ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2025-11-04 19:25:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename mutable flags (#5797)

Browse Source 
This is a minor change on top of #5705
This commit is contained in:
yinyiqian1
2025-09-17 16:43:04 -04:00
committed by GitHub
parent 9494fc9668
commit 37b951859c
6 changed files with 166 additions and 155 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
include/xrpl/protocol/LedgerFormats.h
View File

@@ -188,14 +188,14 @@ enum LedgerSpecificFlags {
lsfMPTCanTransfer = 0x00000020, lsfMPTCanTransfer = 0x00000020,
lsfMPTCanClawback = 0x00000040, lsfMPTCanClawback = 0x00000040,
lsfMPTCanMutateCanLock = 0x00000002, lmfMPTCanMutateCanLock = 0x00000002,
lsfMPTCanMutateRequireAuth = 0x00000004, lmfMPTCanMutateRequireAuth = 0x00000004,
lsfMPTCanMutateCanEscrow = 0x00000008, lmfMPTCanMutateCanEscrow = 0x00000008,
lsfMPTCanMutateCanTrade = 0x00000010, lmfMPTCanMutateCanTrade = 0x00000010,
lsfMPTCanMutateCanTransfer = 0x00000020, lmfMPTCanMutateCanTransfer = 0x00000020,
lsfMPTCanMutateCanClawback = 0x00000040, lmfMPTCanMutateCanClawback = 0x00000040,
lsfMPTCanMutateMetadata = 0x00010000, lmfMPTCanMutateMetadata = 0x00010000,
lsfMPTCanMutateTransferFee = 0x00020000, lmfMPTCanMutateTransferFee = 0x00020000,
// ltMPTOKEN // ltMPTOKEN
lsfMPTAuthorized = 0x00000002, lsfMPTAuthorized = 0x00000002,

54
include/xrpl/protocol/TxFlags.h
View File

@@ -153,17 +153,17 @@ constexpr std::uint32_t const tfMPTokenIssuanceCreateMask =
// MPTokenIssuanceCreate MutableFlags: // MPTokenIssuanceCreate MutableFlags:
// Indicating specific fields or flags may be changed after issuance. // Indicating specific fields or flags may be changed after issuance.
constexpr std::uint32_t const tfMPTCanMutateCanLock = lsfMPTCanMutateCanLock; constexpr std::uint32_t const tmfMPTCanMutateCanLock = lmfMPTCanMutateCanLock;
constexpr std::uint32_t const tfMPTCanMutateRequireAuth = lsfMPTCanMutateRequireAuth; constexpr std::uint32_t const tmfMPTCanMutateRequireAuth = lmfMPTCanMutateRequireAuth;
constexpr std::uint32_t const tfMPTCanMutateCanEscrow = lsfMPTCanMutateCanEscrow; constexpr std::uint32_t const tmfMPTCanMutateCanEscrow = lmfMPTCanMutateCanEscrow;
constexpr std::uint32_t const tfMPTCanMutateCanTrade = lsfMPTCanMutateCanTrade; constexpr std::uint32_t const tmfMPTCanMutateCanTrade = lmfMPTCanMutateCanTrade;
constexpr std::uint32_t const tfMPTCanMutateCanTransfer = lsfMPTCanMutateCanTransfer; constexpr std::uint32_t const tmfMPTCanMutateCanTransfer = lmfMPTCanMutateCanTransfer;
constexpr std::uint32_t const tfMPTCanMutateCanClawback = lsfMPTCanMutateCanClawback; constexpr std::uint32_t const tmfMPTCanMutateCanClawback = lmfMPTCanMutateCanClawback;
constexpr std::uint32_t const tfMPTCanMutateMetadata = lsfMPTCanMutateMetadata; constexpr std::uint32_t const tmfMPTCanMutateMetadata = lmfMPTCanMutateMetadata;
constexpr std::uint32_t const tfMPTCanMutateTransferFee = lsfMPTCanMutateTransferFee; constexpr std::uint32_t const tmfMPTCanMutateTransferFee = lmfMPTCanMutateTransferFee;
constexpr std::uint32_t const tfMPTokenIssuanceCreateMutableMask = constexpr std::uint32_t const tmfMPTokenIssuanceCreateMutableMask =
~(tfMPTCanMutateCanLock | tfMPTCanMutateRequireAuth | tfMPTCanMutateCanEscrow | tfMPTCanMutateCanTrade ~(tmfMPTCanMutateCanLock | tmfMPTCanMutateRequireAuth | tmfMPTCanMutateCanEscrow | tmfMPTCanMutateCanTrade
| tfMPTCanMutateCanTransfer | tfMPTCanMutateCanClawback | tfMPTCanMutateMetadata | tfMPTCanMutateTransferFee); | tmfMPTCanMutateCanTransfer | tmfMPTCanMutateCanClawback | tmfMPTCanMutateMetadata | tmfMPTCanMutateTransferFee);
// MPTokenAuthorize flags: // MPTokenAuthorize flags:
constexpr std::uint32_t const tfMPTUnauthorize = 0x00000001; constexpr std::uint32_t const tfMPTUnauthorize = 0x00000001;
@@ -177,22 +177,22 @@ constexpr std::uint32_t const tfMPTokenIssuanceSetPermissionMask = ~(tfUniversal
// MPTokenIssuanceSet MutableFlags: // MPTokenIssuanceSet MutableFlags:
// Set or Clear flags. // Set or Clear flags.
constexpr std::uint32_t const tfMPTSetCanLock = 0x00000001; constexpr std::uint32_t const tmfMPTSetCanLock = 0x00000001;
constexpr std::uint32_t const tfMPTClearCanLock = 0x00000002; constexpr std::uint32_t const tmfMPTClearCanLock = 0x00000002;
constexpr std::uint32_t const tfMPTSetRequireAuth = 0x00000004; constexpr std::uint32_t const tmfMPTSetRequireAuth = 0x00000004;
constexpr std::uint32_t const tfMPTClearRequireAuth = 0x00000008; constexpr std::uint32_t const tmfMPTClearRequireAuth = 0x00000008;
constexpr std::uint32_t const tfMPTSetCanEscrow = 0x00000010; constexpr std::uint32_t const tmfMPTSetCanEscrow = 0x00000010;
constexpr std::uint32_t const tfMPTClearCanEscrow = 0x00000020; constexpr std::uint32_t const tmfMPTClearCanEscrow = 0x00000020;
constexpr std::uint32_t const tfMPTSetCanTrade = 0x00000040; constexpr std::uint32_t const tmfMPTSetCanTrade = 0x00000040;
constexpr std::uint32_t const tfMPTClearCanTrade = 0x00000080; constexpr std::uint32_t const tmfMPTClearCanTrade = 0x00000080;
constexpr std::uint32_t const tfMPTSetCanTransfer = 0x00000100; constexpr std::uint32_t const tmfMPTSetCanTransfer = 0x00000100;
constexpr std::uint32_t const tfMPTClearCanTransfer = 0x00000200; constexpr std::uint32_t const tmfMPTClearCanTransfer = 0x00000200;
constexpr std::uint32_t const tfMPTSetCanClawback = 0x00000400; constexpr std::uint32_t const tmfMPTSetCanClawback = 0x00000400;
constexpr std::uint32_t const tfMPTClearCanClawback = 0x00000800; constexpr std::uint32_t const tmfMPTClearCanClawback = 0x00000800;
constexpr std::uint32_t const tfMPTokenIssuanceSetMutableMask = ~(tfMPTSetCanLock | tfMPTClearCanLock | constexpr std::uint32_t const tmfMPTokenIssuanceSetMutableMask = ~(tmfMPTSetCanLock | tmfMPTClearCanLock |
tfMPTSetRequireAuth | tfMPTClearRequireAuth | tfMPTSetCanEscrow | tfMPTClearCanEscrow | tmfMPTSetRequireAuth | tmfMPTClearRequireAuth | tmfMPTSetCanEscrow | tmfMPTClearCanEscrow |
tfMPTSetCanTrade | tfMPTClearCanTrade | tfMPTSetCanTransfer | tfMPTClearCanTransfer | tmfMPTSetCanTrade | tmfMPTClearCanTrade | tmfMPTSetCanTransfer | tmfMPTClearCanTransfer |
tfMPTSetCanClawback | tfMPTClearCanClawback); tmfMPTSetCanClawback | tmfMPTClearCanClawback);
// MPTokenIssuanceDestroy flags: // MPTokenIssuanceDestroy flags:
constexpr std::uint32_t const tfMPTokenIssuanceDestroyMask = ~tfUniversal; constexpr std::uint32_t const tfMPTokenIssuanceDestroyMask = ~tfUniversal;

199
src/test/app/MPToken_test.cpp
View File

@@ -2871,8 +2871,8 @@ class MPToken_test : public beast::unit_test::suite
MPTTester mptAlice(env, alice, {.holders = {bob}}); MPTTester mptAlice(env, alice, {.holders = {bob}});
mptAlice.create( mptAlice.create(
{.ownerCount = 1, {.ownerCount = 1,
.mutableFlags = tfMPTCanMutateMetadata | .mutableFlags = tmfMPTCanMutateMetadata |
tfMPTCanMutateCanLock | tfMPTCanMutateTransferFee}); tmfMPTCanMutateCanLock | tmfMPTCanMutateTransferFee});
// Setting flags is not allowed when MutableFlags is present // Setting flags is not allowed when MutableFlags is present
mptAlice.set( mptAlice.set(
@@ -2906,7 +2906,7 @@ class MPToken_test : public beast::unit_test::suite
.ownerCount = 1, .ownerCount = 1,
.flags = tfMPTCanTransfer, .flags = tfMPTCanTransfer,
.mutableFlags = .mutableFlags =
tfMPTCanMutateTransferFee | tfMPTCanMutateMetadata}); tmfMPTCanMutateTransferFee | tmfMPTCanMutateMetadata});
mptAlice.set( mptAlice.set(
{.account = alice, {.account = alice,
@@ -2943,15 +2943,15 @@ class MPToken_test : public beast::unit_test::suite
auto const mptID = makeMptID(env.seq(alice), alice); auto const mptID = makeMptID(env.seq(alice), alice);
auto const flagCombinations = { auto const flagCombinations = {
tfMPTSetCanLock | tfMPTClearCanLock, tmfMPTSetCanLock | tmfMPTClearCanLock,
tfMPTSetRequireAuth | tfMPTClearRequireAuth, tmfMPTSetRequireAuth | tmfMPTClearRequireAuth,
tfMPTSetCanEscrow | tfMPTClearCanEscrow, tmfMPTSetCanEscrow | tmfMPTClearCanEscrow,
tfMPTSetCanTrade | tfMPTClearCanTrade, tmfMPTSetCanTrade | tmfMPTClearCanTrade,
tfMPTSetCanTransfer | tfMPTClearCanTransfer, tmfMPTSetCanTransfer | tmfMPTClearCanTransfer,
tfMPTSetCanClawback | tfMPTClearCanClawback, tmfMPTSetCanClawback | tmfMPTClearCanClawback,
tfMPTSetCanLock | tfMPTClearCanLock | tfMPTClearCanTrade, tmfMPTSetCanLock | tmfMPTClearCanLock | tmfMPTClearCanTrade,
tfMPTSetCanTransfer | tfMPTClearCanTransfer | tmfMPTSetCanTransfer | tmfMPTClearCanTransfer |
tfMPTSetCanEscrow | tfMPTClearCanClawback}; tmfMPTSetCanEscrow | tmfMPTClearCanClawback};
for (auto const& mutableFlags : flagCombinations) for (auto const& mutableFlags : flagCombinations)
{ {
@@ -2971,18 +2971,18 @@ class MPToken_test : public beast::unit_test::suite
mptAlice.create({.ownerCount = 1}); mptAlice.create({.ownerCount = 1});
auto const mutableFlags = { auto const mutableFlags = {
tfMPTSetCanLock, tmfMPTSetCanLock,
tfMPTClearCanLock, tmfMPTClearCanLock,
tfMPTSetRequireAuth, tmfMPTSetRequireAuth,
tfMPTClearRequireAuth, tmfMPTClearRequireAuth,
tfMPTSetCanEscrow, tmfMPTSetCanEscrow,
tfMPTClearCanEscrow, tmfMPTClearCanEscrow,
tfMPTSetCanTrade, tmfMPTSetCanTrade,
tfMPTClearCanTrade, tmfMPTClearCanTrade,
tfMPTSetCanTransfer, tmfMPTSetCanTransfer,
tfMPTClearCanTransfer, tmfMPTClearCanTransfer,
tfMPTSetCanClawback, tmfMPTSetCanClawback,
tfMPTClearCanClawback}; tmfMPTClearCanClawback};
for (auto const& mutableFlag : mutableFlags) for (auto const& mutableFlag : mutableFlags)
{ {
@@ -2999,7 +2999,7 @@ class MPToken_test : public beast::unit_test::suite
MPTTester mptAlice(env, alice, {.holders = {bob}}); MPTTester mptAlice(env, alice, {.holders = {bob}});
mptAlice.create( mptAlice.create(
{.ownerCount = 1, .mutableFlags = tfMPTCanMutateMetadata}); {.ownerCount = 1, .mutableFlags = tmfMPTCanMutateMetadata});
std::string metadata(maxMPTokenMetadataLength + 1, 'a'); std::string metadata(maxMPTokenMetadataLength + 1, 'a');
mptAlice.set( mptAlice.set(
@@ -3025,7 +3025,7 @@ class MPToken_test : public beast::unit_test::suite
auto const mptID = makeMptID(env.seq(alice), alice); auto const mptID = makeMptID(env.seq(alice), alice);
mptAlice.create( mptAlice.create(
{.ownerCount = 1, .mutableFlags = tfMPTCanMutateTransferFee}); {.ownerCount = 1, .mutableFlags = tmfMPTCanMutateTransferFee});
mptAlice.set( mptAlice.set(
{.account = alice, {.account = alice,
@@ -3045,13 +3045,13 @@ class MPToken_test : public beast::unit_test::suite
.ownerCount = 1, .ownerCount = 1,
.flags = tfMPTCanTransfer, .flags = tfMPTCanTransfer,
.mutableFlags = .mutableFlags =
tfMPTCanMutateTransferFee | tfMPTCanMutateCanTransfer}); tmfMPTCanMutateTransferFee | tmfMPTCanMutateCanTransfer});
// Can not set non-zero transfer fee and clear MPTCanTransfer at the // Can not set non-zero transfer fee and clear MPTCanTransfer at the
// same time // same time
mptAlice.set( mptAlice.set(
{.account = alice, {.account = alice,
.mutableFlags = tfMPTClearCanTransfer, .mutableFlags = tmfMPTClearCanTransfer,
.transferFee = 1, .transferFee = 1,
.err = temMALFORMED}); .err = temMALFORMED});
@@ -3060,7 +3060,7 @@ class MPToken_test : public beast::unit_test::suite
// be removed. // be removed.
mptAlice.set( mptAlice.set(
{.account = alice, {.account = alice,
.mutableFlags = tfMPTClearCanTransfer, .mutableFlags = tmfMPTClearCanTransfer,
.transferFee = 0}); .transferFee = 0});
BEAST_EXPECT(!mptAlice.isTransferFeePresent()); BEAST_EXPECT(!mptAlice.isTransferFeePresent());
} }
@@ -3073,7 +3073,7 @@ class MPToken_test : public beast::unit_test::suite
mptAlice.create( mptAlice.create(
{.ownerCount = 1, {.ownerCount = 1,
.mutableFlags = .mutableFlags =
tfMPTCanMutateTransferFee | tfMPTCanMutateCanTransfer}); tmfMPTCanMutateTransferFee | tmfMPTCanMutateCanTransfer});
mptAlice.set( mptAlice.set(
{.account = alice, {.account = alice,
@@ -3085,7 +3085,7 @@ class MPToken_test : public beast::unit_test::suite
// fee can be set in a separate transaction. // fee can be set in a separate transaction.
mptAlice.set( mptAlice.set(
{.account = alice, {.account = alice,
.mutableFlags = tfMPTSetCanTransfer, .mutableFlags = tmfMPTSetCanTransfer,
.transferFee = 100, .transferFee = 100,
.err = tecNO_PERMISSION}); .err = tecNO_PERMISSION});
} }
@@ -3116,8 +3116,8 @@ class MPToken_test : public beast::unit_test::suite
mptAlice.create( mptAlice.create(
{.ownerCount = 1, {.ownerCount = 1,
.mutableFlags = tfMPTCanMutateCanTrade | .mutableFlags = tmfMPTCanMutateCanTrade |
tfMPTCanMutateCanTransfer | tfMPTCanMutateMetadata}); tmfMPTCanMutateCanTransfer | tmfMPTCanMutateMetadata});
// Can not mutate transfer fee // Can not mutate transfer fee
mptAlice.set( mptAlice.set(
@@ -3126,14 +3126,14 @@ class MPToken_test : public beast::unit_test::suite
.err = tecNO_PERMISSION}); .err = tecNO_PERMISSION});
auto const invalidFlags = { auto const invalidFlags = {
tfMPTSetCanLock, tmfMPTSetCanLock,
tfMPTClearCanLock, tmfMPTClearCanLock,
tfMPTSetRequireAuth, tmfMPTSetRequireAuth,
tfMPTClearRequireAuth, tmfMPTClearRequireAuth,
tfMPTSetCanEscrow, tmfMPTSetCanEscrow,
tfMPTClearCanEscrow, tmfMPTClearCanEscrow,
tfMPTSetCanClawback, tmfMPTSetCanClawback,
tfMPTClearCanClawback}; tmfMPTClearCanClawback};
// Can not mutate flags which are not mutable // Can not mutate flags which are not mutable
for (auto const& mutableFlag : invalidFlags) for (auto const& mutableFlag : invalidFlags)
@@ -3145,15 +3145,15 @@ class MPToken_test : public beast::unit_test::suite
} }
// Can mutate MPTCanTrade // Can mutate MPTCanTrade
mptAlice.set({.account = alice, .mutableFlags = tfMPTSetCanTrade}); mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetCanTrade});
mptAlice.set( mptAlice.set(
{.account = alice, .mutableFlags = tfMPTClearCanTrade}); {.account = alice, .mutableFlags = tmfMPTClearCanTrade});
// Can mutate MPTCanTransfer // Can mutate MPTCanTransfer
mptAlice.set( mptAlice.set(
{.account = alice, .mutableFlags = tfMPTSetCanTransfer}); {.account = alice, .mutableFlags = tmfMPTSetCanTransfer});
mptAlice.set( mptAlice.set(
{.account = alice, .mutableFlags = tfMPTClearCanTransfer}); {.account = alice, .mutableFlags = tmfMPTClearCanTransfer});
// Can mutate metadata // Can mutate metadata
mptAlice.set({.account = alice, .metadata = "test"}); mptAlice.set({.account = alice, .metadata = "test"});
@@ -3176,7 +3176,7 @@ class MPToken_test : public beast::unit_test::suite
mptAlice.create( mptAlice.create(
{.metadata = "test", {.metadata = "test",
.ownerCount = 1, .ownerCount = 1,
.mutableFlags = tfMPTCanMutateMetadata}); .mutableFlags = tmfMPTCanMutateMetadata});
std::vector<std::string> metadatas = { std::vector<std::string> metadatas = {
"mutate metadata", "mutate metadata",
@@ -3206,7 +3206,7 @@ class MPToken_test : public beast::unit_test::suite
.metadata = "test", .metadata = "test",
.ownerCount = 1, .ownerCount = 1,
.flags = tfMPTCanTransfer, .flags = tfMPTCanTransfer,
.mutableFlags = tfMPTCanMutateTransferFee}); .mutableFlags = tmfMPTCanMutateTransferFee});
for (std::uint16_t const fee : std::initializer_list<std::uint16_t>{ for (std::uint16_t const fee : std::initializer_list<std::uint16_t>{
1, 10, 100, 200, 500, 1000, maxTransferFee}) 1, 10, 100, 200, 500, 1000, maxTransferFee})
@@ -3250,25 +3250,27 @@ class MPToken_test : public beast::unit_test::suite
}; };
testFlagToggle( testFlagToggle(
tfMPTCanMutateCanLock, tfMPTCanLock, tfMPTClearCanLock); tmfMPTCanMutateCanLock, tfMPTCanLock, tmfMPTClearCanLock);
testFlagToggle( testFlagToggle(
tfMPTCanMutateRequireAuth, tmfMPTCanMutateRequireAuth,
tfMPTSetRequireAuth, tmfMPTSetRequireAuth,
tfMPTClearRequireAuth); tmfMPTClearRequireAuth);
testFlagToggle( testFlagToggle(
tfMPTCanMutateCanEscrow, tmfMPTCanMutateCanEscrow,
tfMPTSetCanEscrow, tmfMPTSetCanEscrow,
tfMPTClearCanEscrow); tmfMPTClearCanEscrow);
testFlagToggle( testFlagToggle(
tfMPTCanMutateCanTrade, tfMPTSetCanTrade, tfMPTClearCanTrade); tmfMPTCanMutateCanTrade,
tmfMPTSetCanTrade,
tmfMPTClearCanTrade);
testFlagToggle( testFlagToggle(
tfMPTCanMutateCanTransfer, tmfMPTCanMutateCanTransfer,
tfMPTSetCanTransfer, tmfMPTSetCanTransfer,
tfMPTClearCanTransfer); tmfMPTClearCanTransfer);
testFlagToggle( testFlagToggle(
tfMPTCanMutateCanClawback, tmfMPTCanMutateCanClawback,
tfMPTSetCanClawback, tmfMPTSetCanClawback,
tfMPTClearCanClawback); tmfMPTClearCanClawback);
} }
} }
@@ -3289,20 +3291,22 @@ class MPToken_test : public beast::unit_test::suite
{.ownerCount = 1, {.ownerCount = 1,
.holderCount = 0, .holderCount = 0,
.flags = tfMPTCanLock | tfMPTCanTransfer, .flags = tfMPTCanLock | tfMPTCanTransfer,
.mutableFlags = tfMPTCanMutateCanLock | .mutableFlags = tmfMPTCanMutateCanLock |
tfMPTCanMutateCanTrade | tfMPTCanMutateTransferFee}); tmfMPTCanMutateCanTrade | tmfMPTCanMutateTransferFee});
mptAlice.authorize({.account = bob, .holderCount = 1}); mptAlice.authorize({.account = bob, .holderCount = 1});
// Lock bob's mptoken // Lock bob's mptoken
mptAlice.set({.account = alice, .holder = bob, .flags = tfMPTLock}); mptAlice.set({.account = alice, .holder = bob, .flags = tfMPTLock});
// Can mutate the mutable flags and fields // Can mutate the mutable flags and fields
mptAlice.set({.account = alice, .mutableFlags = tfMPTClearCanLock});
mptAlice.set({.account = alice, .mutableFlags = tfMPTSetCanLock});
mptAlice.set({.account = alice, .mutableFlags = tfMPTClearCanLock});
mptAlice.set({.account = alice, .mutableFlags = tfMPTSetCanTrade});
mptAlice.set( mptAlice.set(
{.account = alice, .mutableFlags = tfMPTClearCanTrade}); {.account = alice, .mutableFlags = tmfMPTClearCanLock});
mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetCanLock});
mptAlice.set(
{.account = alice, .mutableFlags = tmfMPTClearCanLock});
mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetCanTrade});
mptAlice.set(
{.account = alice, .mutableFlags = tmfMPTClearCanTrade});
mptAlice.set({.account = alice, .transferFee = 200}); mptAlice.set({.account = alice, .transferFee = 200});
} }
@@ -3314,21 +3318,23 @@ class MPToken_test : public beast::unit_test::suite
{.ownerCount = 1, {.ownerCount = 1,
.holderCount = 0, .holderCount = 0,
.flags = tfMPTCanLock, .flags = tfMPTCanLock,
.mutableFlags = tfMPTCanMutateCanLock | .mutableFlags = tmfMPTCanMutateCanLock |
tfMPTCanMutateCanClawback | tfMPTCanMutateMetadata}); tmfMPTCanMutateCanClawback | tmfMPTCanMutateMetadata});
mptAlice.authorize({.account = bob, .holderCount = 1}); mptAlice.authorize({.account = bob, .holderCount = 1});
// Lock issuance // Lock issuance
mptAlice.set({.account = alice, .flags = tfMPTLock}); mptAlice.set({.account = alice, .flags = tfMPTLock});
// Can mutate the mutable flags and fields // Can mutate the mutable flags and fields
mptAlice.set({.account = alice, .mutableFlags = tfMPTClearCanLock});
mptAlice.set({.account = alice, .mutableFlags = tfMPTSetCanLock});
mptAlice.set({.account = alice, .mutableFlags = tfMPTClearCanLock});
mptAlice.set( mptAlice.set(
{.account = alice, .mutableFlags = tfMPTSetCanClawback}); {.account = alice, .mutableFlags = tmfMPTClearCanLock});
mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetCanLock});
mptAlice.set( mptAlice.set(
{.account = alice, .mutableFlags = tfMPTClearCanClawback}); {.account = alice, .mutableFlags = tmfMPTClearCanLock});
mptAlice.set(
{.account = alice, .mutableFlags = tmfMPTSetCanClawback});
mptAlice.set(
{.account = alice, .mutableFlags = tmfMPTClearCanClawback});
mptAlice.set({.account = alice, .metadata = "mutate"}); mptAlice.set({.account = alice, .metadata = "mutate"});
} }
@@ -3340,8 +3346,8 @@ class MPToken_test : public beast::unit_test::suite
{.ownerCount = 1, {.ownerCount = 1,
.holderCount = 0, .holderCount = 0,
.flags = tfMPTCanLock, .flags = tfMPTCanLock,
.mutableFlags = tfMPTCanMutateCanLock | .mutableFlags = tmfMPTCanMutateCanLock |
tfMPTCanMutateCanClawback | tfMPTCanMutateMetadata}); tmfMPTCanMutateCanClawback | tmfMPTCanMutateMetadata});
mptAlice.authorize({.account = bob, .holderCount = 1}); mptAlice.authorize({.account = bob, .holderCount = 1});
// Can lock and unlock // Can lock and unlock
@@ -3352,7 +3358,8 @@ class MPToken_test : public beast::unit_test::suite
{.account = alice, .holder = bob, .flags = tfMPTUnlock}); {.account = alice, .holder = bob, .flags = tfMPTUnlock});
// Clear lsfMPTCanLock // Clear lsfMPTCanLock
mptAlice.set({.account = alice, .mutableFlags = tfMPTClearCanLock}); mptAlice.set(
{.account = alice, .mutableFlags = tmfMPTClearCanLock});
// Can not lock or unlock // Can not lock or unlock
mptAlice.set( mptAlice.set(
@@ -3375,7 +3382,7 @@ class MPToken_test : public beast::unit_test::suite
.err = tecNO_PERMISSION}); .err = tecNO_PERMISSION});
// Set MPTCanLock again // Set MPTCanLock again
mptAlice.set({.account = alice, .mutableFlags = tfMPTSetCanLock}); mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetCanLock});
// Can lock and unlock again // Can lock and unlock again
mptAlice.set({.account = alice, .flags = tfMPTLock}); mptAlice.set({.account = alice, .flags = tfMPTLock});
@@ -3400,7 +3407,7 @@ class MPToken_test : public beast::unit_test::suite
mptAlice.create( mptAlice.create(
{.ownerCount = 1, {.ownerCount = 1,
.flags = tfMPTRequireAuth, .flags = tfMPTRequireAuth,
.mutableFlags = tfMPTCanMutateRequireAuth}); .mutableFlags = tmfMPTCanMutateRequireAuth});
mptAlice.authorize({.account = bob}); mptAlice.authorize({.account = bob});
mptAlice.authorize({.account = alice, .holder = bob}); mptAlice.authorize({.account = alice, .holder = bob});
@@ -3416,13 +3423,14 @@ class MPToken_test : public beast::unit_test::suite
mptAlice.pay(bob, alice, 100, tecNO_AUTH); mptAlice.pay(bob, alice, 100, tecNO_AUTH);
// Clear RequireAuth // Clear RequireAuth
mptAlice.set({.account = alice, .mutableFlags = tfMPTClearRequireAuth}); mptAlice.set(
{.account = alice, .mutableFlags = tmfMPTClearRequireAuth});
// Can pay to bob // Can pay to bob
mptAlice.pay(alice, bob, 1000); mptAlice.pay(alice, bob, 1000);
// Set RequireAuth again // Set RequireAuth again
mptAlice.set({.account = alice, .mutableFlags = tfMPTSetRequireAuth}); mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetRequireAuth});
// Can not pay to bob since he is not authorized // Can not pay to bob since he is not authorized
mptAlice.pay(bob, alice, 100, tecNO_AUTH); mptAlice.pay(bob, alice, 100, tecNO_AUTH);
@@ -3452,7 +3460,7 @@ class MPToken_test : public beast::unit_test::suite
{.ownerCount = 1, {.ownerCount = 1,
.holderCount = 0, .holderCount = 0,
.flags = tfMPTCanTransfer, .flags = tfMPTCanTransfer,
.mutableFlags = tfMPTCanMutateCanEscrow}); .mutableFlags = tmfMPTCanMutateCanEscrow});
mptAlice.authorize({.account = carol}); mptAlice.authorize({.account = carol});
mptAlice.authorize({.account = bob}); mptAlice.authorize({.account = bob});
@@ -3469,14 +3477,14 @@ class MPToken_test : public beast::unit_test::suite
ter(tecNO_PERMISSION)); ter(tecNO_PERMISSION));
// MPTCanEscrow is enabled now // MPTCanEscrow is enabled now
mptAlice.set({.account = alice, .mutableFlags = tfMPTSetCanEscrow}); mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetCanEscrow});
env(escrow::create(carol, bob, MPT(3)), env(escrow::create(carol, bob, MPT(3)),
escrow::condition(escrow::cb1), escrow::condition(escrow::cb1),
escrow::finish_time(env.now() + 1s), escrow::finish_time(env.now() + 1s),
fee(baseFee * 150)); fee(baseFee * 150));
// Clear MPTCanEscrow // Clear MPTCanEscrow
mptAlice.set({.account = alice, .mutableFlags = tfMPTClearCanEscrow}); mptAlice.set({.account = alice, .mutableFlags = tmfMPTClearCanEscrow});
env(escrow::create(carol, bob, MPT(3)), env(escrow::create(carol, bob, MPT(3)),
escrow::condition(escrow::cb1), escrow::condition(escrow::cb1),
escrow::finish_time(env.now() + 1s), escrow::finish_time(env.now() + 1s),
@@ -3501,7 +3509,7 @@ class MPToken_test : public beast::unit_test::suite
mptAlice.create( mptAlice.create(
{.ownerCount = 1, {.ownerCount = 1,
.mutableFlags = .mutableFlags =
tfMPTCanMutateCanTransfer | tfMPTCanMutateTransferFee}); tmfMPTCanMutateCanTransfer | tmfMPTCanMutateTransferFee});
mptAlice.authorize({.account = bob}); mptAlice.authorize({.account = bob});
mptAlice.authorize({.account = carol}); mptAlice.authorize({.account = carol});
@@ -3522,13 +3530,13 @@ class MPToken_test : public beast::unit_test::suite
// MPTCanTransfer at the same time // MPTCanTransfer at the same time
mptAlice.set( mptAlice.set(
{.account = alice, {.account = alice,
.mutableFlags = tfMPTSetCanTransfer, .mutableFlags = tmfMPTSetCanTransfer,
.transferFee = 100, .transferFee = 100,
.err = tecNO_PERMISSION}); .err = tecNO_PERMISSION});
// Alice sets MPTCanTransfer // Alice sets MPTCanTransfer
mptAlice.set( mptAlice.set(
{.account = alice, .mutableFlags = tfMPTSetCanTransfer}); {.account = alice, .mutableFlags = tmfMPTSetCanTransfer});
// Can set transfer fee now // Can set transfer fee now
BEAST_EXPECT(!mptAlice.isTransferFeePresent()); BEAST_EXPECT(!mptAlice.isTransferFeePresent());
@@ -3540,7 +3548,7 @@ class MPToken_test : public beast::unit_test::suite
// Alice clears MPTCanTransfer // Alice clears MPTCanTransfer
mptAlice.set( mptAlice.set(
{.account = alice, .mutableFlags = tfMPTClearCanTransfer}); {.account = alice, .mutableFlags = tmfMPTClearCanTransfer});
// TransferFee field is removed when MPTCanTransfer is cleared // TransferFee field is removed when MPTCanTransfer is cleared
BEAST_EXPECT(!mptAlice.isTransferFeePresent()); BEAST_EXPECT(!mptAlice.isTransferFeePresent());
@@ -3550,7 +3558,7 @@ class MPToken_test : public beast::unit_test::suite
} }
// Can set transfer fee to zero when MPTCanTransfer is not set, but // Can set transfer fee to zero when MPTCanTransfer is not set, but
// tfMPTCanMutateTransferFee is set. // tmfMPTCanMutateTransferFee is set.
{ {
Env env{*this, features}; Env env{*this, features};
@@ -3560,13 +3568,13 @@ class MPToken_test : public beast::unit_test::suite
.ownerCount = 1, .ownerCount = 1,
.flags = tfMPTCanTransfer, .flags = tfMPTCanTransfer,
.mutableFlags = .mutableFlags =
tfMPTCanMutateTransferFee | tfMPTCanMutateCanTransfer}); tmfMPTCanMutateTransferFee | tmfMPTCanMutateCanTransfer});
BEAST_EXPECT(mptAlice.checkTransferFee(100)); BEAST_EXPECT(mptAlice.checkTransferFee(100));
// Clear MPTCanTransfer and transfer fee is removed // Clear MPTCanTransfer and transfer fee is removed
mptAlice.set( mptAlice.set(
{.account = alice, .mutableFlags = tfMPTClearCanTransfer}); {.account = alice, .mutableFlags = tmfMPTClearCanTransfer});
BEAST_EXPECT(!mptAlice.isTransferFeePresent()); BEAST_EXPECT(!mptAlice.isTransferFeePresent());
// Can still set transfer fee to zero, although it is already zero // Can still set transfer fee to zero, although it is already zero
@@ -3592,7 +3600,7 @@ class MPToken_test : public beast::unit_test::suite
mptAlice.create( mptAlice.create(
{.ownerCount = 1, {.ownerCount = 1,
.holderCount = 0, .holderCount = 0,
.mutableFlags = tfMPTCanMutateCanClawback}); .mutableFlags = tmfMPTCanMutateCanClawback});
// Bob creates an MPToken // Bob creates an MPToken
mptAlice.authorize({.account = bob}); mptAlice.authorize({.account = bob});
@@ -3604,13 +3612,14 @@ class MPToken_test : public beast::unit_test::suite
mptAlice.claw(alice, bob, 1, tecNO_PERMISSION); mptAlice.claw(alice, bob, 1, tecNO_PERMISSION);
// Enable MPTCanClawback // Enable MPTCanClawback
mptAlice.set({.account = alice, .mutableFlags = tfMPTSetCanClawback}); mptAlice.set({.account = alice, .mutableFlags = tmfMPTSetCanClawback});
// Can clawback now // Can clawback now
mptAlice.claw(alice, bob, 1); mptAlice.claw(alice, bob, 1);
// Clear MPTCanClawback // Clear MPTCanClawback
mptAlice.set({.account = alice, .mutableFlags = tfMPTClearCanClawback}); mptAlice.set(
{.account = alice, .mutableFlags = tmfMPTClearCanClawback});
// Can not clawback // Can not clawback
mptAlice.claw(alice, bob, 1, tecNO_PERMISSION); mptAlice.claw(alice, bob, 1, tecNO_PERMISSION);

24
src/test/jtx/impl/mpt.cpp
View File

@@ -265,34 +265,34 @@ MPTTester::set(MPTSet const& arg)
if (arg.mutableFlags) if (arg.mutableFlags)
{ {
if (*arg.mutableFlags & tfMPTSetCanLock) if (*arg.mutableFlags & tmfMPTSetCanLock)
flags |= lsfMPTCanLock; flags |= lsfMPTCanLock;
else if (*arg.mutableFlags & tfMPTClearCanLock) else if (*arg.mutableFlags & tmfMPTClearCanLock)
flags &= ~lsfMPTCanLock; flags &= ~lsfMPTCanLock;
if (*arg.mutableFlags & tfMPTSetRequireAuth) if (*arg.mutableFlags & tmfMPTSetRequireAuth)
flags |= lsfMPTRequireAuth; flags |= lsfMPTRequireAuth;
else if (*arg.mutableFlags & tfMPTClearRequireAuth) else if (*arg.mutableFlags & tmfMPTClearRequireAuth)
flags &= ~lsfMPTRequireAuth; flags &= ~lsfMPTRequireAuth;
if (*arg.mutableFlags & tfMPTSetCanEscrow) if (*arg.mutableFlags & tmfMPTSetCanEscrow)
flags |= lsfMPTCanEscrow; flags |= lsfMPTCanEscrow;
else if (*arg.mutableFlags & tfMPTClearCanEscrow) else if (*arg.mutableFlags & tmfMPTClearCanEscrow)
flags &= ~lsfMPTCanEscrow; flags &= ~lsfMPTCanEscrow;
if (*arg.mutableFlags & tfMPTSetCanClawback) if (*arg.mutableFlags & tmfMPTSetCanClawback)
flags |= lsfMPTCanClawback; flags |= lsfMPTCanClawback;
else if (*arg.mutableFlags & tfMPTClearCanClawback) else if (*arg.mutableFlags & tmfMPTClearCanClawback)
flags &= ~lsfMPTCanClawback; flags &= ~lsfMPTCanClawback;
if (*arg.mutableFlags & tfMPTSetCanTrade) if (*arg.mutableFlags & tmfMPTSetCanTrade)
flags |= lsfMPTCanTrade; flags |= lsfMPTCanTrade;
else if (*arg.mutableFlags & tfMPTClearCanTrade) else if (*arg.mutableFlags & tmfMPTClearCanTrade)
flags &= ~lsfMPTCanTrade; flags &= ~lsfMPTCanTrade;
if (*arg.mutableFlags & tfMPTSetCanTransfer) if (*arg.mutableFlags & tmfMPTSetCanTransfer)
flags |= lsfMPTCanTransfer; flags |= lsfMPTCanTransfer;
else if (*arg.mutableFlags & tfMPTClearCanTransfer) else if (*arg.mutableFlags & tmfMPTClearCanTransfer)
flags &= ~lsfMPTCanTransfer; flags &= ~lsfMPTCanTransfer;
} }
} }

2
src/xrpld/app/tx/detail/MPTokenIssuanceCreate.cpp
View File

@@ -44,7 +44,7 @@ MPTokenIssuanceCreate::preflight(PreflightContext const& ctx)
return ret; return ret;
if (auto const mutableFlags = ctx.tx[~sfMutableFlags]; mutableFlags && if (auto const mutableFlags = ctx.tx[~sfMutableFlags]; mutableFlags &&
(!*mutableFlags || *mutableFlags & tfMPTokenIssuanceCreateMutableMask)) (!*mutableFlags || *mutableFlags & tmfMPTokenIssuanceCreateMutableMask))
return temINVALID_FLAG; return temINVALID_FLAG;
if (ctx.tx.getFlags() & tfMPTokenIssuanceCreateMask) if (ctx.tx.getFlags() & tfMPTokenIssuanceCreateMask)

26
src/xrpld/app/tx/detail/MPTokenIssuanceSet.cpp
View File

@@ -37,12 +37,14 @@ struct MPTMutabilityFlags
}; };
static constexpr std::array<MPTMutabilityFlags, 6> mptMutabilityFlags = { static constexpr std::array<MPTMutabilityFlags, 6> mptMutabilityFlags = {
{{tfMPTSetCanLock, tfMPTClearCanLock, lsfMPTCanMutateCanLock}, {{tmfMPTSetCanLock, tmfMPTClearCanLock, lmfMPTCanMutateCanLock},
{tfMPTSetRequireAuth, tfMPTClearRequireAuth, lsfMPTCanMutateRequireAuth}, {tmfMPTSetRequireAuth, tmfMPTClearRequireAuth, lmfMPTCanMutateRequireAuth},
{tfMPTSetCanEscrow, tfMPTClearCanEscrow, lsfMPTCanMutateCanEscrow}, {tmfMPTSetCanEscrow, tmfMPTClearCanEscrow, lmfMPTCanMutateCanEscrow},
{tfMPTSetCanTrade, tfMPTClearCanTrade, lsfMPTCanMutateCanTrade}, {tmfMPTSetCanTrade, tmfMPTClearCanTrade, lmfMPTCanMutateCanTrade},
{tfMPTSetCanTransfer, tfMPTClearCanTransfer, lsfMPTCanMutateCanTransfer}, {tmfMPTSetCanTransfer, tmfMPTClearCanTransfer, lmfMPTCanMutateCanTransfer},
{tfMPTSetCanClawback, tfMPTClearCanClawback, lsfMPTCanMutateCanClawback}}}; {tmfMPTSetCanClawback,
tmfMPTClearCanClawback,
lmfMPTCanMutateCanClawback}}};
NotTEC NotTEC
MPTokenIssuanceSet::preflight(PreflightContext const& ctx) MPTokenIssuanceSet::preflight(PreflightContext const& ctx)
@@ -110,7 +112,7 @@ MPTokenIssuanceSet::preflight(PreflightContext const& ctx)
if (mutableFlags) if (mutableFlags)
{ {
if (!*mutableFlags || if (!*mutableFlags ||
(*mutableFlags & tfMPTokenIssuanceSetMutableMask)) (*mutableFlags & tmfMPTokenIssuanceSetMutableMask))
return temINVALID_FLAG; return temINVALID_FLAG;
// Can not set and clear the same flag // Can not set and clear the same flag
@@ -126,7 +128,7 @@ MPTokenIssuanceSet::preflight(PreflightContext const& ctx)
// Trying to set a non-zero TransferFee and clear MPTCanTransfer // Trying to set a non-zero TransferFee and clear MPTCanTransfer
// in the same transaction is not allowed. // in the same transaction is not allowed.
if (transferFee.value_or(0) && if (transferFee.value_or(0) &&
(*mutableFlags & tfMPTClearCanTransfer)) (*mutableFlags & tmfMPTClearCanTransfer))
return temMALFORMED; return temMALFORMED;
} }
} }
@@ -241,7 +243,7 @@ MPTokenIssuanceSet::preclaim(PreclaimContext const& ctx)
return tecNO_PERMISSION; return tecNO_PERMISSION;
} }
if (!isMutableFlag(lsfMPTCanMutateMetadata) && if (!isMutableFlag(lmfMPTCanMutateMetadata) &&
ctx.tx.isFieldPresent(sfMPTokenMetadata)) ctx.tx.isFieldPresent(sfMPTokenMetadata))
return tecNO_PERMISSION; return tecNO_PERMISSION;
@@ -249,12 +251,12 @@ MPTokenIssuanceSet::preclaim(PreclaimContext const& ctx)
{ {
// A non-zero TransferFee is only valid if the lsfMPTCanTransfer flag // A non-zero TransferFee is only valid if the lsfMPTCanTransfer flag
// was previously enabled (at issuance or via a prior mutation). Setting // was previously enabled (at issuance or via a prior mutation). Setting
// it by tfMPTSetCanTransfer in the current transaction does not meet // it by tmfMPTSetCanTransfer in the current transaction does not meet
// this requirement. // this requirement.
if (fee > 0u && !sleMptIssuance->isFlag(lsfMPTCanTransfer)) if (fee > 0u && !sleMptIssuance->isFlag(lsfMPTCanTransfer))
return tecNO_PERMISSION; return tecNO_PERMISSION;
if (!isMutableFlag(lsfMPTCanMutateTransferFee)) if (!isMutableFlag(lmfMPTCanMutateTransferFee))
return tecNO_PERMISSION; return tecNO_PERMISSION;
} }
@@ -296,7 +298,7 @@ MPTokenIssuanceSet::doApply()
flagsOut &= ~f.canMutateFlag; flagsOut &= ~f.canMutateFlag;
} }
if (mutableFlags & tfMPTClearCanTransfer) if (mutableFlags & tmfMPTClearCanTransfer)
{ {
// If the lsfMPTCanTransfer flag is being cleared, then also clear // If the lsfMPTCanTransfer flag is being cleared, then also clear
// the TransferFee field. // the TransferFee field.