chore: Update libxrpl to 3.3.0 (#3170)

2026-08-19 03:30:53 +00:00 · 2026-08-12 09:57:52 +01:00
parent dbdbe4ea1f
commit 62428a2d91
7 changed files with 101 additions and 92 deletions
--- a/conan.lock
+++ b/conan.lock
@@ -3,7 +3,7 @@
    "requires": [
        "zlib/1.3.2#1cb806da49011867778ffb6ac7190fcb%1782392402.122708",
        "xxhash/0.8.3#681d36a0a6111fc56e5e45ea182c19cc%1782392402.420688",
-        "xrpl/3.3.0-rc1-custom#cdfb12fc2671eaea72d5920bea800fd2%1785426802.141277",
+        "xrpl/3.3.0#5e356a24ae1f0d6da6bd617b926f92e6%1786467262.262007",
        "sqlite3/3.53.0#324ada52333108388a9a6108bfa96734%1782392403.185447",
        "spdlog/1.17.0#bcbaaf7147bda6ad24ffbd1ac3d7142c%1782736610.443882",
        "soci/4.0.3#e726491a03468795453f7c83fc924a96%1782392402.679521",
@@ -15,7 +15,7 @@
        "protobuf/6.33.5#ff253ead763bd8d9904a52979cd21e81%1782392410.233933",
        "openssl/3.6.3#f806de8933e3bf6f01016c6a888cee2e%1783945160.863288",
        "nudb/2.0.9#11149c73f8f2baff9a0198fe25971fc7%1782392402.297166",
-        "mpt-crypto/0.4.0-rc4#ffdba12f2332357f0d8b0ae944cfff52%1784138702.932355",
+        "mpt-crypto/1.0.2#b313cef0c1a493eb970ad185b2e9bab7%1784285108.866483",
        "minizip/1.2.13#64dfec2ee447ab6c0c7eab967815a762%1782736605.272739",
        "lz4/1.10.0#982d9b673900f665a1da109e09c17cab%1782392402.164188",
        "libuv/1.46.0#e1a592bf7c0f37802889ca2c795fb26c%1782736605.776567",
--- a/conanfile.py
+++ b/conanfile.py
@@ -17,7 +17,7 @@ class ClioConan(ConanFile):
        "fmt/12.1.0",
        "libbacktrace/cci.20210118",
        "spdlog/1.17.0",
-        "xrpl/3.3.0-rc1-custom",
+        "xrpl/3.3.0",
    ]

    default_options = {
--- a/src/rpc/handlers/AccountMPTokenIssuances.cpp
+++ b/src/rpc/handlers/AccountMPTokenIssuances.cpp
@@ -57,22 +57,25 @@ AccountMPTokenIssuancesHandler::addMPTokenIssuance(
    setFlag(issuance.mptCanClawback, xrpl::lsfMPTCanClawback);
    setFlag(issuance.mptCanHoldConfidentialBalance, xrpl::lsfMPTCanHoldConfidentialBalance);

-    if (sle.isFieldPresent(xrpl::sfMutableFlags)) {
-        auto const mutableFlags = sle.getFieldU32(xrpl::sfMutableFlags);
+    if (sle.isFieldPresent(xrpl::sfImmutableFlags)) {
+        auto const immutableFlags = sle.getFieldU32(xrpl::sfImmutableFlags);

-        auto const setMutableFlag = [&](std::optional<bool>& field, std::uint32_t mask) {
-            if ((mutableFlags & mask) != 0u)
+        auto const setImmutableFlag = [&](std::optional<bool>& field, std::uint32_t mask) {
+            if ((immutableFlags & mask) != 0u)
                field = true;
        };

-        setMutableFlag(issuance.mptCanMutateCanLock, xrpl::lsmfMPTCanEnableCanLock);
-        setMutableFlag(issuance.mptCanMutateRequireAuth, xrpl::lsmfMPTCanEnableRequireAuth);
-        setMutableFlag(issuance.mptCanMutateCanEscrow, xrpl::lsmfMPTCanEnableCanEscrow);
-        setMutableFlag(issuance.mptCanMutateCanTrade, xrpl::lsmfMPTCanEnableCanTrade);
-        setMutableFlag(issuance.mptCanMutateCanTransfer, xrpl::lsmfMPTCanEnableCanTransfer);
-        setMutableFlag(issuance.mptCanMutateCanClawback, xrpl::lsmfMPTCanEnableCanClawback);
-        setMutableFlag(issuance.mptCanMutateMetadata, xrpl::lsmfMPTCanMutateMetadata);
-        setMutableFlag(issuance.mptCanMutateTransferFee, xrpl::lsmfMPTCanMutateTransferFee);
+        setImmutableFlag(issuance.mptImmutableCanLock, xrpl::lsifMPTCanLock);
+        setImmutableFlag(issuance.mptImmutableRequireAuth, xrpl::lsifMPTRequireAuth);
+        setImmutableFlag(issuance.mptImmutableCanEscrow, xrpl::lsifMPTCanEscrow);
+        setImmutableFlag(issuance.mptImmutableCanTrade, xrpl::lsifMPTCanTrade);
+        setImmutableFlag(issuance.mptImmutableCanTransfer, xrpl::lsifMPTCanTransfer);
+        setImmutableFlag(issuance.mptImmutableCanClawback, xrpl::lsifMPTCanClawback);
+        setImmutableFlag(
+            issuance.mptImmutableCanHoldConfidentialBalance, xrpl::lsifMPTCanHoldConfidentialBalance
+        );
+        setImmutableFlag(issuance.mptImmutableMetadata, xrpl::lsifMPTMetadata);
+        setImmutableFlag(issuance.mptImmutableTransferFee, xrpl::lsifMPTTransferFee);
    }

    if (sle.isFieldPresent(xrpl::sfTransferFee))
@@ -277,14 +280,18 @@ tag_invoke(
    setIfPresent("mpt_can_transfer", issuance.mptCanTransfer);
    setIfPresent("mpt_can_clawback", issuance.mptCanClawback);

-    setIfPresent("mpt_can_mutate_can_lock", issuance.mptCanMutateCanLock);
-    setIfPresent("mpt_can_mutate_require_auth", issuance.mptCanMutateRequireAuth);
-    setIfPresent("mpt_can_mutate_can_escrow", issuance.mptCanMutateCanEscrow);
-    setIfPresent("mpt_can_mutate_can_trade", issuance.mptCanMutateCanTrade);
-    setIfPresent("mpt_can_mutate_can_transfer", issuance.mptCanMutateCanTransfer);
-    setIfPresent("mpt_can_mutate_can_clawback", issuance.mptCanMutateCanClawback);
-    setIfPresent("mpt_can_mutate_metadata", issuance.mptCanMutateMetadata);
-    setIfPresent("mpt_can_mutate_transfer_fee", issuance.mptCanMutateTransferFee);
+    setIfPresent("mpt_immutable_can_lock", issuance.mptImmutableCanLock);
+    setIfPresent("mpt_immutable_require_auth", issuance.mptImmutableRequireAuth);
+    setIfPresent("mpt_immutable_can_escrow", issuance.mptImmutableCanEscrow);
+    setIfPresent("mpt_immutable_can_trade", issuance.mptImmutableCanTrade);
+    setIfPresent("mpt_immutable_can_transfer", issuance.mptImmutableCanTransfer);
+    setIfPresent("mpt_immutable_can_clawback", issuance.mptImmutableCanClawback);
+    setIfPresent(
+        "mpt_immutable_can_hold_confidential_balance",
+        issuance.mptImmutableCanHoldConfidentialBalance
+    );
+    setIfPresent("mpt_immutable_metadata", issuance.mptImmutableMetadata);
+    setIfPresent("mpt_immutable_transfer_fee", issuance.mptImmutableTransferFee);

    setIfPresent("mpt_can_hold_confidential_balance", issuance.mptCanHoldConfidentialBalance);
    setUint64IfPresent(
--- a/src/rpc/handlers/AccountMPTokenIssuances.hpp
+++ b/src/rpc/handlers/AccountMPTokenIssuances.hpp
@@ -63,14 +63,15 @@ public:
        std::optional<bool> mptCanTransfer;
        std::optional<bool> mptCanClawback;

-        std::optional<bool> mptCanMutateCanLock;
-        std::optional<bool> mptCanMutateRequireAuth;
-        std::optional<bool> mptCanMutateCanEscrow;
-        std::optional<bool> mptCanMutateCanTrade;
-        std::optional<bool> mptCanMutateCanTransfer;
-        std::optional<bool> mptCanMutateCanClawback;
-        std::optional<bool> mptCanMutateMetadata;
-        std::optional<bool> mptCanMutateTransferFee;
+        std::optional<bool> mptImmutableCanLock;
+        std::optional<bool> mptImmutableRequireAuth;
+        std::optional<bool> mptImmutableCanEscrow;
+        std::optional<bool> mptImmutableCanTrade;
+        std::optional<bool> mptImmutableCanTransfer;
+        std::optional<bool> mptImmutableCanClawback;
+        std::optional<bool> mptImmutableCanHoldConfidentialBalance;
+        std::optional<bool> mptImmutableMetadata;
+        std::optional<bool> mptImmutableTransferFee;

        std::optional<bool> mptCanHoldConfidentialBalance;
        std::optional<std::uint64_t> confidentialOutstandingAmount;
--- a/tests/common/util/TestObject.cpp
+++ b/tests/common/util/TestObject.cpp
@@ -1493,7 +1493,7 @@ createMptIssuanceObject(
    std::optional<std::uint64_t> maxAmount,
    std::optional<std::uint64_t> lockedAmount,
    std::optional<std::string_view> domainId,
-    std::optional<std::uint32_t> mutableFlags,
+    std::optional<std::uint32_t> immutableFlags,
    std::optional<std::string_view> issuerEncryptionKey,
    std::optional<std::string_view> auditorEncryptionKey,
    std::optional<std::uint64_t> confidentialOutstandingAmount
@@ -1523,8 +1523,8 @@ createMptIssuanceObject(
    }
    if (domainId.has_value())
        mptIssuance.setFieldH256(xrpl::sfDomainID, xrpl::uint256{*domainId});
-    if (mutableFlags.has_value())
-        mptIssuance.setFieldU32(xrpl::sfMutableFlags, *mutableFlags);
+    if (immutableFlags.has_value())
+        mptIssuance.setFieldU32(xrpl::sfImmutableFlags, *immutableFlags);
    if (issuerEncryptionKey.has_value()) {
        xrpl::Slice const slice(issuerEncryptionKey->data(), issuerEncryptionKey->size());
        mptIssuance.setFieldVL(xrpl::sfIssuerEncryptionKey, slice);
--- a/tests/common/util/TestObject.hpp
+++ b/tests/common/util/TestObject.hpp
@@ -466,7 +466,7 @@ createMptIssuanceObject(
    std::optional<std::uint64_t> maxAmount = std::nullopt,
    std::optional<std::uint64_t> lockedAmount = std::nullopt,
    std::optional<std::string_view> domainId = std::nullopt,
-    std::optional<std::uint32_t> mutableFlags = std::nullopt,
+    std::optional<std::uint32_t> immutableFlags = std::nullopt,
    std::optional<std::string_view> issuerEncryptionKey = std::nullopt,
    std::optional<std::string_view> auditorEncryptionKey = std::nullopt,
    std::optional<std::uint64_t> confidentialOutstandingAmount = std::nullopt
--- a/tests/unit/rpc/handlers/AccountMPTokenIssuancesTests.cpp
+++ b/tests/unit/rpc/handlers/AccountMPTokenIssuancesTests.cpp
@@ -956,15 +956,13 @@ TEST_P(AccountMPTokenIssuancesAmountSerializationTest, SerializedAsStrings)
    });
 }

-TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MutableFlags)
+TEST_F(RPCAccountMPTokenIssuancesHandlerTest, ImmutableFlags)
 {
-    uint32_t const mutableFlags1 = xrpl::lsmfMPTCanEnableCanLock |
-        xrpl::lsmfMPTCanEnableRequireAuth | xrpl::lsmfMPTCanEnableCanEscrow |
-        xrpl::lsmfMPTCanEnableCanTrade;
+    uint32_t const immutableFlags1 = xrpl::lsifMPTCanLock | xrpl::lsifMPTRequireAuth |
+        xrpl::lsifMPTCanEscrow | xrpl::lsifMPTCanTrade;

-    uint32_t const mutableFlags2 = xrpl::lsmfMPTCanEnableCanTransfer |
-        xrpl::lsmfMPTCanEnableCanClawback | xrpl::lsmfMPTCanMutateMetadata |
-        xrpl::lsmfMPTCanMutateTransferFee;
+    uint32_t const immutableFlags2 = xrpl::lsifMPTCanTransfer | xrpl::lsifMPTCanClawback |
+        xrpl::lsifMPTMetadata | xrpl::lsifMPTTransferFee;

    auto const ledgerHeader = createLedgerHeader(kLedgerHash, 30);
    EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(Return(ledgerHeader));
@@ -993,7 +991,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MutableFlags)
            std::nullopt,
            std::nullopt,
            std::nullopt,
-            mutableFlags1
+            immutableFlags1
        )
            .getSerializer()
            .peekData(),
@@ -1009,7 +1007,7 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MutableFlags)
            std::nullopt,
            std::nullopt,
            std::nullopt,
-            mutableFlags2
+            immutableFlags2
        )
            .getSerializer()
            .peekData()
@@ -1042,10 +1040,10 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MutableFlags)
                        "outstanding_amount": "{}",
                        "transfer_fee": {},
                        "mpt_can_transfer": true,
-                        "mpt_can_mutate_can_lock": true,
-                        "mpt_can_mutate_require_auth": true,
-                        "mpt_can_mutate_can_escrow": true,
-                        "mpt_can_mutate_can_trade": true
+                        "mpt_immutable_can_lock": true,
+                        "mpt_immutable_require_auth": true,
+                        "mpt_immutable_can_escrow": true,
+                        "mpt_immutable_can_trade": true
                    }},
                    {{
                        "mpt_issuance_id": "{}",
@@ -1055,10 +1053,10 @@ TEST_F(RPCAccountMPTokenIssuancesHandlerTest, MutableFlags)
                        "transfer_fee": {},
                        "mptoken_metadata": "{}",
                        "mpt_can_transfer": true,
-                        "mpt_can_mutate_can_transfer": true,
-                        "mpt_can_mutate_can_clawback": true,
-                        "mpt_can_mutate_metadata": true,
-                        "mpt_can_mutate_transfer_fee": true
+                        "mpt_immutable_can_transfer": true,
+                        "mpt_immutable_can_clawback": true,
+                        "mpt_immutable_metadata": true,
+                        "mpt_immutable_transfer_fee": true
                    }}
                ]
            }})JSON",
@@ -1174,8 +1172,8 @@ struct SingleFlagTest {
    std::string expectedJsonKey;
 };

-struct AccountMPTokenIssuancesImmutableFlagsTest : RPCAccountMPTokenIssuancesHandlerTest,
-                                                   WithParamInterface<SingleFlagTest> {};
+struct AccountMPTokenIssuancesLedgerFlagsTest : RPCAccountMPTokenIssuancesHandlerTest,
+                                                WithParamInterface<SingleFlagTest> {};

 static auto
 generateSingleFlagTests()
@@ -1200,13 +1198,13 @@ generateSingleFlagTests()
 }

 INSTANTIATE_TEST_SUITE_P(
-    RPCAccountMPTokenIssuancesImmutableFlagsGroup,
-    AccountMPTokenIssuancesImmutableFlagsTest,
+    RPCAccountMPTokenIssuancesLedgerFlagsGroup,
+    AccountMPTokenIssuancesLedgerFlagsTest,
    ValuesIn(generateSingleFlagTests()),
    tests::util::kNameGenerator
 );

-TEST_P(AccountMPTokenIssuancesImmutableFlagsTest, SingleFlag)
+TEST_P(AccountMPTokenIssuancesLedgerFlagsTest, SingleFlag)
 {
    auto const testParams = GetParam();

@@ -1254,54 +1252,57 @@ TEST_P(AccountMPTokenIssuancesImmutableFlagsTest, SingleFlag)
    });
 }

-struct SingleMutableFlagTest {
+struct SingleImmutableFlagTest {
    std::string testName;
-    uint32_t mutableFlag;
+    uint32_t immutableFlag;
    std::string expectedJsonKey;
 };

-struct AccountMPTokenIssuancesMutableFlagsTest : RPCAccountMPTokenIssuancesHandlerTest,
-                                                 WithParamInterface<SingleMutableFlagTest> {};
+struct AccountMPTokenIssuancesImmutableFlagsTest : RPCAccountMPTokenIssuancesHandlerTest,
+                                                   WithParamInterface<SingleImmutableFlagTest> {};

 static auto
-generateSingleMutableFlagTests()
+generateSingleImmutableFlagTests()
 {
-    return std::vector<SingleMutableFlagTest>{
-        {.testName = "CanMutateCanLock",
-         .mutableFlag = xrpl::lsmfMPTCanEnableCanLock,
-         .expectedJsonKey = "mpt_can_mutate_can_lock"},
-        {.testName = "CanMutateRequireAuth",
-         .mutableFlag = xrpl::lsmfMPTCanEnableRequireAuth,
-         .expectedJsonKey = "mpt_can_mutate_require_auth"},
-        {.testName = "CanMutateCanEscrow",
-         .mutableFlag = xrpl::lsmfMPTCanEnableCanEscrow,
-         .expectedJsonKey = "mpt_can_mutate_can_escrow"},
-        {.testName = "CanMutateCanTrade",
-         .mutableFlag = xrpl::lsmfMPTCanEnableCanTrade,
-         .expectedJsonKey = "mpt_can_mutate_can_trade"},
-        {.testName = "CanMutateCanTransfer",
-         .mutableFlag = xrpl::lsmfMPTCanEnableCanTransfer,
-         .expectedJsonKey = "mpt_can_mutate_can_transfer"},
-        {.testName = "CanMutateCanClawback",
-         .mutableFlag = xrpl::lsmfMPTCanEnableCanClawback,
-         .expectedJsonKey = "mpt_can_mutate_can_clawback"},
-        {.testName = "CanMutateMetadata",
-         .mutableFlag = xrpl::lsmfMPTCanMutateMetadata,
-         .expectedJsonKey = "mpt_can_mutate_metadata"},
-        {.testName = "CanMutateTransferFee",
-         .mutableFlag = xrpl::lsmfMPTCanMutateTransferFee,
-         .expectedJsonKey = "mpt_can_mutate_transfer_fee"},
+    return std::vector<SingleImmutableFlagTest>{
+        {.testName = "ImmutableCanLock",
+         .immutableFlag = xrpl::lsifMPTCanLock,
+         .expectedJsonKey = "mpt_immutable_can_lock"},
+        {.testName = "ImmutableRequireAuth",
+         .immutableFlag = xrpl::lsifMPTRequireAuth,
+         .expectedJsonKey = "mpt_immutable_require_auth"},
+        {.testName = "ImmutableCanEscrow",
+         .immutableFlag = xrpl::lsifMPTCanEscrow,
+         .expectedJsonKey = "mpt_immutable_can_escrow"},
+        {.testName = "ImmutableCanTrade",
+         .immutableFlag = xrpl::lsifMPTCanTrade,
+         .expectedJsonKey = "mpt_immutable_can_trade"},
+        {.testName = "ImmutableCanTransfer",
+         .immutableFlag = xrpl::lsifMPTCanTransfer,
+         .expectedJsonKey = "mpt_immutable_can_transfer"},
+        {.testName = "ImmutableCanClawback",
+         .immutableFlag = xrpl::lsifMPTCanClawback,
+         .expectedJsonKey = "mpt_immutable_can_clawback"},
+        {.testName = "ImmutableCanHoldConfidentialBalance",
+         .immutableFlag = xrpl::lsifMPTCanHoldConfidentialBalance,
+         .expectedJsonKey = "mpt_immutable_can_hold_confidential_balance"},
+        {.testName = "ImmutableMetadata",
+         .immutableFlag = xrpl::lsifMPTMetadata,
+         .expectedJsonKey = "mpt_immutable_metadata"},
+        {.testName = "ImmutableTransferFee",
+         .immutableFlag = xrpl::lsifMPTTransferFee,
+         .expectedJsonKey = "mpt_immutable_transfer_fee"},
    };
 }

 INSTANTIATE_TEST_SUITE_P(
-    RPCAccountMPTokenIssuancesMutableFlagsGroup,
-    AccountMPTokenIssuancesMutableFlagsTest,
-    ValuesIn(generateSingleMutableFlagTests()),
+    RPCAccountMPTokenIssuancesImmutableFlagsGroup,
+    AccountMPTokenIssuancesImmutableFlagsTest,
+    ValuesIn(generateSingleImmutableFlagTests()),
    tests::util::kNameGenerator
 );

-TEST_P(AccountMPTokenIssuancesMutableFlagsTest, SingleMutableFlag)
+TEST_P(AccountMPTokenIssuancesImmutableFlagsTest, SingleImmutableFlag)
 {
    auto const testParams = GetParam();

@@ -1330,7 +1331,7 @@ TEST_P(AccountMPTokenIssuancesMutableFlagsTest, SingleMutableFlag)
                                           std::nullopt,
                                           std::nullopt,
                                           std::nullopt,
-                                           testParams.mutableFlag
+                                           testParams.immutableFlag
    )
                                           .getSerializer()
                                           .peekData()};