Update several unit tests to work with the new number rules

ximinez · ximinez · commit 3f87aeb6b53e · 2025-11-28T18:43:50.000-05:00
- For AMM tests, just disable the SAV amendment because there are
  a boatload of results that depend on the old math. Those will be
  updated later.
diff --git a/src/test/app/AMMExtended_test.cpp b/src/test/app/AMMExtended_test.cpp
@@ -45,10 +45,6 @@ struct AMMExtended_test : public jtx::AMMTest
         // funded and not used for the payment.
 
         using namespace jtx;
-        // For now, just disable SAV entirely, which locks in the small Number
-        // mantissas
-        features =
-            features - featureSingleAssetVault /* - featureLendingProtocol */;
 
         Env env{*this, features};
 
@@ -1426,7 +1422,12 @@ struct AMMExtended_test : public jtx::AMMTest
     testOffers()
     {
         using namespace jtx;
-        FeatureBitset const all{testable_amendments()};
+        // For now, just disable SAV entirely, which locks in the small Number
+        // mantissas
+        FeatureBitset const all{
+            testable_amendments() -
+            featureSingleAssetVault /* - featureLendingProtocol */};
+
         testRmFundedOffer(all);
         testRmFundedOffer(all - fixAMMv1_1 - fixAMMv1_3);
         testEnforceNoRipple(all);
@@ -3754,7 +3755,11 @@ struct AMMExtended_test : public jtx::AMMTest
     testFlow()
     {
         using namespace jtx;
-        FeatureBitset const all{testable_amendments()};
+        // For now, just disable SAV entirely, which locks in the small Number
+        // mantissas in the transaction engine
+        FeatureBitset const all{
+            testable_amendments() -
+            featureSingleAssetVault /* - featureLendingProtocol */};
 
         testFalseDry(all);
         testBookStep(all);
@@ -3768,7 +3773,11 @@ struct AMMExtended_test : public jtx::AMMTest
     testCrossingLimits()
     {
         using namespace jtx;
-        FeatureBitset const all{testable_amendments()};
+        // For now, just disable SAV entirely, which locks in the small Number
+        // mantissas in the transaction engine
+        FeatureBitset const all{
+            testable_amendments() -
+            featureSingleAssetVault /* - featureLendingProtocol */};
         testStepLimit(all);
         testStepLimit(all - fixAMMv1_1 - fixAMMv1_3);
     }
@@ -3777,23 +3786,36 @@ struct AMMExtended_test : public jtx::AMMTest
     testDeliverMin()
     {
         using namespace jtx;
-        FeatureBitset const all{testable_amendments()};
+        // For now, just disable SAV entirely, which locks in the small Number
+        // mantissas in the transaction engine
+        FeatureBitset const all{
+            testable_amendments() -
+            featureSingleAssetVault /* - featureLendingProtocol */};
         test_convert_all_of_an_asset(all);
         test_convert_all_of_an_asset(all - fixAMMv1_1 - fixAMMv1_3);
     }
 
     void
     testDepositAuth()
     {
-        testPayment(jtx::testable_amendments());
+        // For now, just disable SAV entirely, which locks in the small Number
+        // mantissas in the transaction engine
+        FeatureBitset const all{
+            jtx::testable_amendments() -
+            featureSingleAssetVault /* - featureLendingProtocol */};
+        testPayment(all);
         testPayIOU();
     }
 
     void
     testFreeze()
     {
         using namespace test::jtx;
-        auto const sa = testable_amendments();
+        // For now, just disable SAV entirely, which locks in the small Number
+        // mantissas in the transaction engine
+        FeatureBitset const sa{
+            testable_amendments() -
+            featureSingleAssetVault /* - featureLendingProtocol */};
         testRippleState(sa);
         testGlobalFreeze(sa);
         testOffersWhenFrozen(sa);
diff --git a/src/test/app/EscrowToken_test.cpp b/src/test/app/EscrowToken_test.cpp
@@ -559,12 +559,16 @@ struct EscrowToken_test : public beast::unit_test::suite
             env(pay(gw, bob, USD(1)));
             env.close();
 
+            bool const largeMantissa = features[featureSingleAssetVault] /* ||
+                features[featureLendingProtocol]*/
+                ;
+
             // alice cannot create escrow for 1/10 iou - precision loss
             env(escrow::create(alice, bob, USD(1)),
                 escrow::condition(escrow::cb1),
                 escrow::finish_time(env.now() + 1s),
                 fee(baseFee * 150),
-                ter(tecPRECISION_LOSS));
+                ter(largeMantissa ? (TER)tesSUCCESS : (TER)tecPRECISION_LOSS));
             env.close();
         }
     }
@@ -2076,12 +2080,16 @@ struct EscrowToken_test : public beast::unit_test::suite
             env(pay(gw, bob, USD(1)));
             env.close();
 
+            bool const largeMantissa = features[featureSingleAssetVault] /* ||
+                features[featureLendingProtocol]*/
+                ;
+
             // alice cannot create escrow for 1/10 iou - precision loss
             env(escrow::create(alice, bob, USD(1)),
                 escrow::condition(escrow::cb1),
                 escrow::finish_time(env.now() + 1s),
                 fee(baseFee * 150),
-                ter(tecPRECISION_LOSS));
+                ter(largeMantissa ? (TER)tesSUCCESS : (TER)tecPRECISION_LOSS));
             env.close();
 
             auto const seq1 = env.seq(alice);
@@ -3924,9 +3932,13 @@ struct EscrowToken_test : public beast::unit_test::suite
     {
         using namespace test::jtx;
         FeatureBitset const all{testable_amendments()};
-        testIOUWithFeats(all);
-        testMPTWithFeats(all);
-        testMPTWithFeats(all - fixTokenEscrowV1);
+        for (FeatureBitset const& feats :
+             {all - featureSingleAssetVault /*- featureLendingProtocol*/, all})
+        {
+            testIOUWithFeats(feats);
+            testMPTWithFeats(feats);
+            testMPTWithFeats(feats - fixTokenEscrowV1);
+        }
     }
 };
 
diff --git a/src/test/basics/IOUAmount_test.cpp b/src/test/basics/IOUAmount_test.cpp
@@ -141,15 +141,35 @@ class IOUAmount_test : public beast::unit_test::suite
     {
         testcase("IOU strings");
 
-        BEAST_EXPECT(to_string(IOUAmount(-2, 0)) == "-2");
-        BEAST_EXPECT(to_string(IOUAmount(0, 0)) == "0");
-        BEAST_EXPECT(to_string(IOUAmount(2, 0)) == "2");
-        BEAST_EXPECT(to_string(IOUAmount(25, -3)) == "0.025");
-        BEAST_EXPECT(to_string(IOUAmount(-25, -3)) == "-0.025");
-        BEAST_EXPECT(to_string(IOUAmount(25, 1)) == "250");
-        BEAST_EXPECT(to_string(IOUAmount(-25, 1)) == "-250");
-        BEAST_EXPECT(to_string(IOUAmount(2, 20)) == "2000000000000000e5");
-        BEAST_EXPECT(to_string(IOUAmount(-2, -20)) == "-2000000000000000e-35");
+        auto test = [this](IOUAmount const& n, std::string const& expected) {
+            auto const result = to_string(n);
+            std::stringstream ss;
+            ss << "to_string(" << result << "). Expected: " << expected;
+            BEAST_EXPECTS(result == expected, ss.str());
+        };
+
+        for (auto const mantissaSize :
+             {MantissaRange::small, MantissaRange::large})
+        {
+            NumberMantissaScaleGuard mg(mantissaSize);
+
+            test(IOUAmount(-2, 0), "-2");
+            test(IOUAmount(0, 0), "0");
+            test(IOUAmount(2, 0), "2");
+            test(IOUAmount(25, -3), "0.025");
+            test(IOUAmount(-25, -3), "-0.025");
+            test(IOUAmount(25, 1), "250");
+            test(IOUAmount(-25, 1), "-250");
+            test(
+                IOUAmount(2, 20),
+                mantissaSize == MantissaRange::small ? "2000000000000000e5"
+                                                     : "2000000000000000000e2");
+            test(
+                IOUAmount(-2, -20),
+                mantissaSize == MantissaRange::small
+                    ? "-2000000000000000e-35"
+                    : "-2000000000000000000e-38");
+        }
     }
 
     void
diff --git a/src/test/rpc/GetAggregatePrice_test.cpp b/src/test/rpc/GetAggregatePrice_test.cpp
@@ -191,18 +191,41 @@ class GetAggregatePrice_test : public beast::unit_test::suite
         // Aggregate data set includes all price oracle instances, no trimming
         // or time threshold
         {
-            Env env(*this);
-            OraclesData oracles;
-            prep(env, oracles);
-            // entire and trimmed stats
-            auto ret = Oracle::aggregatePrice(env, "XRP", "USD", oracles);
-            BEAST_EXPECT(ret[jss::entire_set][jss::mean] == "74.45");
-            BEAST_EXPECT(ret[jss::entire_set][jss::size].asUInt() == 10);
-            BEAST_EXPECT(
-                ret[jss::entire_set][jss::standard_deviation] ==
-                "0.3027650354097492");
-            BEAST_EXPECT(ret[jss::median] == "74.45");
-            BEAST_EXPECT(ret[jss::time] == 946694900);
+            auto const all = testable_amendments();
+            for (auto const& feats :
+                 {all - featureSingleAssetVault /* -
+                  featureLendingProtocol */
+                  ,
+                  all})
+            {
+                for (auto const mantissaSize :
+                     {MantissaRange::small, MantissaRange::large})
+                {
+                    // Regardless of the features enabled, RPC is controlled by
+                    // the global mantissa size. And since it's a thread-local,
+                    // overriding it locally won't make a difference either.
+                    // This will mean all RPC will use the default of "large".
+                    NumberMantissaScaleGuard mg(mantissaSize);
+
+                    Env env(*this, feats);
+                    OraclesData oracles;
+                    prep(env, oracles);
+                    // entire and trimmed stats
+                    auto ret =
+                        Oracle::aggregatePrice(env, "XRP", "USD", oracles);
+                    BEAST_EXPECT(ret[jss::entire_set][jss::mean] == "74.45");
+                    BEAST_EXPECT(
+                        ret[jss::entire_set][jss::size].asUInt() == 10);
+                    // Short: 0.3027650354097492
+                    BEAST_EXPECTS(
+                        ret[jss::entire_set][jss::standard_deviation] ==
+                            "0.3027650354097491666",
+                        ret[jss::entire_set][jss::standard_deviation]
+                            .asString());
+                    BEAST_EXPECT(ret[jss::median] == "74.45");
+                    BEAST_EXPECT(ret[jss::time] == 946694900);
+                }
+            }
         }
 
         // Aggregate data set includes all price oracle instances
@@ -215,15 +238,19 @@ class GetAggregatePrice_test : public beast::unit_test::suite
                 Oracle::aggregatePrice(env, "XRP", "USD", oracles, 20, 100);
             BEAST_EXPECT(ret[jss::entire_set][jss::mean] == "74.45");
             BEAST_EXPECT(ret[jss::entire_set][jss::size].asUInt() == 10);
-            BEAST_EXPECT(
+            // Short: "0.3027650354097492",
+            BEAST_EXPECTS(
                 ret[jss::entire_set][jss::standard_deviation] ==
-                "0.3027650354097492");
+                    "0.3027650354097491666",
+                ret[jss::entire_set][jss::standard_deviation].asString());
             BEAST_EXPECT(ret[jss::median] == "74.45");
             BEAST_EXPECT(ret[jss::trimmed_set][jss::mean] == "74.45");
             BEAST_EXPECT(ret[jss::trimmed_set][jss::size].asUInt() == 6);
-            BEAST_EXPECT(
+            // Short: "0.187082869338697",
+            BEAST_EXPECTS(
                 ret[jss::trimmed_set][jss::standard_deviation] ==
-                "0.187082869338697");
+                    "0.1870828693386970693",
+                ret[jss::trimmed_set][jss::standard_deviation].asString());
             BEAST_EXPECT(ret[jss::time] == 946694900);
         }
 
@@ -274,15 +301,19 @@ class GetAggregatePrice_test : public beast::unit_test::suite
                 Oracle::aggregatePrice(env, "XRP", "USD", oracles, 20, "200");
             BEAST_EXPECT(ret[jss::entire_set][jss::mean] == "74.6");
             BEAST_EXPECT(ret[jss::entire_set][jss::size].asUInt() == 7);
-            BEAST_EXPECT(
+            // Short: 0.2160246899469287
+            BEAST_EXPECTS(
                 ret[jss::entire_set][jss::standard_deviation] ==
-                "0.2160246899469287");
+                    "0.2160246899469286744",
+                ret[jss::entire_set][jss::standard_deviation].asString());
             BEAST_EXPECT(ret[jss::median] == "74.6");
             BEAST_EXPECT(ret[jss::trimmed_set][jss::mean] == "74.6");
             BEAST_EXPECT(ret[jss::trimmed_set][jss::size].asUInt() == 5);
-            BEAST_EXPECT(
+            // Short: 0.158113883008419
+            BEAST_EXPECTS(
                 ret[jss::trimmed_set][jss::standard_deviation] ==
-                "0.158113883008419");
+                    "0.1581138830084189666",
+                ret[jss::trimmed_set][jss::standard_deviation].asString());
             BEAST_EXPECT(ret[jss::time] == 946694900);
         }
 
diff --git a/src/xrpld/app/tx/detail/Transactor.cpp b/src/xrpld/app/tx/detail/Transactor.cpp
@@ -592,24 +592,6 @@ Transactor::ticketDelete(
     return tesSUCCESS;
 }
 
-bool
-Transactor::useOldNumberRules(TxType txType)
-{
-    constexpr auto skipTransactions = std::to_array<TxType>(
-        {ttAMM_BID,
-         ttAMM_CLAWBACK,
-         ttAMM_CREATE,
-         ttAMM_DELETE,
-         ttAMM_DEPOSIT,
-         ttAMM_VOTE,
-         ttAMM_WITHDRAW});
-
-    return std::find(
-               std::begin(skipTransactions),
-               std::end(skipTransactions),
-               txType) != std::end(skipTransactions);
-}
-
 // check stuff before you bother to lock the ledger
 void
 Transactor::preCompute()
@@ -1132,8 +1114,6 @@ Transactor::operator()()
     // fixUniversalNumber predate the rulesGuard and should be replaced.
     NumberSO stNumberSO{view().rules().enabled(fixUniversalNumber)};
     CurrentTransactionRulesGuard currentTransctionRulesGuard(view().rules());
-    if (Transactor::useOldNumberRules(ctx_.tx.getTxnType()))
-        Number::setMantissaScale(MantissaRange::small);
 
 #ifdef DEBUG
     {
diff --git a/src/xrpld/app/tx/detail/Transactor.h b/src/xrpld/app/tx/detail/Transactor.h
@@ -230,9 +230,6 @@ class Transactor
         uint256 const& ticketIndex,
         beast::Journal j);
 
-    static bool
-    useOldNumberRules(TxType txType);
-
 protected:
     TER
     apply();
diff --git a/src/xrpld/app/tx/detail/applySteps.cpp b/src/xrpld/app/tx/detail/applySteps.cpp
@@ -51,15 +51,19 @@ with_txn_type(Rules const& rules, TxType txnType, F&& f)
     //
     std::optional<NumberSO> stNumberSO;
     std::optional<CurrentTransactionRulesGuard> rulesGuard;
+    std::optional<NumberMantissaScaleGuard> mantissaScaleGuard;
     if (rules.enabled(featureSingleAssetVault) /*|| rules.enabled(featureLendingProtocol)*/)
     {
         // raii classes for the current ledger rules.
-        // fixUniversalNumber predate the rulesGuard and should be replaced.
+        // fixUniversalNumber predates the rulesGuard and should be replaced.
         stNumberSO.emplace(rules.enabled(fixUniversalNumber));
         rulesGuard.emplace(rules);
     }
-    if (Transactor::useOldNumberRules(txnType))
-        Number::setMantissaScale(MantissaRange::small);
+    else
+    {
+        // Without those features enabled, always use the old number rules.
+        mantissaScaleGuard.emplace(MantissaRange::small);
+    }
 
     switch (txnType)
     {
