Merge branch 'develop' into ripple/wasmi

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

CMakeLists.txt

@@ -96,6 +96,7 @@ find_package(OpenSSL REQUIRED)
 find_package(secp256k1 REQUIRED)
 find_package(SOCI REQUIRED)
 find_package(SQLite3 REQUIRED)
+find_package(wasmi REQUIRED)
 find_package(xxHash REQUIRED)
 
 target_link_libraries(

cmake/XrplCore.cmake

@@ -67,6 +67,7 @@ target_link_libraries(
         Xrpl::opts
         Xrpl::syslibs
         secp256k1::secp256k1
+        wasmi::wasmi
         xrpl.libpb
         xxHash::xxhash
         $<$<BOOL:${voidstar}>:antithesis-sdk-cpp>

conan.lock

@@ -3,6 +3,7 @@
     "requires": [
         "zlib/1.3.2#1cb806da49011867778ffb6ac7190fcb%1782392402.122708",
         "xxhash/0.8.3#681d36a0a6111fc56e5e45ea182c19cc%1782392402.420688",
+        "wasmi/1.0.9#1fecdab9b90c96698eb35ea99ca4f5cb%1782307153.343419",
         "sqlite3/3.53.0#324ada52333108388a9a6108bfa96734%1782392403.185447",
         "soci/4.0.3#e726491a03468795453f7c83fc924a96%1782392402.679521",
         "snappy/1.1.10#968fef506ff261592ec30c574d4a7809%1782307151.633168",

conanfile.py

@@ -34,6 +34,7 @@ class Xrpl(ConanFile):
         "nudb/2.0.9",
         "openssl/3.6.3",
         "soci/4.0.3",
+        "wasmi/1.0.9",
         "zlib/1.3.2",
     ]
 
@@ -221,6 +222,7 @@ class Xrpl(ConanFile):
             "soci::soci",
             "secp256k1::secp256k1",
             "sqlite3::sqlite",
+            "wasmi::wasmi",
             "xxhash::xxhash",
             "zlib::zlib",
         ]

src/libxrpl/basics/Number.cpp

@@ -260,11 +260,6 @@ public:
     unsigned
     pop() noexcept;
 
-    // if true, there are no recoverable digits in the guard, though there may be dropped digits
-    // (xbit_)
-    [[nodiscard]] bool
-    unrecoverable() const noexcept;
-
     // if true, there are no digits in the guard, including dropped digits (xbit_)
     [[nodiscard]] bool
     empty() const noexcept;
@@ -282,17 +277,6 @@ public:
     void
     doDropDigit(T& mantissa, int& exponent) noexcept;
 
-    /**
-     * Drop a digit from the mantissa, and increment the exponent, storing the dropped digit in
-     * this Guard.
-     *
-     * If a drop will not do anything meaningful (there are no recoverable digits in the guard, and
-     * the mantissa is 0), and if targetExponent > exponent, simply set exponent to targetExponent.
-     */
-    template <class T>
-    void
-    doDropDigitWithTarget(T& mantissa, int& exponent, int const targetExponent) noexcept;
-
     // Modify the result to the correctly rounded value
     template <UnsignedMantissa T>
     void
@@ -390,16 +374,10 @@ Number::Guard::pop() noexcept
     return d;
 }
 
-inline bool
-Number::Guard::unrecoverable() const noexcept
-{
-    return digits_ == 0;
-}
-
 inline bool
 Number::Guard::empty() const noexcept
 {
-    return unrecoverable() && !xbit_;
+    return digits_ == 0 && !xbit_;
 }
 
 template <class T>
@@ -423,22 +401,6 @@ Number::Guard::doDropDigit<uint128_t>(uint128_t& mantissa, int& exponent) noexce
     ++exponent;
 }
 
-template <class T>
-void
-Number::Guard::doDropDigitWithTarget(T& mantissa, int& exponent, int const targetExponent) noexcept
-{
-    XRPL_ASSERT(
-        targetExponent > exponent, "Number::Guard::doDropDigitWithTarget : something to do");
-    if (mantissa == 0 && unrecoverable() && targetExponent > exponent)
-    {
-        // No number of dropped digits is going to change any of the operative parameters at this
-        // point.
-        exponent = targetExponent;
-        return;
-    }
-    doDropDigit(mantissa, exponent);
-}
-
 template <UnsignedMantissa T>
 void
 Number::Guard::pushOverflow(T mantissa)
@@ -973,8 +935,6 @@ Number::operator+=(Number const& y)
             // 1. First, shrink the mantissa of shrinkM/shrinkE while shrinkM ends in 0.
             while (shrinkE < expandE && shrinkM % 10 == 0)
             {
-                // Don't use doDropDigitWithTarget here, because the loop will stop before the
-                // mantissa gets to 0.
                 g.doDropDigit(shrinkM, shrinkE);
             }
 
@@ -992,7 +952,7 @@ Number::operator+=(Number const& y)
         // digits will be put into the Guard. This is the only step for non-Enabled330 modes.
         while (shrinkE < expandE)
         {
-            g.doDropDigitWithTarget(shrinkM, shrinkE, expandE);
+            g.doDropDigit(shrinkM, shrinkE);
         }
     };
 

src/test/protocol/STNumber_test.cpp

@@ -12,7 +12,6 @@
 #include <exception>
 #include <initializer_list>
 #include <limits>
-#include <sstream>
 #include <stdexcept>
 #include <string>
 #include <type_traits>
@@ -177,32 +176,61 @@ struct STNumber_test : public beast::unit_test::Suite
                 numberFromJson(sfNumber, std::to_string(kUMax)) ==
                 STNumber(sfNumber, Number(kUMax, 0)));
 
-            auto const expectJsonThrows = [this](
-                                              json::Value const& num, std::string const& expected) {
-                try
-                {
-                    numberFromJson(sfNumber, num);
-                    fail();
-                }
-                catch (std::exception const& e)
-                {
-                    std::ostringstream out;
-                    out << "Json: " << num.asString() << " got exception: " << e.what()
-                        << ", expected: " << expected;
-                    BEAST_EXPECTS(std::string(e.what()) == expected, out.str());
-                }
-            };
-
-            // Obvious overflows tested here
-            expectJsonThrows("1e2000000", "Number::normalize 2");
-            expectJsonThrows("1e2000000000", "Number::normalize 2");
-
             // Obvious non-numbers tested here
-            expectJsonThrows("", "'' is not a number");
-            expectJsonThrows("e", "'e' is not a number");
-            expectJsonThrows("1e", "'1e' is not a number");
-            expectJsonThrows("e2", "'e2' is not a number");
-            expectJsonThrows(json::Value(), "not a number");
+            try
+            {
+                auto _ = numberFromJson(sfNumber, "");
+                BEAST_EXPECT(false);
+            }
+            catch (std::runtime_error const& e)
+            {
+                std::string const expected = "'' is not a number";
+                BEAST_EXPECT(e.what() == expected);
+            }
+
+            try
+            {
+                auto _ = numberFromJson(sfNumber, "e");
+                BEAST_EXPECT(false);
+            }
+            catch (std::runtime_error const& e)
+            {
+                std::string const expected = "'e' is not a number";
+                BEAST_EXPECT(e.what() == expected);
+            }
+
+            try
+            {
+                auto _ = numberFromJson(sfNumber, "1e");
+                BEAST_EXPECT(false);
+            }
+            catch (std::runtime_error const& e)
+            {
+                std::string const expected = "'1e' is not a number";
+                BEAST_EXPECT(e.what() == expected);
+            }
+
+            try
+            {
+                auto _ = numberFromJson(sfNumber, "e2");
+                BEAST_EXPECT(false);
+            }
+            catch (std::runtime_error const& e)
+            {
+                std::string const expected = "'e2' is not a number";
+                BEAST_EXPECT(e.what() == expected);
+            }
+
+            try
+            {
+                auto _ = numberFromJson(sfNumber, json::Value());
+                BEAST_EXPECT(false);
+            }
+            catch (std::runtime_error const& e)
+            {
+                std::string const expected = "not a number";
+                BEAST_EXPECT(e.what() == expected);
+            }
 
             try
             {

src/tests/libxrpl/basics/Number.cpp

@@ -1,6 +1,5 @@
 #include <xrpl/basics/Number.h>
 
-#include <xrpl/beast/utility/Zero.h>
 #include <xrpl/protocol/IOUAmount.h>
 #include <xrpl/protocol/Issue.h>
 #include <xrpl/protocol/STAmount.h>
@@ -184,17 +183,6 @@ TEST(NumberTest, limits)
         }
         EXPECT_TRUE(caught);
 
-        try
-        {
-            Number{1, 2000000, Number::Normalized{}};
-            ADD_FAILURE();
-        }
-        catch (std::overflow_error const& e)
-        {
-            std::string const expected = "Number::normalize 2";
-            EXPECT_EQ(e.what(), expected) << e.what();
-        }
-
         if (scale == MantissaRange::MantissaScale::Large330)
         {
             // Normalization with the other scales, including the older large mantissa scales, will
@@ -415,37 +403,6 @@ TEST(NumberTest, add)
             }
             EXPECT_TRUE(caught);
         }
-
-        // Special case: Exponents at each end of the allowable range
-        for (auto const round :
-             {Number::RoundingMode::ToNearest,
-              Number::RoundingMode::TowardsZero,
-              Number::RoundingMode::Downward,
-              Number::RoundingMode::Upward})
-        {
-            NumberRoundModeGuard const rg{round};
-            auto const x =
-                Number{Number::minMantissa(), Number::kMaxExponent, Number::Normalized{}};
-            auto const y =
-                Number{Number::minMantissa(), Number::kMinExponent, Number::Normalized{}};
-            EXPECT_EQ(x.exponent(), Number::kMaxExponent);
-            EXPECT_NE(x, beast::kZero);
-            EXPECT_EQ(y.exponent(), Number::kMinExponent);
-            EXPECT_NE(y, beast::kZero);
-            auto const result = x + y;
-
-            if (round == Number::RoundingMode::Upward)
-            {
-                // Rounding upward will take that little x-bit and round result up to the next
-                // representable value.
-                EXPECT_NE(result, x);
-                EXPECT_EQ(result, (Number{x.mantissa() + 1, x.exponent()}));
-            }
-            else
-            {
-                EXPECT_EQ(result, x);
-            }
-        }
     }
 }