activate tsan and asan for gcc and clang

Signed-off-by: Pratik Mankawde <3397372+pratikmankawde@users.noreply.github.com>

.github/scripts/strategy-matrix/generate.py

@@ -236,10 +236,12 @@ def generate_strategy_matrix(all: bool, config: Config) -> list:
         # names get truncated.
         # Add Address and Thread (both coupled with UB) sanitizers for specific bookworm distros.
         # GCC-Asan rippled-embedded tests are failing because of https://github.com/google/sanitizers/issues/856
-        if (
-            os["distro_version"] == "bookworm"
-            and f"{os['compiler_name']}-{os['compiler_version']}" == "clang-20"
-        ):
+        if os[
+            "distro_version"
+        ] == "bookworm" and f"{os['compiler_name']}-{os['compiler_version']}" in [
+            "clang-20",
+            "gcc-15",
+        ]:
             # Add ASAN + UBSAN configuration.
             configurations.append(
                 {
@@ -254,7 +256,7 @@ def generate_strategy_matrix(all: bool, config: Config) -> list:
                 }
             )
             # TSAN is deactivated due to seg faults with latest compilers.
-            activate_tsan = False
+            activate_tsan = True
             if activate_tsan:
                 configurations.append(
                     {

cmake/XrplConfig.cmake

@@ -17,7 +17,7 @@ find_dependency(Boost
                 chrono
                 container
                 context
-                coroutine
+                coroutine2
                 date_time
                 filesystem
                 program_options

cmake/deps/Boost.cmake

@@ -4,7 +4,7 @@ include(XrplSanitizers)
 find_package(Boost REQUIRED
              COMPONENTS chrono
                         container
-                        coroutine
+                        context
                         date_time
                         filesystem
                         json
@@ -21,7 +21,7 @@ target_link_libraries(
     INTERFACE Boost::headers
               Boost::chrono
               Boost::container
-              Boost::coroutine
+              Boost::context
               Boost::date_time
               Boost::filesystem
               Boost::json

conan/profiles/sanitizers

@@ -13,15 +13,18 @@ include(default)
             {% if "address" in sanitizers %}
                 {% set _ = sanitizer_list.append("address") %}
                 {% set model_code = "-mcmodel=large" %}
+                tools.build:defines+=["BOOST_USE_ASAN", "BOOST_USE_UCONTEXT"]
             {% elif "thread" in sanitizers %}
                 {% set _ = sanitizer_list.append("thread") %}
                 {% set model_code = "-mcmodel=medium" %}
                 {% set _ = extra_cxxflags.append("-Wno-tsan") %}
+                tools.build:defines+=["BOOST_USE_TSAN", "BOOST_USE_UCONTEXT"]
             {% endif %}
 
             {% if "undefinedbehavior" in sanitizers %}
                 {% set _ = sanitizer_list.append("undefined") %}
                 {% set _ = sanitizer_list.append("float-divide-by-zero") %}
+                tools.build:defines+=["BOOST_USE_UBSAN", "BOOST_USE_UCONTEXT"]
             {% endif %}
 
             {% set sanitizer_flags = "-fsanitize=" ~ ",".join(sanitizer_list) ~ " " ~ model_code %}
@@ -37,14 +40,17 @@ include(default)
 
             {% if "address" in sanitizers %}
                 {% set _ = sanitizer_list.append("address") %}
+                tools.build:defines+=["BOOST_USE_ASAN", "BOOST_USE_UCONTEXT"]
             {% elif "thread" in sanitizers %}
                 {% set _ = sanitizer_list.append("thread") %}
+                tools.build:defines+=["BOOST_USE_TSAN", "BOOST_USE_UCONTEXT"]
             {% endif %}
 
             {% if "undefinedbehavior" in sanitizers %}
                 {% set _ = sanitizer_list.append("undefined") %}
                 {% set _ = sanitizer_list.append("float-divide-by-zero") %}
                 {% set _ = sanitizer_list.append("unsigned-integer-overflow") %}
+                tools.build:defines+=[ "BOOST_USE_UBSAN", "BOOST_USE_UCONTEXT"]
             {% endif %}
 
             {% set sanitizer_flags = "-fsanitize=" ~ ",".join(sanitizer_list) %}
@@ -56,4 +62,20 @@ include(default)
     {% endif %}
 {% endif %}
 
-tools.info.package_id:confs+=["tools.build:cxxflags", "tools.build:exelinkflags", "tools.build:sharedlinkflags"]
+tools.info.package_id:confs+=["tools.build:cxxflags", "tools.build:exelinkflags", "tools.build:sharedlinkflags", "tools.build:defines"]
+
+[options]
+{% if compiler == "gcc" or compiler == "apple-clang" or compiler == "clang" %}
+{% if sanitizers == "Address" or sanitizers == "Thread" %}
+boost/*:without_context=False
+boost/*:without_stacktrace=True
+boost/*:without_coroutine2=False
+
+{% if sanitizers == "Address" %}
+boost/*:extra_b2_flags="context-impl=ucontext address-sanitizer=norecover undefined-sanitizer=norecover --with-coroutine2"
+{% elif sanitizers == "Thread" %}
+boost/*:extra_b2_flags="context-impl=ucontext thread-sanitizer=norecover undefined-sanitizer=norecover --with-coroutine2"
+{% endif %}
+
+{% endif %}
+{% endif %}

conanfile.py

@@ -125,6 +125,7 @@ class Xrpl(ConanFile):
             self.options["boost"].visibility = "global"
         if self.settings.compiler in ["clang", "gcc"]:
             self.options["boost"].without_cobalt = True
+        self.options["boost"].without_coroutine2 = False
 
     def requirements(self):
         # Conan 2 requires transitive headers to be specified
@@ -196,7 +197,8 @@ class Xrpl(ConanFile):
             "boost::headers",
             "boost::chrono",
             "boost::container",
-            "boost::coroutine",
+            "boost::context",
+            "boost::coroutine2",
             "boost::date_time",
             "boost::filesystem",
             "boost::json",

cspell.config.yaml

@@ -173,6 +173,7 @@ words:
   - nftpage
   - nikb
   - nonxrp
+  - norecover
   - noripple
   - nudb
   - nullptr

include/xrpl/core/Coro.ipp

@@ -10,16 +10,14 @@ JobQueue::Coro::Coro(Coro_create_t, JobQueue& jq, JobType type, std::string cons
     , type_(type)
     , name_(name)
     , running_(false)
-    , coro_(
-          [this, fn = std::forward<F>(f)](boost::coroutines::asymmetric_coroutine<void>::push_type& do_yield) {
-              yield_ = &do_yield;
-              yield();
-              fn(shared_from_this());
+    , coro_([this, fn = std::forward<F>(f)](boost::coroutines2::asymmetric_coroutine<void>::push_type& do_yield) {
+        yield_ = &do_yield;
+        yield();
+        fn(shared_from_this());
 #ifndef NDEBUG
-              finished_ = true;
+        finished_ = true;
 #endif
-          },
-          boost::coroutines::attributes(megabytes(1)))
+    })
 {
 }
 

include/xrpl/core/JobQueue.h

@@ -7,7 +7,7 @@
 #include <xrpl/core/detail/Workers.h>
 #include <xrpl/json/json_value.h>
 
-#include <boost/coroutine/all.hpp>
+#include <boost/coroutine2/all.hpp>
 
 #include <set>
 
@@ -48,8 +48,8 @@ public:
         std::mutex mutex_;
         std::mutex mutex_run_;
         std::condition_variable cv_;
-        boost::coroutines::asymmetric_coroutine<void>::pull_type coro_;
-        boost::coroutines::asymmetric_coroutine<void>::push_type* yield_;
+        boost::coroutines2::asymmetric_coroutine<void>::pull_type coro_;
+        boost::coroutines2::asymmetric_coroutine<void>::push_type* yield_;
 #ifndef NDEBUG
         bool finished_ = false;
 #endif
@@ -326,7 +326,7 @@ private:
     other requests while the RPC command completes its work asynchronously.
 
     postCoro() creates a Coro object. When the Coro ctor is called, and its
-    coro_ member is initialized (a boost::coroutines::pull_type), execution
+    coro_ member is initialized (a boost::coroutines2::pull_type), execution
     automatically passes to the coroutine, which we don't want at this point,
     since we are still in the handler thread context. It's important to note
    here that construction of a boost pull_type automatically passes execution to

include/xrpl/protocol/STAmount.h

@@ -42,8 +42,8 @@ private:
 public:
     using value_type = STAmount;
 
-    static int constexpr cMinOffset = -96;
-    static int constexpr cMaxOffset = 80;
+    static int const cMinOffset = -96;
+    static int const cMaxOffset = 80;
 
     // Maximum native value supported by the code
     constexpr static std::uint64_t cMinValue = 1'000'000'000'000'000ull;
@@ -720,22 +720,6 @@ canAdd(STAmount const& amt1, STAmount const& amt2);
 bool
 canSubtract(STAmount const& amt1, STAmount const& amt2);
 
-/** Get the scale of a Number for a given asset.
- *
- * "scale" is similar to "exponent", but from the perspective of STAmount, which has different rules and mantissa ranges
- * for determining the exponent than Number.
- *
- * @param number The Number to get the scale of.
- * @param asset The asset to use for determining the scale.
- * @return The scale of this Number for the given asset.
- */
-template <AssetType Asset>
-inline int
-numberScale(Number const& number, Asset const& asset)
-{
-    return STAmount{asset, number}.exponent();
-}
-
 }  // namespace xrpl
 
 //------------------------------------------------------------------------------

include/xrpl/protocol/detail/features.macro

@@ -15,8 +15,6 @@
 
 // Add new amendments to the top of this list.
 // Keep it sorted in reverse chronological order.
-
-XRPL_FIX    (LendingProtocolV1_1,        Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX   (PermissionedDomainInvariant, Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (ExpiredNFTokenOfferRemoval, Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (BatchInnerSigs,             Supported::yes, VoteBehavior::DefaultNo)

include/xrpl/tx/InvariantCheck.h

@@ -8,6 +8,7 @@
 #include <xrpl/protocol/STTx.h>
 #include <xrpl/protocol/TER.h>
 
+#include <cstdint>
 #include <tuple>
 #include <unordered_set>
 
@@ -663,19 +664,11 @@ class ValidVault
         Shares static make(SLE const&);
     };
 
-public:
-    struct DeltaInfo final
-    {
-        Number delta = numZero;
-        std::optional<int> scale;
-    };
-
-private:
     std::vector<Vault> afterVault_ = {};
     std::vector<Shares> afterMPTs_ = {};
     std::vector<Vault> beforeVault_ = {};
     std::vector<Shares> beforeMPTs_ = {};
-    std::unordered_map<uint256, DeltaInfo> deltas_ = {};
+    std::unordered_map<uint256, Number> deltas_ = {};
 
 public:
     void
@@ -683,10 +676,6 @@ public:
 
     bool
     finalize(STTx const&, TER const, XRPAmount const, ReadView const&, beast::Journal const&);
-
-    // Compute the coarsest scale required to represent all numbers
-    [[nodiscard]] static std::int32_t
-    computeMinScale(Asset const& asset, std::vector<DeltaInfo> const& numbers);
 };
 
 // additional invariant checks can be declared above and then added to this

include/xrpl/tx/transactors/Lending/LendingHelpers.h

@@ -167,7 +167,7 @@ getAssetsTotalScale(SLE::const_ref vaultSle)
 {
     if (!vaultSle)
         return Number::minExponent - 1;  // LCOV_EXCL_LINE
-    return numberScale(vaultSle->at(sfAssetsTotal), vaultSle->at(sfAsset));
+    return STAmount{vaultSle->at(sfAsset), vaultSle->at(sfAssetsTotal)}.exponent();
 }
 
 TER

src/libxrpl/tx/InvariantCheck.cpp

@@ -13,6 +13,7 @@
 #include <xrpl/protocol/SystemParameters.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFormats.h>
+#include <xrpl/protocol/Units.h>
 #include <xrpl/protocol/nftPageMask.h>
 #include <xrpl/tx/InvariantCheck.h>
 #include <xrpl/tx/transactors/AMM/AMMHelpers.h>
@@ -20,9 +21,7 @@
 #include <xrpl/tx/transactors/NFT/NFTokenUtils.h>
 #include <xrpl/tx/transactors/PermissionedDomain/PermissionedDomainSet.h>
 
-#include <algorithm>
-#include <cstddef>
-#include <initializer_list>
+#include <cstdint>
 #include <optional>
 
 namespace xrpl {
@@ -2466,13 +2465,8 @@ ValidVault::visitEntry(bool isDelete, std::shared_ptr<SLE const> const& before,
     // Number balanceDelta will capture the difference (delta) between "before"
     // state (zero if created) and "after" state (zero if destroyed), so the
     // invariants can validate that the change in account balances matches the
-    // balanceDelta captures the difference (delta) between "before"
-    // state (zero if created) and "after" state (zero if destroyed), and
-    // preserves value scale (exponent) to round values to the same scale during
-    // validation. It is used to validate that the change in account
-    // balances matches the change in vault balances, stored to deltas_ at the
-    // end of this function.
-    DeltaInfo balanceDelta{numZero, std::nullopt};
+    // change in vault balances, stored to deltas_ at the end of this function.
+    Number balanceDelta{};
 
     std::int8_t sign = 0;
     if (before)
@@ -2486,33 +2480,18 @@ ValidVault::visitEntry(bool isDelete, std::shared_ptr<SLE const> const& before,
                 // At this moment we have no way of telling if this object holds
                 // vault shares or something else. Save it for finalize.
                 beforeMPTs_.push_back(Shares::make(*before));
-                balanceDelta.delta = static_cast<std::int64_t>(before->getFieldU64(sfOutstandingAmount));
-                // MPTs are ints, so the scale is always 0.
-                balanceDelta.scale = 0;
+                balanceDelta = static_cast<std::int64_t>(before->getFieldU64(sfOutstandingAmount));
                 sign = 1;
                 break;
             case ltMPTOKEN:
-                balanceDelta.delta = static_cast<std::int64_t>(before->getFieldU64(sfMPTAmount));
-                // MPTs are ints, so the scale is always 0.
-                balanceDelta.scale = 0;
+                balanceDelta = static_cast<std::int64_t>(before->getFieldU64(sfMPTAmount));
                 sign = -1;
                 break;
             case ltACCOUNT_ROOT:
-                balanceDelta.delta = before->getFieldAmount(sfBalance);
-                // Account balance is XRP, which is an int, so the scale is
-                // always 0.
-                balanceDelta.scale = 0;
+            case ltRIPPLE_STATE:
+                balanceDelta = before->getFieldAmount(sfBalance);
                 sign = -1;
                 break;
-            case ltRIPPLE_STATE: {
-                auto const amount = before->getFieldAmount(sfBalance);
-                balanceDelta.delta = amount;
-                // Trust Line balances are STAmounts, so we can use the exponent
-                // directly to get the scale.
-                balanceDelta.scale = amount.exponent();
-                sign = -1;
-                break;
-            }
             default:;
         }
     }
@@ -2528,34 +2507,18 @@ ValidVault::visitEntry(bool isDelete, std::shared_ptr<SLE const> const& before,
                 // At this moment we have no way of telling if this object holds
                 // vault shares or something else. Save it for finalize.
                 afterMPTs_.push_back(Shares::make(*after));
-                balanceDelta.delta -= Number(static_cast<std::int64_t>(after->getFieldU64(sfOutstandingAmount)));
-                // MPTs are ints, so the scale is always 0.
-                balanceDelta.scale = 0;
+                balanceDelta -= Number(static_cast<std::int64_t>(after->getFieldU64(sfOutstandingAmount)));
                 sign = 1;
                 break;
             case ltMPTOKEN:
-                balanceDelta.delta -= Number(static_cast<std::int64_t>(after->getFieldU64(sfMPTAmount)));
-                // MPTs are ints, so the scale is always 0.
-                balanceDelta.scale = 0;
+                balanceDelta -= Number(static_cast<std::int64_t>(after->getFieldU64(sfMPTAmount)));
                 sign = -1;
                 break;
             case ltACCOUNT_ROOT:
-                balanceDelta.delta -= Number(after->getFieldAmount(sfBalance));
-                // Account balance is XRP, which is an int, so the scale is
-                // always 0.
-                balanceDelta.scale = 0;
+            case ltRIPPLE_STATE:
+                balanceDelta -= Number(after->getFieldAmount(sfBalance));
                 sign = -1;
                 break;
-            case ltRIPPLE_STATE: {
-                auto const amount = after->getFieldAmount(sfBalance);
-                balanceDelta.delta -= Number(amount);
-                // Trust Line balances are STAmounts, so we can use the exponent
-                // directly to get the scale.
-                if (amount.exponent() > balanceDelta.scale)
-                    balanceDelta.scale = amount.exponent();
-                sign = -1;
-                break;
-            }
             default:;
         }
     }
@@ -2567,11 +2530,7 @@ ValidVault::visitEntry(bool isDelete, std::shared_ptr<SLE const> const& before,
     // transferred to the account. We intentionally do not compare balanceDelta
     // against zero, to avoid missing such updates.
     if (sign != 0)
-    {
-        XRPL_ASSERT_PARTS(balanceDelta.scale, "xrpl::ValidVault::visitEntry", "scale initialized");
-        balanceDelta.delta *= sign;
-        deltas_[key] = balanceDelta;
-    }
+        deltas_[key] = balanceDelta * sign;
 }
 
 bool
@@ -2827,13 +2786,13 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
     }
 
     auto const& vaultAsset = afterVault.asset;
-    auto const deltaAssets = [&](AccountID const& id) -> std::optional<DeltaInfo> {
+    auto const deltaAssets = [&](AccountID const& id) -> std::optional<Number> {
         auto const get =  //
-            [&](auto const& it, std::int8_t sign = 1) -> std::optional<DeltaInfo> {
+            [&](auto const& it, std::int8_t sign = 1) -> std::optional<Number> {
             if (it == deltas_.end())
                 return std::nullopt;
 
-            return DeltaInfo{it->second.delta * sign, it->second.scale};
+            return it->second * sign;
         };
 
         return std::visit(
@@ -2851,7 +2810,7 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
             },
             vaultAsset.value());
     };
-    auto const deltaAssetsTxAccount = [&]() -> std::optional<DeltaInfo> {
+    auto const deltaAssetsTxAccount = [&]() -> std::optional<Number> {
         auto ret = deltaAssets(tx[sfAccount]);
         // Nothing returned or not XRP transaction
         if (!ret.has_value() || !vaultAsset.native())
@@ -2861,20 +2820,20 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
         if (auto const delegate = tx[~sfDelegate]; delegate.has_value() && *delegate != tx[sfAccount])
             return ret;
 
-        ret->delta += fee.drops();
-        if (ret->delta == zero)
+        *ret += fee.drops();
+        if (*ret == zero)
             return std::nullopt;
 
         return ret;
     };
-    auto const deltaShares = [&](AccountID const& id) -> std::optional<DeltaInfo> {
+    auto const deltaShares = [&](AccountID const& id) -> std::optional<Number> {
         auto const it = [&]() {
             if (id == afterVault.pseudoId)
                 return deltas_.find(keylet::mptIssuance(afterVault.shareMPTID).key);
             return deltas_.find(keylet::mptoken(afterVault.shareMPTID, id).key);
         }();
 
-        return it != deltas_.end() ? std::optional<DeltaInfo>(it->second) : std::nullopt;
+        return it != deltas_.end() ? std::optional<Number>(it->second) : std::nullopt;
     };
 
     auto const vaultHoldsNoAssets = [&](Vault const& vault) {
@@ -2996,37 +2955,16 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                     XRPL_ASSERT(!beforeVault_.empty(), "xrpl::ValidVault::finalize : deposit updated a vault");
                     auto const& beforeVault = beforeVault_[0];
 
-                    auto const maybeVaultDeltaAssets = deltaAssets(afterVault.pseudoId);
-                    if (!maybeVaultDeltaAssets)
+                    auto const vaultDeltaAssets = deltaAssets(afterVault.pseudoId);
+
+                    if (!vaultDeltaAssets)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: deposit must change vault balance";
                         return false;  // That's all we can do
                     }
 
-                    // Get the coarsest scale to round calculations to
-                    DeltaInfo totalDelta{
-                        afterVault.assetsTotal - beforeVault.assetsTotal,
-                        std::max(
-                            numberScale(afterVault.assetsTotal, vaultAsset),
-                            numberScale(beforeVault.assetsTotal, vaultAsset))};
-                    DeltaInfo availableDelta{
-                        afterVault.assetsAvailable - beforeVault.assetsAvailable,
-                        std::max(
-                            numberScale(afterVault.assetsAvailable, vaultAsset),
-                            numberScale(beforeVault.assetsAvailable, vaultAsset))};
-                    auto const minScale = computeMinScale(
-                        vaultAsset,
-                        {
-                            *maybeVaultDeltaAssets,
-                            totalDelta,
-                            availableDelta,
-                        });
-
-                    auto const vaultDeltaAssets = roundToAsset(vaultAsset, maybeVaultDeltaAssets->delta, minScale);
-                    auto const txAmount = roundToAsset(vaultAsset, tx[sfAmount], minScale);
-
-                    if (vaultDeltaAssets > txAmount)
+                    if (*vaultDeltaAssets > tx[sfAmount])
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: deposit must not change vault "
@@ -3034,7 +2972,7 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                         result = false;
                     }
 
-                    if (vaultDeltaAssets <= zero)
+                    if (*vaultDeltaAssets <= zero)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: deposit must increase vault balance";
@@ -3051,22 +2989,16 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
 
                     if (!issuerDeposit)
                     {
-                        auto const maybeAccDeltaAssets = deltaAssetsTxAccount();
-                        if (!maybeAccDeltaAssets)
+                        auto const accountDeltaAssets = deltaAssetsTxAccount();
+                        if (!accountDeltaAssets)
                         {
                             JLOG(j.fatal()) <<  //
                                 "Invariant failed: deposit must change depositor "
                                 "balance";
                             return false;
                         }
-                        auto const localMinScale =
-                            std::max(minScale, computeMinScale(vaultAsset, {*maybeAccDeltaAssets}));
 
-                        auto const accountDeltaAssets =
-                            roundToAsset(vaultAsset, maybeAccDeltaAssets->delta, localMinScale);
-                        auto const localVaultDeltaAssets = roundToAsset(vaultAsset, vaultDeltaAssets, localMinScale);
-
-                        if (accountDeltaAssets >= zero)
+                        if (*accountDeltaAssets >= zero)
                         {
                             JLOG(j.fatal()) <<  //
                                 "Invariant failed: deposit must decrease depositor "
@@ -3074,7 +3006,7 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                             result = false;
                         }
 
-                        if (localVaultDeltaAssets * -1 != accountDeltaAssets)
+                        if (*accountDeltaAssets * -1 != *vaultDeltaAssets)
                         {
                             JLOG(j.fatal()) <<  //
                                 "Invariant failed: deposit must change vault and "
@@ -3091,17 +3023,16 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                         result = false;
                     }
 
-                    auto const maybeAccDeltaShares = deltaShares(tx[sfAccount]);
-                    if (!maybeAccDeltaShares)
+                    auto const accountDeltaShares = deltaShares(tx[sfAccount]);
+                    if (!accountDeltaShares)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: deposit must change depositor "
                             "shares";
                         return false;  // That's all we can do
                     }
-                    // We don't need to round shares, they are integral MPT
-                    auto const& accountDeltaShares = *maybeAccDeltaShares;
-                    if (accountDeltaShares.delta <= zero)
+
+                    if (*accountDeltaShares <= zero)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: deposit must increase depositor "
@@ -3109,17 +3040,15 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                         result = false;
                     }
 
-                    auto const maybeVaultDeltaShares = deltaShares(afterVault.pseudoId);
-                    if (!maybeVaultDeltaShares || maybeVaultDeltaShares->delta == zero)
+                    auto const vaultDeltaShares = deltaShares(afterVault.pseudoId);
+                    if (!vaultDeltaShares || *vaultDeltaShares == zero)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: deposit must change vault shares";
                         return false;  // That's all we can do
                     }
 
-                    // We don't need to round shares, they are integral MPT
-                    auto const& vaultDeltaShares = *maybeVaultDeltaShares;
-                    if (vaultDeltaShares.delta * -1 != accountDeltaShares.delta)
+                    if (*vaultDeltaShares * -1 != *accountDeltaShares)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: deposit must change depositor and "
@@ -3127,18 +3056,13 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                         result = false;
                     }
 
-                    auto const assetTotalDelta =
-                        roundToAsset(vaultAsset, afterVault.assetsTotal - beforeVault.assetsTotal, minScale);
-                    if (assetTotalDelta != vaultDeltaAssets)
+                    if (beforeVault.assetsTotal + *vaultDeltaAssets != afterVault.assetsTotal)
                     {
                         JLOG(j.fatal()) << "Invariant failed: deposit and assets "
                                            "outstanding must add up";
                         result = false;
                     }
-
-                    auto const assetAvailableDelta =
-                        roundToAsset(vaultAsset, afterVault.assetsAvailable - beforeVault.assetsAvailable, minScale);
-                    if (assetAvailableDelta != vaultDeltaAssets)
+                    if (beforeVault.assetsAvailable + *vaultDeltaAssets != afterVault.assetsAvailable)
                     {
                         JLOG(j.fatal()) << "Invariant failed: deposit and assets "
                                            "available must add up";
@@ -3156,38 +3080,22 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                         "vault");
                     auto const& beforeVault = beforeVault_[0];
 
-                    auto const maybeVaultDeltaAssets = deltaAssets(afterVault.pseudoId);
+                    auto const vaultDeltaAssets = deltaAssets(afterVault.pseudoId);
 
-                    if (!maybeVaultDeltaAssets)
+                    if (!vaultDeltaAssets)
                     {
                         JLOG(j.fatal()) << "Invariant failed: withdrawal must "
                                            "change vault balance";
                         return false;  // That's all we can do
                     }
 
-                    // Get the most coarse scale to round calculations to
-                    auto const totalDelta = DeltaInfo{
-                        afterVault.assetsTotal - beforeVault.assetsTotal,
-                        std::max(
-                            numberScale(afterVault.assetsTotal, vaultAsset),
-                            numberScale(beforeVault.assetsTotal, vaultAsset))};
-                    auto const availableDelta = DeltaInfo{
-                        afterVault.assetsAvailable - beforeVault.assetsAvailable,
-                        std::max(
-                            numberScale(afterVault.assetsAvailable, vaultAsset),
-                            numberScale(beforeVault.assetsAvailable, vaultAsset))};
-                    auto const minScale =
-                        computeMinScale(vaultAsset, {*maybeVaultDeltaAssets, totalDelta, availableDelta});
-
-                    auto const vaultPseudoDeltaAssets =
-                        roundToAsset(vaultAsset, maybeVaultDeltaAssets->delta, minScale);
-
-                    if (vaultPseudoDeltaAssets >= zero)
+                    if (*vaultDeltaAssets >= zero)
                     {
                         JLOG(j.fatal()) << "Invariant failed: withdrawal must "
                                            "decrease vault balance";
                         result = false;
                     }
+
                     // Any payments (including withdrawal) going to the issuer
                     // do not change their balance, but destroy funds instead.
                     bool const issuerWithdrawal = [&]() -> bool {
@@ -3199,15 +3107,15 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
 
                     if (!issuerWithdrawal)
                     {
-                        auto const maybeAccDelta = deltaAssetsTxAccount();
-                        auto const maybeOtherAccDelta = [&]() -> std::optional<DeltaInfo> {
+                        auto const accountDeltaAssets = deltaAssetsTxAccount();
+                        auto const otherAccountDelta = [&]() -> std::optional<Number> {
                             if (auto const destination = tx[~sfDestination];
                                 destination && *destination != tx[sfAccount])
                                 return deltaAssets(*destination);
                             return std::nullopt;
                         }();
 
-                        if (maybeAccDelta.has_value() == maybeOtherAccDelta.has_value())
+                        if (accountDeltaAssets.has_value() == otherAccountDelta.has_value())
                         {
                             JLOG(j.fatal()) <<  //
                                 "Invariant failed: withdrawal must change one "
@@ -3216,16 +3124,9 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                         }
 
                         auto const destinationDelta =  //
-                            maybeAccDelta ? *maybeAccDelta : *maybeOtherAccDelta;
+                            accountDeltaAssets ? *accountDeltaAssets : *otherAccountDelta;
 
-                        // the scale of destinationDelta can be coarser than
-                        // minScale, so we take that into account when rounding
-                        auto const localMinScale = std::max(minScale, computeMinScale(vaultAsset, {destinationDelta}));
-
-                        auto const roundedDestinationDelta =
-                            roundToAsset(vaultAsset, destinationDelta.delta, localMinScale);
-
-                        if (roundedDestinationDelta <= zero)
+                        if (destinationDelta <= zero)
                         {
                             JLOG(j.fatal()) <<  //
                                 "Invariant failed: withdrawal must increase "
@@ -3233,9 +3134,7 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                             result = false;
                         }
 
-                        auto const localPseudoDeltaAssets =
-                            roundToAsset(vaultAsset, vaultPseudoDeltaAssets, localMinScale);
-                        if (localPseudoDeltaAssets * -1 != roundedDestinationDelta)
+                        if (*vaultDeltaAssets * -1 != destinationDelta)
                         {
                             JLOG(j.fatal()) <<  //
                                 "Invariant failed: withdrawal must change vault "
@@ -3243,7 +3142,7 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                             result = false;
                         }
                     }
-                    // We don't need to round shares, they are integral MPT
+
                     auto const accountDeltaShares = deltaShares(tx[sfAccount]);
                     if (!accountDeltaShares)
                     {
@@ -3253,23 +3152,23 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                         return false;
                     }
 
-                    if (accountDeltaShares->delta >= zero)
+                    if (*accountDeltaShares >= zero)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: withdrawal must decrease depositor "
                             "shares";
                         result = false;
                     }
-                    // We don't need to round shares, they are integral MPT
+
                     auto const vaultDeltaShares = deltaShares(afterVault.pseudoId);
-                    if (!vaultDeltaShares || vaultDeltaShares->delta == zero)
+                    if (!vaultDeltaShares || *vaultDeltaShares == zero)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: withdrawal must change vault shares";
                         return false;  // That's all we can do
                     }
 
-                    if (vaultDeltaShares->delta * -1 != accountDeltaShares->delta)
+                    if (*vaultDeltaShares * -1 != *accountDeltaShares)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: withdrawal must change depositor "
@@ -3277,20 +3176,15 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                         result = false;
                     }
 
-                    auto const assetTotalDelta =
-                        roundToAsset(vaultAsset, afterVault.assetsTotal - beforeVault.assetsTotal, minScale);
                     // Note, vaultBalance is negative (see check above)
-                    if (assetTotalDelta != vaultPseudoDeltaAssets)
+                    if (beforeVault.assetsTotal + *vaultDeltaAssets != afterVault.assetsTotal)
                     {
                         JLOG(j.fatal()) << "Invariant failed: withdrawal and "
                                            "assets outstanding must add up";
                         result = false;
                     }
 
-                    auto const assetAvailableDelta =
-                        roundToAsset(vaultAsset, afterVault.assetsAvailable - beforeVault.assetsAvailable, minScale);
-
-                    if (assetAvailableDelta != vaultPseudoDeltaAssets)
+                    if (beforeVault.assetsAvailable + *vaultDeltaAssets != afterVault.assetsAvailable)
                     {
                         JLOG(j.fatal()) << "Invariant failed: withdrawal and "
                                            "assets available must add up";
@@ -3320,23 +3214,10 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                         }
                     }
 
-                    auto const maybeVaultDeltaAssets = deltaAssets(afterVault.pseudoId);
-                    if (maybeVaultDeltaAssets)
+                    auto const vaultDeltaAssets = deltaAssets(afterVault.pseudoId);
+                    if (vaultDeltaAssets)
                     {
-                        auto const totalDelta = DeltaInfo{
-                            afterVault.assetsTotal - beforeVault.assetsTotal,
-                            std::max(
-                                numberScale(afterVault.assetsTotal, vaultAsset),
-                                numberScale(beforeVault.assetsTotal, vaultAsset))};
-                        auto const availableDelta = DeltaInfo{
-                            afterVault.assetsAvailable - beforeVault.assetsAvailable,
-                            std::max(
-                                numberScale(afterVault.assetsAvailable, vaultAsset),
-                                numberScale(beforeVault.assetsAvailable, vaultAsset))};
-                        auto const minScale =
-                            computeMinScale(vaultAsset, {*maybeVaultDeltaAssets, totalDelta, availableDelta});
-                        auto const vaultDeltaAssets = roundToAsset(vaultAsset, maybeVaultDeltaAssets->delta, minScale);
-                        if (vaultDeltaAssets >= zero)
+                        if (*vaultDeltaAssets >= zero)
                         {
                             JLOG(j.fatal()) <<  //
                                 "Invariant failed: clawback must decrease vault "
@@ -3344,9 +3225,7 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                             result = false;
                         }
 
-                        auto const assetsTotalDelta =
-                            roundToAsset(vaultAsset, afterVault.assetsTotal - beforeVault.assetsTotal, minScale);
-                        if (assetsTotalDelta != vaultDeltaAssets)
+                        if (beforeVault.assetsTotal + *vaultDeltaAssets != afterVault.assetsTotal)
                         {
                             JLOG(j.fatal()) <<  //
                                 "Invariant failed: clawback and assets outstanding "
@@ -3354,9 +3233,7 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                             result = false;
                         }
 
-                        auto const assetAvailableDelta = roundToAsset(
-                            vaultAsset, afterVault.assetsAvailable - beforeVault.assetsAvailable, minScale);
-                        if (assetAvailableDelta != vaultDeltaAssets)
+                        if (beforeVault.assetsAvailable + *vaultDeltaAssets != afterVault.assetsAvailable)
                         {
                             JLOG(j.fatal()) <<  //
                                 "Invariant failed: clawback and assets available "
@@ -3371,15 +3248,15 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                         return false;  // That's all we can do
                     }
 
-                    // We don't need to round shares, they are integral MPT
-                    auto const maybeAccountDeltaShares = deltaShares(tx[sfHolder]);
-                    if (!maybeAccountDeltaShares)
+                    auto const accountDeltaShares = deltaShares(tx[sfHolder]);
+                    if (!accountDeltaShares)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: clawback must change holder shares";
                         return false;  // That's all we can do
                     }
-                    if (maybeAccountDeltaShares->delta >= zero)
+
+                    if (*accountDeltaShares >= zero)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: clawback must decrease holder "
@@ -3387,16 +3264,15 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
                         result = false;
                     }
 
-                    // We don't need to round shares, they are integral MPT
                     auto const vaultDeltaShares = deltaShares(afterVault.pseudoId);
-                    if (!vaultDeltaShares || vaultDeltaShares->delta == zero)
+                    if (!vaultDeltaShares || *vaultDeltaShares == zero)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: clawback must change vault shares";
                         return false;  // That's all we can do
                     }
 
-                    if (vaultDeltaShares->delta * -1 != maybeAccountDeltaShares->delta)
+                    if (*vaultDeltaShares * -1 != *accountDeltaShares)
                     {
                         JLOG(j.fatal()) <<  //
                             "Invariant failed: clawback must change holder and "
@@ -3433,15 +3309,4 @@ ValidVault::finalize(STTx const& tx, TER const ret, XRPAmount const fee, ReadVie
     return true;
 }
 
-[[nodiscard]] std::int32_t
-ValidVault::computeMinScale(Asset const& asset, std::vector<DeltaInfo> const& numbers)
-{
-    if (numbers.size() == 0)
-        return 0;
-
-    auto const max = std::max_element(
-        numbers.begin(), numbers.end(), [](auto const& a, auto const& b) -> bool { return a.scale < b.scale; });
-    XRPL_ASSERT_PARTS(max->scale, "xrpl::ValidVault::computeMinScale", "scale set for destinationDelta");
-    return max->scale.value_or(STAmount::cMaxOffset);
-}
 }  // namespace xrpl

src/libxrpl/tx/transactors/Lending/LoanBrokerCoverWithdraw.cpp

@@ -121,7 +121,7 @@ LoanBrokerCoverWithdraw::preclaim(PreclaimContext const& ctx)
         return roundToAsset(
             vaultAsset,
             tenthBipsOfValue(currentDebtTotal, TenthBips32(sleBroker->at(sfCoverRateMinimum))),
-            numberScale(currentDebtTotal, vaultAsset));
+            currentDebtTotal.exponent());
     }();
     if (coverAvail < amount)
         return tecINSUFFICIENT_FUNDS;

src/test/app/Invariants_test.cpp

@@ -15,15 +15,10 @@
 #include <xrpl/protocol/TxFormats.h>
 #include <xrpl/protocol/XRPAmount.h>
 #include <xrpl/tx/ApplyContext.h>
-#include <xrpl/tx/InvariantCheck.h>
 #include <xrpl/tx/apply.h>
 
 #include <boost/algorithm/string/predicate.hpp>
 
-#include <initializer_list>
-#include <string>
-#include <vector>
-
 namespace xrpl {
 namespace test {
 
@@ -3711,124 +3706,6 @@ class Invariants_test : public beast::unit_test::suite
             precloseMpt);
     }
 
-    void
-    testVaultComputeMinScale()
-    {
-        using namespace jtx;
-
-        Account const issuer{"issuer"};
-        PrettyAsset const vaultAsset = issuer["IOU"];
-
-        struct TestCase
-        {
-            std::string name;
-            std::int32_t expectedMinScale;
-            std::vector<ValidVault::DeltaInfo> values;
-        };
-
-        NumberMantissaScaleGuard g{MantissaRange::large};
-
-        auto makeDelta = [&vaultAsset](Number const& n) -> ValidVault::DeltaInfo {
-            return {n, numberScale(n, vaultAsset.raw())};
-        };
-
-        auto const testCases = std::vector<TestCase>{
-            {
-                .name = "No values",
-                .expectedMinScale = 0,
-                .values = {},
-            },
-            {
-                .name = "Mixed integer and Number values",
-                .expectedMinScale = -15,
-                .values = {makeDelta(1), makeDelta(-1), makeDelta(Number{10, -1})},
-            },
-            {
-                .name = "Mixed scales",
-                .expectedMinScale = -17,
-                .values = {makeDelta(Number{1, -2}), makeDelta(Number{5, -3}), makeDelta(Number{3, -2})},
-            },
-            {
-                .name = "Equal scales",
-                .expectedMinScale = -16,
-                .values = {makeDelta(Number{1, -1}), makeDelta(Number{5, -1}), makeDelta(Number{1, -1})},
-            },
-            {
-                .name = "Mixed mantissa sizes",
-                .expectedMinScale = -12,
-                .values =
-                    {makeDelta(Number{1}),
-                     makeDelta(Number{1234, -3}),
-                     makeDelta(Number{12345, -6}),
-                     makeDelta(Number{123, 1})},
-            },
-        };
-
-        for (auto const& tc : testCases)
-        {
-            testcase("vault computeMinScale: " + tc.name);
-
-            auto const actualScale = ValidVault::computeMinScale(vaultAsset, tc.values);
-
-            BEAST_EXPECTS(
-                actualScale == tc.expectedMinScale,
-                "expected: " + std::to_string(tc.expectedMinScale) + ", actual: " + std::to_string(actualScale));
-            for (auto const& num : tc.values)
-            {
-                // None of these scales are far enough apart that rounding the
-                // values would lose information, so check that the rounded
-                // value matches the original.
-                auto const actualRounded = roundToAsset(vaultAsset, num.delta, actualScale);
-                BEAST_EXPECTS(
-                    actualRounded == num.delta,
-                    "number " + to_string(num.delta) + " rounded to scale " + std::to_string(actualScale) + " is " +
-                        to_string(actualRounded));
-            }
-        }
-
-        auto const testCases2 = std::vector<TestCase>{
-            {
-                .name = "False equivalence",
-                .expectedMinScale = -15,
-                .values =
-                    {
-                        makeDelta(Number{1234567890123456789, -18}),
-                        makeDelta(Number{12345, -4}),
-                        makeDelta(Number{1}),
-                    },
-            },
-        };
-
-        // Unlike the first set of test cases, the values in these test could
-        // look equivalent if using the wrong scale.
-        for (auto const& tc : testCases2)
-        {
-            testcase("vault computeMinScale: " + tc.name);
-
-            auto const actualScale = ValidVault::computeMinScale(vaultAsset, tc.values);
-
-            BEAST_EXPECTS(
-                actualScale == tc.expectedMinScale,
-                "expected: " + std::to_string(tc.expectedMinScale) + ", actual: " + std::to_string(actualScale));
-            std::optional<Number> first;
-            Number firstRounded;
-            for (auto const& num : tc.values)
-            {
-                if (!first)
-                {
-                    first = num.delta;
-                    firstRounded = roundToAsset(vaultAsset, num.delta, actualScale);
-                    continue;
-                }
-                auto const numRounded = roundToAsset(vaultAsset, num.delta, actualScale);
-                BEAST_EXPECTS(
-                    numRounded != firstRounded,
-                    "at a scale of " + std::to_string(actualScale) + " " + to_string(num.delta) +
-                        " == " + to_string(*first));
-            }
-        }
-    }
-
 public:
     void
     run() override
@@ -3854,7 +3731,6 @@ public:
         testValidPseudoAccounts();
         testValidLoanBroker();
         testVault();
-        testVaultComputeMinScale();
     }
 };
 

src/test/app/LendingHelpers_test.cpp

@@ -3,6 +3,7 @@
 #include <test/jtx.h>
 #include <test/jtx/Account.h>
 #include <test/jtx/amount.h>
+#include <test/jtx/mpt.h>
 
 #include <xrpl/beast/xor_shift_engine.h>
 #include <xrpl/protocol/SField.h>

src/test/app/LoanBroker_test.cpp

@@ -1700,21 +1700,10 @@ class LoanBroker_test : public beast::unit_test::suite
         testRIPD4274MPT();
     }
 
-    void
-    testFixAmendmentEnabled()
-    {
-        using namespace jtx;
-        testcase("testFixAmendmentEnabled");
-        Env env{*this};
-
-        BEAST_EXPECT(env.enabled(fixLendingProtocolV1_1));
-    }
-
 public:
     void
     run() override
     {
-        testFixAmendmentEnabled();
         testLoanBrokerSetDebtMaximum();
         testLoanBrokerCoverDepositNullVault();
 

src/test/app/Loan_test.cpp

@@ -6675,132 +6675,6 @@ protected:
         BEAST_EXPECT(afterSecondCoverAvailable == 0);
     }
 
-    // Tests that vault withdrawals work correctly when the vault has unrealized
-    // loss from an impaired loan, ensuring the invariant check properly
-    // accounts for the loss.
-    void
-    testWithdrawReflectsUnrealizedLoss()
-    {
-        using namespace jtx;
-        using namespace loan;
-        using namespace std::chrono_literals;
-
-        testcase("Vault withdraw reflects sfLossUnrealized");
-
-        // Test constants
-        static constexpr std::int64_t INITIAL_FUNDING = 1'000'000;
-        static constexpr std::int64_t LENDER_INITIAL_IOU = 5'000'000;
-        static constexpr std::int64_t DEPOSITOR_INITIAL_IOU = 1'000'000;
-        static constexpr std::int64_t BORROWER_INITIAL_IOU = 100'000;
-        static constexpr std::int64_t DEPOSIT_AMOUNT = 5'000;
-        static constexpr std::int64_t PRINCIPAL_AMOUNT = 99;
-        static constexpr std::uint64_t EXPECTED_SHARES_PER_DEPOSITOR = 5'000'000'000;
-        static constexpr std::uint32_t PAYMENT_INTERVAL = 600;
-        static constexpr std::uint32_t PAYMENT_TOTAL = 2;
-
-        Env env(*this, all);
-
-        // Setup accounts
-        Account const issuer{"issuer"};
-        Account const lender{"lender"};
-        Account const depositorA{"lpA"};
-        Account const depositorB{"lpB"};
-        Account const borrower{"borrowerA"};
-
-        env.fund(XRP(INITIAL_FUNDING), issuer, lender, depositorA, depositorB, borrower);
-        env.close();
-
-        // Setup trust lines
-        PrettyAsset const iouAsset = issuer[iouCurrency];
-        env(trust(lender, iouAsset(10'000'000)));
-        env(trust(depositorA, iouAsset(10'000'000)));
-        env(trust(depositorB, iouAsset(10'000'000)));
-        env(trust(borrower, iouAsset(10'000'000)));
-        env.close();
-
-        // Fund accounts with IOUs
-        env(pay(issuer, lender, iouAsset(LENDER_INITIAL_IOU)));
-        env(pay(issuer, depositorA, iouAsset(DEPOSITOR_INITIAL_IOU)));
-        env(pay(issuer, depositorB, iouAsset(DEPOSITOR_INITIAL_IOU)));
-        env(pay(issuer, borrower, iouAsset(BORROWER_INITIAL_IOU)));
-        env.close();
-
-        // Create vault and broker, then add deposits from two depositors
-        auto const broker = createVaultAndBroker(env, iouAsset, lender);
-        Vault v{env};
-
-        env(v.deposit({
-                .depositor = depositorA,
-                .id = broker.vaultKeylet().key,
-                .amount = iouAsset(DEPOSIT_AMOUNT),
-            }),
-            ter(tesSUCCESS));
-        env(v.deposit({
-                .depositor = depositorB,
-                .id = broker.vaultKeylet().key,
-                .amount = iouAsset(DEPOSIT_AMOUNT),
-            }),
-            ter(tesSUCCESS));
-        env.close();
-
-        // Create a loan
-        auto const sleBroker = env.le(keylet::loanbroker(broker.brokerID));
-        if (!BEAST_EXPECT(sleBroker))
-            return;
-
-        auto const loanKeylet = keylet::loan(broker.brokerID, sleBroker->at(sfLoanSequence));
-
-        env(set(borrower, broker.brokerID, PRINCIPAL_AMOUNT),
-            sig(sfCounterpartySignature, lender),
-            paymentTotal(PAYMENT_TOTAL),
-            paymentInterval(PAYMENT_INTERVAL),
-            fee(env.current()->fees().base * 2),
-            ter(tesSUCCESS));
-        env.close();
-
-        // Impair the loan to create unrealized loss
-        env(manage(lender, loanKeylet.key, tfLoanImpair), ter(tesSUCCESS));
-        env.close();
-
-        // Verify unrealized loss is recorded in the vault
-        auto const vaultAfterImpair = env.le(broker.vaultKeylet());
-        if (!BEAST_EXPECT(vaultAfterImpair))
-            return;
-
-        BEAST_EXPECT(vaultAfterImpair->at(sfLossUnrealized) == broker.asset(PRINCIPAL_AMOUNT).value());
-
-        // Helper to get share balance for a depositor
-        auto const shareAsset = vaultAfterImpair->at(sfShareMPTID);
-        auto const getShareBalance = [&](Account const& depositor) -> std::uint64_t {
-            auto const token = env.le(keylet::mptoken(shareAsset, depositor.id()));
-            return token ? token->getFieldU64(sfMPTAmount) : 0;
-        };
-
-        // Verify both depositors have equal shares
-        auto const sharesLpA = getShareBalance(depositorA);
-        auto const sharesLpB = getShareBalance(depositorB);
-        BEAST_EXPECT(sharesLpA == EXPECTED_SHARES_PER_DEPOSITOR);
-        BEAST_EXPECT(sharesLpB == EXPECTED_SHARES_PER_DEPOSITOR);
-        BEAST_EXPECT(sharesLpA == sharesLpB);
-
-        // Helper to attempt withdrawal
-        auto const attemptWithdrawShares = [&](Account const& depositor, std::uint64_t shareAmount, TER expected) {
-            STAmount const shareAmt{MPTIssue{shareAsset}, Number(shareAmount)};
-            env(v.withdraw({.depositor = depositor, .id = broker.vaultKeylet().key, .amount = shareAmt}),
-                ter(expected));
-            env.close();
-        };
-
-        // Regression test: Both depositors should successfully withdraw despite
-        // unrealized loss. Previously failed with invariant violation:
-        // "withdrawal must change vault and destination balance by equal
-        // amount". This was caused by sharesToAssetsWithdraw rounding down,
-        // creating a mismatch where vaultDeltaAssets * -1 != destinationDelta
-        // when unrealized loss exists.
-        attemptWithdrawShares(depositorA, sharesLpA, tesSUCCESS);
-        attemptWithdrawShares(depositorB, sharesLpB, tesSUCCESS);
-    }
-
 public:
     void
     run() override
@@ -6809,7 +6683,6 @@ public:
         testLoanPayLateFullPaymentBypassesPenalties();
         testLoanCoverMinimumRoundingExploit();
 #endif
-        testWithdrawReflectsUnrealizedLoss();
         testInvalidLoanSet();
 
         testCoverDepositWithdrawNonTransferableMPT();