diff --git a/src/tests/libxrpl/tx/wasm/FloatFixture.h b/src/tests/libxrpl/tx/wasm/FloatFixture.h
index b5cbb66a21..5744cb53f4 100644
--- a/src/tests/libxrpl/tx/wasm/FloatFixture.h
+++ b/src/tests/libxrpl/tx/wasm/FloatFixture.h
@@ -11,40 +11,34 @@
 
 namespace xrpl::test {
 
-// Known float bit patterns (12-byte `wasm_float` regions) — inputs / expected values for
-// the float host functions. `kNormalExp` is the exponent offset the encoding uses.
-namespace floats {
-inline constexpr int kNormalExp = 18;
-
-// clang-format off
-inline Bytes const kIntMin      = {0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00};  // -2^63 (rounds to -(2^63-1))
-inline Bytes const kIntZero     = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00};  // 0
-inline Bytes const kIntMax      = {0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00};  // 2^63-1
-inline Bytes const kUintMax     = {0x19, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9A, 0x00, 0x00, 0x00, 0x01};  // 2^64-1
-inline Bytes const kMaxExp      = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00};  // 1e(kMaxExponent + kNormalExp)
-inline Bytes const kPreMaxExp   = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF};  // 1e(kMaxExponent + kNormalExp - 1)
-inline Bytes const kMinusMaxExp = {0xF2, 0x1F, 0x49, 0x4C, 0x58, 0x9C, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00};  // -1e(kMaxExponent + kNormalExp)
-inline Bytes const kMinExp      = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00};  // 1e(kMinExponent - kNormalExp)
-inline Bytes const kMax         = {0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x80, 0x00};  // kMaxRep e(kMaxExponent - kNormalExp)
-inline Bytes const kMaxIOU      = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x63, 0xFF, 0x9C, 0x00, 0x00, 0x00, 0x4E};  // 9999999999999999e(96)
-inline Bytes const kMinIOU      = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x9D};  // 1e(-81)
-inline Bytes const kOne         = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xEE};  // 1
-inline Bytes const kMinusOne    = {0xF2, 0x1F, 0x49, 0x4C, 0x58, 0x9C, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xEE};  // -1
-inline Bytes const kOneMore     = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x03, 0xE8, 0xFF, 0xFF, 0xFF, 0xEE};  // 1.000000000000001
-inline Bytes const kTwo         = {0x1B, 0xC1, 0x6D, 0x67, 0x4E, 0xC8, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xEE};  // 2
-inline Bytes const kTen         = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xEF};  // 10
-inline Bytes const kPi          = {0x2B, 0x99, 0x2D, 0xDF, 0xA2, 0x32, 0x48, 0xE8, 0xFF, 0xFF, 0xFF, 0xEE};  // 3.141592653589793
-inline Bytes const kInvalidZero = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00};  // non-canonical zero
-inline Bytes const kMinusThree  = {0xD6, 0x5D, 0xDB, 0xE5, 0x09, 0xD4, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xEE};  // -3
-// clang-format on
-
-inline std::string const kInvalidData = "invalid_data";
-}  // namespace floats
-
 struct FloatTest : WasmImplTest
 {
     static constexpr std::int64_t kMin64 = std::numeric_limits<std::int64_t>::min();
     static constexpr std::int64_t kMax64 = std::numeric_limits<std::int64_t>::max();
+    static constexpr std::int32_t kNormalExp = 18;
+    static inline std::string const kInvalidData = "invalid_data";
+
+    // clang-format off
+    static inline Bytes const kIntMin      = {0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00};  // -2^63 (rounds to -(2^63-1))
+    static inline Bytes const kIntZero     = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00};  // 0
+    static inline Bytes const kIntMax      = {0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00};  // 2^63-1
+    static inline Bytes const kUintMax     = {0x19, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x9A, 0x00, 0x00, 0x00, 0x01};  // 2^64-1
+    static inline Bytes const kMaxExp      = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00};  // 1e(kMaxExponent + kNormalExp)
+    static inline Bytes const kPreMaxExp   = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF};  // 1e(kMaxExponent + kNormalExp - 1)
+    static inline Bytes const kMinusMaxExp = {0xF2, 0x1F, 0x49, 0x4C, 0x58, 0x9C, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00};  // -1e(kMaxExponent + kNormalExp)
+    static inline Bytes const kMinExp      = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00};  // 1e(kMinExponent - kNormalExp)
+    static inline Bytes const kMax         = {0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x80, 0x00};  // kMaxRep e(kMaxExponent - kNormalExp)
+    static inline Bytes const kMaxIOU      = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x63, 0xFF, 0x9C, 0x00, 0x00, 0x00, 0x4E};  // 9999999999999999e(96)
+    static inline Bytes const kMinIOU      = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x9D};  // 1e(-81)
+    static inline Bytes const kOne         = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xEE};  // 1
+    static inline Bytes const kMinusOne    = {0xF2, 0x1F, 0x49, 0x4C, 0x58, 0x9C, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xEE};  // -1
+    static inline Bytes const kOneMore     = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x03, 0xE8, 0xFF, 0xFF, 0xFF, 0xEE};  // 1.000000000000001
+    static inline Bytes const kTwo         = {0x1B, 0xC1, 0x6D, 0x67, 0x4E, 0xC8, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xEE};  // 2
+    static inline Bytes const kTen         = {0x0D, 0xE0, 0xB6, 0xB3, 0xA7, 0x64, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xEF};  // 10
+    static inline Bytes const kPi          = {0x2B, 0x99, 0x2D, 0xDF, 0xA2, 0x32, 0x48, 0xE8, 0xFF, 0xFF, 0xFF, 0xEE};  // 3.141592653589793
+    static inline Bytes const kInvalidZero = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00};  // non-canonical zero
+    static inline Bytes const kMinusThree  = {0xD6, 0x5D, 0xDB, 0xE5, 0x09, 0xD4, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xEE};  // -3
+    // clang-format on
 
     static Slice
     slice(Bytes const& b)
diff --git a/src/tests/libxrpl/tx/wasm/host_functions/FloatAdd.cpp b/src/tests/libxrpl/tx/wasm/host_functions/FloatAdd.cpp
index 31daa29eda..6864794411 100644
--- a/src/tests/libxrpl/tx/wasm/host_functions/FloatAdd.cpp
+++ b/src/tests/libxrpl/tx/wasm/host_functions/FloatAdd.cpp
@@ -14,33 +14,36 @@ struct FloatAddImpl : FloatTest
 TEST_F(FloatAddImpl, BadModeIsMalformed)
 {
     expectError(
-        makeHost()->floatAdd(slice(floats::kOne), slice(floats::kOne), -1),
+        makeHost()->floatAdd(slice(FloatTest::kOne), slice(FloatTest::kOne), -1),
         HostFunctionError::FloatInputMalformed);
 }
 
 TEST_F(FloatAddImpl, MalformedInput)
 {
     expectError(
-        makeHost()->floatAdd(slice(floats::kOne), Slice{}, 0),
+        makeHost()->floatAdd(slice(FloatTest::kOne), Slice{}, 0),
         HostFunctionError::FloatInputMalformed);
 }
 
 TEST_F(FloatAddImpl, MaxIouPlusMaxExpIsMaxExp)
 {
     expectValue(
-        makeHost()->floatAdd(slice(floats::kMaxIOU), slice(floats::kMaxExp), 0), floats::kMaxExp);
+        makeHost()->floatAdd(slice(FloatTest::kMaxIOU), slice(FloatTest::kMaxExp), 0),
+        FloatTest::kMaxExp);
 }
 
 TEST_F(FloatAddImpl, MinPlusZeroIsMin)
 {
     expectValue(
-        makeHost()->floatAdd(slice(floats::kIntMin), slice(floats::kIntZero), 0), floats::kIntMin);
+        makeHost()->floatAdd(slice(FloatTest::kIntMin), slice(FloatTest::kIntZero), 0),
+        FloatTest::kIntMin);
 }
 
 TEST_F(FloatAddImpl, MaxPlusMinIsZero)
 {
     expectValue(
-        makeHost()->floatAdd(slice(floats::kIntMax), slice(floats::kIntMin), 0), floats::kIntZero);
+        makeHost()->floatAdd(slice(FloatTest::kIntMax), slice(FloatTest::kIntMin), 0),
+        FloatTest::kIntZero);
 }
 
 }  // namespace xrpl::test
diff --git a/src/tests/libxrpl/tx/wasm/host_functions/FloatCompare.cpp b/src/tests/libxrpl/tx/wasm/host_functions/FloatCompare.cpp
index b90b4c5b07..51bb506205 100644
--- a/src/tests/libxrpl/tx/wasm/host_functions/FloatCompare.cpp
+++ b/src/tests/libxrpl/tx/wasm/host_functions/FloatCompare.cpp
@@ -17,23 +17,23 @@ TEST_F(FloatCompareImpl, MalformedInputs)
     // 12-byte buffer, so size is the only rejection.
     expectError(makeHost()->floatCompare(Slice{}, Slice{}), HostFunctionError::FloatInputMalformed);
     expectError(
-        makeHost()->floatCompare(slice(floats::kOne), Slice{}),
+        makeHost()->floatCompare(slice(FloatTest::kOne), Slice{}),
         HostFunctionError::FloatInputMalformed);
 }
 
 TEST_F(FloatCompareImpl, Less)
 {
-    expectValue(makeHost()->floatCompare(slice(floats::kIntMin), slice(floats::kIntZero)), 2);
+    expectValue(makeHost()->floatCompare(slice(FloatTest::kIntMin), slice(FloatTest::kIntZero)), 2);
 }
 
 TEST_F(FloatCompareImpl, Greater)
 {
-    expectValue(makeHost()->floatCompare(slice(floats::kIntMax), slice(floats::kIntZero)), 1);
+    expectValue(makeHost()->floatCompare(slice(FloatTest::kIntMax), slice(FloatTest::kIntZero)), 1);
 }
 
 TEST_F(FloatCompareImpl, Equal)
 {
-    expectValue(makeHost()->floatCompare(slice(floats::kOne), slice(floats::kOne)), 0);
+    expectValue(makeHost()->floatCompare(slice(FloatTest::kOne), slice(FloatTest::kOne)), 0);
 }
 
 // A non-canonical encoding of 10 (mantissa 100000, exponent -4) is normalized on decode, so
@@ -42,7 +42,7 @@ TEST_F(FloatCompareImpl, NonCanonicalNormalizes)
 {
     Bytes const nonCanonicalTen{
         0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x86, 0xA0, 0xFF, 0xFF, 0xFF, 0xFC};
-    expectValue(makeHost()->floatCompare(slice(nonCanonicalTen), slice(floats::kTen)), 0);
+    expectValue(makeHost()->floatCompare(slice(nonCanonicalTen), slice(FloatTest::kTen)), 0);
 }
 
 }  // namespace xrpl::test
diff --git a/src/tests/libxrpl/tx/wasm/host_functions/FloatDivide.cpp b/src/tests/libxrpl/tx/wasm/host_functions/FloatDivide.cpp
index ae3c81f8bb..ab339404be 100644
--- a/src/tests/libxrpl/tx/wasm/host_functions/FloatDivide.cpp
+++ b/src/tests/libxrpl/tx/wasm/host_functions/FloatDivide.cpp
@@ -15,45 +15,46 @@ struct FloatDivideImpl : FloatTest
 TEST_F(FloatDivideImpl, BadModeIsMalformed)
 {
     expectError(
-        makeHost()->floatDivide(slice(floats::kOne), slice(floats::kOne), -1),
+        makeHost()->floatDivide(slice(FloatTest::kOne), slice(FloatTest::kOne), -1),
         HostFunctionError::FloatInputMalformed);
 }
 
 TEST_F(FloatDivideImpl, MalformedInput)
 {
     expectError(
-        makeHost()->floatDivide(slice(floats::kOne), Slice{}, 0),
+        makeHost()->floatDivide(slice(FloatTest::kOne), Slice{}, 0),
         HostFunctionError::FloatInputMalformed);
 }
 
 TEST_F(FloatDivideImpl, DivideByZeroIsComputationError)
 {
     expectError(
-        makeHost()->floatDivide(slice(floats::kOne), slice(floats::kIntZero), 0),
+        makeHost()->floatDivide(slice(FloatTest::kOne), slice(FloatTest::kIntZero), 0),
         HostFunctionError::FloatComputationError);
 }
 
 TEST_F(FloatDivideImpl, OverflowIsComputationError)
 {
     // A divisor just below 1, so max / it overflows.
-    auto const y = makeHost()->floatFromMantExp(STAmount::kMaxValue, -floats::kNormalExp - 1, 0);
+    auto const y = makeHost()->floatFromMantExp(STAmount::kMaxValue, -FloatTest::kNormalExp - 1, 0);
     ASSERT_TRUE(y.has_value());
     expectError(
-        makeHost()->floatDivide(slice(floats::kMax), slice(*y), 0),
+        makeHost()->floatDivide(slice(FloatTest::kMax), slice(*y), 0),
         HostFunctionError::FloatComputationError);
 }
 
 TEST_F(FloatDivideImpl, ZeroDividedByOneIsZero)
 {
     expectValue(
-        makeHost()->floatDivide(slice(floats::kIntZero), slice(floats::kOne), 0), floats::kIntZero);
+        makeHost()->floatDivide(slice(FloatTest::kIntZero), slice(FloatTest::kOne), 0),
+        FloatTest::kIntZero);
 }
 
 TEST_F(FloatDivideImpl, MaxExpDividedByTenIsPreMaxExp)
 {
     expectValue(
-        makeHost()->floatDivide(slice(floats::kMaxExp), slice(floats::kTen), 0),
-        floats::kPreMaxExp);
+        makeHost()->floatDivide(slice(FloatTest::kMaxExp), slice(FloatTest::kTen), 0),
+        FloatTest::kPreMaxExp);
 }
 
 // The rounding mode changes an inexact result: 1/3 rounded Downward differs from Upward.
@@ -61,8 +62,8 @@ TEST_F(FloatDivideImpl, RoundingModeAffectsInexactResult)
 {
     auto const three = makeHost()->floatFromInt(3, 0);
     ASSERT_TRUE(three.has_value());
-    auto const down = makeHost()->floatDivide(slice(floats::kOne), slice(*three), 2);
-    auto const up = makeHost()->floatDivide(slice(floats::kOne), slice(*three), 3);
+    auto const down = makeHost()->floatDivide(slice(FloatTest::kOne), slice(*three), 2);
+    auto const up = makeHost()->floatDivide(slice(FloatTest::kOne), slice(*three), 3);
     ASSERT_TRUE(down.has_value() && up.has_value());
     EXPECT_NE(*down, *up);
 }
diff --git a/src/tests/libxrpl/tx/wasm/host_functions/FloatFromInt.cpp b/src/tests/libxrpl/tx/wasm/host_functions/FloatFromInt.cpp
index febe731451..895a61fa49 100644
--- a/src/tests/libxrpl/tx/wasm/host_functions/FloatFromInt.cpp
+++ b/src/tests/libxrpl/tx/wasm/host_functions/FloatFromInt.cpp
@@ -18,17 +18,17 @@ TEST_F(FloatFromIntImpl, BadModeIsMalformed)
 
 TEST_F(FloatFromIntImpl, MinInt)
 {
-    expectValue(makeHost()->floatFromInt(kMin64, 0), floats::kIntMin);
+    expectValue(makeHost()->floatFromInt(kMin64, 0), FloatTest::kIntMin);
 }
 
 TEST_F(FloatFromIntImpl, Zero)
 {
-    expectValue(makeHost()->floatFromInt(0, 0), floats::kIntZero);
+    expectValue(makeHost()->floatFromInt(0, 0), FloatTest::kIntZero);
 }
 
 TEST_F(FloatFromIntImpl, MaxInt)
 {
-    expectValue(makeHost()->floatFromInt(kMax64, 0), floats::kIntMax);
+    expectValue(makeHost()->floatFromInt(kMax64, 0), FloatTest::kIntMax);
 }
 
 }  // namespace xrpl::test
diff --git a/src/tests/libxrpl/tx/wasm/host_functions/FloatFromMantExp.cpp b/src/tests/libxrpl/tx/wasm/host_functions/FloatFromMantExp.cpp
index 5a5a424728..f742d2d3fa 100644
--- a/src/tests/libxrpl/tx/wasm/host_functions/FloatFromMantExp.cpp
+++ b/src/tests/libxrpl/tx/wasm/host_functions/FloatFromMantExp.cpp
@@ -10,8 +10,8 @@ namespace xrpl::test {
 
 struct FloatFromMantExpImpl : FloatTest
 {
-    static constexpr int kMaxRawExp = Number::kMaxExponent + floats::kNormalExp;
-    static constexpr int kMinRawExp = Number::kMinExponent + floats::kNormalExp;
+    static constexpr int kMaxRawExp = Number::kMaxExponent + FloatTest::kNormalExp;
+    static constexpr int kMinRawExp = Number::kMinExponent + FloatTest::kNormalExp;
 };
 
 TEST_F(FloatFromMantExpImpl, BadModeIsMalformed)
@@ -28,41 +28,41 @@ TEST_F(FloatFromMantExpImpl, ExponentTooHighIsMalformed)
 
 TEST_F(FloatFromMantExpImpl, UnderflowIsZero)
 {
-    expectValue(makeHost()->floatFromMantExp(1, kMinRawExp - 1, 0), floats::kIntZero);
+    expectValue(makeHost()->floatFromMantExp(1, kMinRawExp - 1, 0), FloatTest::kIntZero);
 }
 
 TEST_F(FloatFromMantExpImpl, MaxExponent)
 {
-    expectValue(makeHost()->floatFromMantExp(1, kMaxRawExp, 0), floats::kMaxExp);
+    expectValue(makeHost()->floatFromMantExp(1, kMaxRawExp, 0), FloatTest::kMaxExp);
 }
 
 TEST_F(FloatFromMantExpImpl, MinusMaxExponent)
 {
-    expectValue(makeHost()->floatFromMantExp(-1, kMaxRawExp, 0), floats::kMinusMaxExp);
+    expectValue(makeHost()->floatFromMantExp(-1, kMaxRawExp, 0), FloatTest::kMinusMaxExp);
 }
 
 TEST_F(FloatFromMantExpImpl, PreMaxExponent)
 {
-    expectValue(makeHost()->floatFromMantExp(1, kMaxRawExp - 1, 0), floats::kPreMaxExp);
+    expectValue(makeHost()->floatFromMantExp(1, kMaxRawExp - 1, 0), FloatTest::kPreMaxExp);
 }
 
 TEST_F(FloatFromMantExpImpl, MaxIou)
 {
     expectValue(
         makeHost()->floatFromMantExp(STAmount::kMaxValue, STAmount::kMaxOffset, 0),
-        floats::kMaxIOU);
+        FloatTest::kMaxIOU);
 }
 
 TEST_F(FloatFromMantExpImpl, MinExponent)
 {
     expectValue(
-        makeHost()->floatFromMantExp(1, Number::kMinExponent - floats::kNormalExp, 0),
-        floats::kMinExp);
+        makeHost()->floatFromMantExp(1, Number::kMinExponent - FloatTest::kNormalExp, 0),
+        FloatTest::kMinExp);
 }
 
 TEST_F(FloatFromMantExpImpl, TenTimesTenthIsOne)
 {
-    expectValue(makeHost()->floatFromMantExp(10, -1, 0), floats::kOne);
+    expectValue(makeHost()->floatFromMantExp(10, -1, 0), FloatTest::kOne);
 }
 
 }  // namespace xrpl::test
diff --git a/src/tests/libxrpl/tx/wasm/host_functions/FloatFromStAmount.cpp b/src/tests/libxrpl/tx/wasm/host_functions/FloatFromStAmount.cpp
index 479bda146d..7b05f7ec55 100644
--- a/src/tests/libxrpl/tx/wasm/host_functions/FloatFromStAmount.cpp
+++ b/src/tests/libxrpl/tx/wasm/host_functions/FloatFromStAmount.cpp
@@ -32,7 +32,7 @@ TEST_F(FloatFromStAmountImpl, BadModeIsMalformed)
 
 TEST_F(FloatFromStAmountImpl, ZeroXrp)
 {
-    expectValue(makeHost()->floatFromSTAmount(STAmount{XRP(0)}, 0), floats::kIntZero);
+    expectValue(makeHost()->floatFromSTAmount(STAmount{XRP(0)}, 0), FloatTest::kIntZero);
 }
 
 TEST_F(FloatFromStAmountImpl, MinusOneXrp)
@@ -54,14 +54,14 @@ TEST_F(FloatFromStAmountImpl, MinIou)
 {
     auto const amount = STAmount{
         IOUAmount{static_cast<std::int64_t>(STAmount::kMinValue), STAmount::kMinOffset}, usd()};
-    expectValue(makeHost()->floatFromSTAmount(amount, 0), floats::kMinIOU);
+    expectValue(makeHost()->floatFromSTAmount(amount, 0), FloatTest::kMinIOU);
 }
 
 TEST_F(FloatFromStAmountImpl, MaxIou)
 {
     auto const amount = STAmount{
         IOUAmount{static_cast<std::int64_t>(STAmount::kMaxValue), STAmount::kMaxOffset}, usd()};
-    expectValue(makeHost()->floatFromSTAmount(amount, 0), floats::kMaxIOU);
+    expectValue(makeHost()->floatFromSTAmount(amount, 0), FloatTest::kMaxIOU);
 }
 
 }  // namespace xrpl::test
diff --git a/src/tests/libxrpl/tx/wasm/host_functions/FloatFromStNumber.cpp b/src/tests/libxrpl/tx/wasm/host_functions/FloatFromStNumber.cpp
index 4405062cf9..d10493d6dd 100644
--- a/src/tests/libxrpl/tx/wasm/host_functions/FloatFromStNumber.cpp
+++ b/src/tests/libxrpl/tx/wasm/host_functions/FloatFromStNumber.cpp
@@ -27,13 +27,13 @@ TEST_F(FloatFromStNumberImpl, MaxUint)
 {
     auto const n = STNumber{
         sfNumber, Number(std::numeric_limits<std::uint64_t>::max(), 0, Number::Normalized{})};
-    expectValue(makeHost()->floatFromSTNumber(n, 0), floats::kUintMax);
+    expectValue(makeHost()->floatFromSTNumber(n, 0), FloatTest::kUintMax);
 }
 
 TEST_F(FloatFromStNumberImpl, MinusMaxExponent)
 {
-    auto const n = STNumber{sfNumber, Number(-1, Number::kMaxExponent + floats::kNormalExp)};
-    expectValue(makeHost()->floatFromSTNumber(n, 0), floats::kMinusMaxExp);
+    auto const n = STNumber{sfNumber, Number(-1, Number::kMaxExponent + FloatTest::kNormalExp)};
+    expectValue(makeHost()->floatFromSTNumber(n, 0), FloatTest::kMinusMaxExp);
 }
 
 }  // namespace xrpl::test
diff --git a/src/tests/libxrpl/tx/wasm/host_functions/FloatFromUint.cpp b/src/tests/libxrpl/tx/wasm/host_functions/FloatFromUint.cpp
index a51217d96f..b0323252d7 100644
--- a/src/tests/libxrpl/tx/wasm/host_functions/FloatFromUint.cpp
+++ b/src/tests/libxrpl/tx/wasm/host_functions/FloatFromUint.cpp
@@ -22,12 +22,12 @@ TEST_F(FloatFromUintImpl, BadModeIsMalformed)
 
 TEST_F(FloatFromUintImpl, Zero)
 {
-    expectValue(makeHost()->floatFromUint(0, 0), floats::kIntZero);
+    expectValue(makeHost()->floatFromUint(0, 0), FloatTest::kIntZero);
 }
 
 TEST_F(FloatFromUintImpl, MaxUint)
 {
-    expectValue(makeHost()->floatFromUint(kMaxU64, 0), floats::kUintMax);
+    expectValue(makeHost()->floatFromUint(kMaxU64, 0), FloatTest::kUintMax);
 }
 
 }  // namespace xrpl::test
diff --git a/src/tests/libxrpl/tx/wasm/host_functions/FloatMultiply.cpp b/src/tests/libxrpl/tx/wasm/host_functions/FloatMultiply.cpp
index fb63cca58d..d49693dc31 100644
--- a/src/tests/libxrpl/tx/wasm/host_functions/FloatMultiply.cpp
+++ b/src/tests/libxrpl/tx/wasm/host_functions/FloatMultiply.cpp
@@ -14,42 +14,43 @@ struct FloatMultiplyImpl : FloatTest
 TEST_F(FloatMultiplyImpl, BadModeIsMalformed)
 {
     expectError(
-        makeHost()->floatMultiply(slice(floats::kOne), slice(floats::kOne), -1),
+        makeHost()->floatMultiply(slice(FloatTest::kOne), slice(FloatTest::kOne), -1),
         HostFunctionError::FloatInputMalformed);
 }
 
 TEST_F(FloatMultiplyImpl, MalformedInput)
 {
     expectError(
-        makeHost()->floatMultiply(slice(floats::kOne), Slice{}, 0),
+        makeHost()->floatMultiply(slice(FloatTest::kOne), Slice{}, 0),
         HostFunctionError::FloatInputMalformed);
 }
 
 TEST_F(FloatMultiplyImpl, OverflowIsComputationError)
 {
     expectError(
-        makeHost()->floatMultiply(slice(floats::kMax), slice(floats::kOneMore), 0),
+        makeHost()->floatMultiply(slice(FloatTest::kMax), slice(FloatTest::kOneMore), 0),
         HostFunctionError::FloatComputationError);
 }
 
 TEST_F(FloatMultiplyImpl, OneTimesOneIsOne)
 {
     expectValue(
-        makeHost()->floatMultiply(slice(floats::kOne), slice(floats::kOne), 0), floats::kOne);
+        makeHost()->floatMultiply(slice(FloatTest::kOne), slice(FloatTest::kOne), 0),
+        FloatTest::kOne);
 }
 
 TEST_F(FloatMultiplyImpl, ZeroTimesMaxIouIsZero)
 {
     expectValue(
-        makeHost()->floatMultiply(slice(floats::kIntZero), slice(floats::kMaxIOU), 0),
-        floats::kIntZero);
+        makeHost()->floatMultiply(slice(FloatTest::kIntZero), slice(FloatTest::kMaxIOU), 0),
+        FloatTest::kIntZero);
 }
 
 TEST_F(FloatMultiplyImpl, TenTimesPreMaxExpIsMaxExp)
 {
     expectValue(
-        makeHost()->floatMultiply(slice(floats::kTen), slice(floats::kPreMaxExp), 0),
-        floats::kMaxExp);
+        makeHost()->floatMultiply(slice(FloatTest::kTen), slice(FloatTest::kPreMaxExp), 0),
+        FloatTest::kMaxExp);
 }
 
 }  // namespace xrpl::test
diff --git a/src/tests/libxrpl/tx/wasm/host_functions/FloatPower.cpp b/src/tests/libxrpl/tx/wasm/host_functions/FloatPower.cpp
index 6dcc84465c..b80772035a 100644
--- a/src/tests/libxrpl/tx/wasm/host_functions/FloatPower.cpp
+++ b/src/tests/libxrpl/tx/wasm/host_functions/FloatPower.cpp
@@ -15,7 +15,8 @@ struct FloatPowerImpl : FloatTest
 TEST_F(FloatPowerImpl, BadModeIsMalformed)
 {
     expectError(
-        makeHost()->floatPower(slice(floats::kOne), 2, -1), HostFunctionError::FloatInputMalformed);
+        makeHost()->floatPower(slice(FloatTest::kOne), 2, -1),
+        HostFunctionError::FloatInputMalformed);
 }
 
 TEST_F(FloatPowerImpl, MalformedInput)
@@ -26,38 +27,39 @@ TEST_F(FloatPowerImpl, MalformedInput)
 TEST_F(FloatPowerImpl, NegativeDegreeIsMalformed)
 {
     expectError(
-        makeHost()->floatPower(slice(floats::kOne), -2, 0), HostFunctionError::FloatInputMalformed);
+        makeHost()->floatPower(slice(FloatTest::kOne), -2, 0),
+        HostFunctionError::FloatInputMalformed);
 }
 
 TEST_F(FloatPowerImpl, OverflowIsComputationError)
 {
     expectError(
-        makeHost()->floatPower(slice(floats::kMax), 2, 0),
+        makeHost()->floatPower(slice(FloatTest::kMax), 2, 0),
         HostFunctionError::FloatComputationError);
 }
 
 TEST_F(FloatPowerImpl, DegreeTooLargeIsMalformed)
 {
     expectError(
-        makeHost()->floatPower(slice(floats::kMax), Number::kMaxExponent + 1, 0),
+        makeHost()->floatPower(slice(FloatTest::kMax), Number::kMaxExponent + 1, 0),
         HostFunctionError::FloatInputMalformed);
 }
 
 TEST_F(FloatPowerImpl, DegreeZeroIsOne)
 {
-    expectValue(makeHost()->floatPower(slice(floats::kMaxIOU), 0, 0), floats::kOne);
+    expectValue(makeHost()->floatPower(slice(FloatTest::kMaxIOU), 0, 0), FloatTest::kOne);
 }
 
 TEST_F(FloatPowerImpl, DegreeOneIsIdentity)
 {
-    expectValue(makeHost()->floatPower(slice(floats::kMaxIOU), 1, 0), floats::kMaxIOU);
+    expectValue(makeHost()->floatPower(slice(FloatTest::kMaxIOU), 1, 0), FloatTest::kMaxIOU);
 }
 
 TEST_F(FloatPowerImpl, TenSquaredIsHundred)
 {
     auto const hundred = makeHost()->floatFromMantExp(100, 0, 0);
     ASSERT_TRUE(hundred.has_value());
-    expectValue(makeHost()->floatPower(slice(floats::kTen), 2, 0), *hundred);
+    expectValue(makeHost()->floatPower(slice(FloatTest::kTen), 2, 0), *hundred);
 }
 
 TEST_F(FloatPowerImpl, TenthSquaredIsHundredth)
diff --git a/src/tests/libxrpl/tx/wasm/host_functions/FloatRoot.cpp b/src/tests/libxrpl/tx/wasm/host_functions/FloatRoot.cpp
index 9d1cca1a18..7258c541a6 100644
--- a/src/tests/libxrpl/tx/wasm/host_functions/FloatRoot.cpp
+++ b/src/tests/libxrpl/tx/wasm/host_functions/FloatRoot.cpp
@@ -14,7 +14,8 @@ struct FloatRootImpl : FloatTest
 TEST_F(FloatRootImpl, BadModeIsMalformed)
 {
     expectError(
-        makeHost()->floatRoot(slice(floats::kOne), 2, -1), HostFunctionError::FloatInputMalformed);
+        makeHost()->floatRoot(slice(FloatTest::kOne), 2, -1),
+        HostFunctionError::FloatInputMalformed);
 }
 
 TEST_F(FloatRootImpl, MalformedInput)
@@ -25,31 +26,32 @@ TEST_F(FloatRootImpl, MalformedInput)
 TEST_F(FloatRootImpl, NegativeDegreeIsMalformed)
 {
     expectError(
-        makeHost()->floatRoot(slice(floats::kOne), -2, 0), HostFunctionError::FloatInputMalformed);
+        makeHost()->floatRoot(slice(FloatTest::kOne), -2, 0),
+        HostFunctionError::FloatInputMalformed);
 }
 
 TEST_F(FloatRootImpl, RootOfZeroIsZero)
 {
-    expectValue(makeHost()->floatRoot(slice(floats::kIntZero), 2, 0), floats::kIntZero);
+    expectValue(makeHost()->floatRoot(slice(FloatTest::kIntZero), 2, 0), FloatTest::kIntZero);
 }
 
 TEST_F(FloatRootImpl, FirstRootIsIdentity)
 {
-    expectValue(makeHost()->floatRoot(slice(floats::kMaxIOU), 1, 0), floats::kMaxIOU);
+    expectValue(makeHost()->floatRoot(slice(FloatTest::kMaxIOU), 1, 0), FloatTest::kMaxIOU);
 }
 
 TEST_F(FloatRootImpl, SquareRootOfHundredIsTen)
 {
     auto const hundred = makeHost()->floatFromMantExp(100, 0, 0);
     ASSERT_TRUE(hundred.has_value());
-    expectValue(makeHost()->floatRoot(slice(*hundred), 2, 0), floats::kTen);
+    expectValue(makeHost()->floatRoot(slice(*hundred), 2, 0), FloatTest::kTen);
 }
 
 TEST_F(FloatRootImpl, CubeRootOfThousandIsTen)
 {
     auto const thousand = makeHost()->floatFromMantExp(1000, 0, 0);
     ASSERT_TRUE(thousand.has_value());
-    expectValue(makeHost()->floatRoot(slice(*thousand), 3, 0), floats::kTen);
+    expectValue(makeHost()->floatRoot(slice(*thousand), 3, 0), FloatTest::kTen);
 }
 
 TEST_F(FloatRootImpl, SquareRootOfHundredthIsTenth)
diff --git a/src/tests/libxrpl/tx/wasm/host_functions/FloatSubtract.cpp b/src/tests/libxrpl/tx/wasm/host_functions/FloatSubtract.cpp
index b60cb24b34..fc0d5eaa53 100644
--- a/src/tests/libxrpl/tx/wasm/host_functions/FloatSubtract.cpp
+++ b/src/tests/libxrpl/tx/wasm/host_functions/FloatSubtract.cpp
@@ -14,36 +14,36 @@ struct FloatSubtractImpl : FloatTest
 TEST_F(FloatSubtractImpl, BadModeIsMalformed)
 {
     expectError(
-        makeHost()->floatSubtract(slice(floats::kOne), slice(floats::kOne), -1),
+        makeHost()->floatSubtract(slice(FloatTest::kOne), slice(FloatTest::kOne), -1),
         HostFunctionError::FloatInputMalformed);
 }
 
 TEST_F(FloatSubtractImpl, MalformedInput)
 {
     expectError(
-        makeHost()->floatSubtract(slice(floats::kOne), Slice{}, 0),
+        makeHost()->floatSubtract(slice(FloatTest::kOne), Slice{}, 0),
         HostFunctionError::FloatInputMalformed);
 }
 
 TEST_F(FloatSubtractImpl, MinusMaxExpMinusMaxIouIsMinusMaxExp)
 {
     expectValue(
-        makeHost()->floatSubtract(slice(floats::kMinusMaxExp), slice(floats::kMaxIOU), 0),
-        floats::kMinusMaxExp);
+        makeHost()->floatSubtract(slice(FloatTest::kMinusMaxExp), slice(FloatTest::kMaxIOU), 0),
+        FloatTest::kMinusMaxExp);
 }
 
 TEST_F(FloatSubtractImpl, MinMinusZeroIsMin)
 {
     expectValue(
-        makeHost()->floatSubtract(slice(floats::kIntMin), slice(floats::kIntZero), 0),
-        floats::kIntMin);
+        makeHost()->floatSubtract(slice(FloatTest::kIntMin), slice(FloatTest::kIntZero), 0),
+        FloatTest::kIntMin);
 }
 
 TEST_F(FloatSubtractImpl, ZeroMinusOneIsMinusOne)
 {
     expectValue(
-        makeHost()->floatSubtract(slice(floats::kIntZero), slice(floats::kOne), 0),
-        floats::kMinusOne);
+        makeHost()->floatSubtract(slice(FloatTest::kIntZero), slice(FloatTest::kOne), 0),
+        FloatTest::kMinusOne);
 }
 
 }  // namespace xrpl::test
diff --git a/src/tests/libxrpl/tx/wasm/host_functions/FloatToInt.cpp b/src/tests/libxrpl/tx/wasm/host_functions/FloatToInt.cpp
index a6a1ef31a8..4323fc3d31 100644
--- a/src/tests/libxrpl/tx/wasm/host_functions/FloatToInt.cpp
+++ b/src/tests/libxrpl/tx/wasm/host_functions/FloatToInt.cpp
@@ -16,9 +16,9 @@ struct FloatToIntImpl : FloatTest
 TEST_F(FloatToIntImpl, BadModeIsMalformed)
 {
     expectError(
-        makeHost()->floatToInt(slice(floats::kOne), -1), HostFunctionError::FloatInputMalformed);
+        makeHost()->floatToInt(slice(FloatTest::kOne), -1), HostFunctionError::FloatInputMalformed);
     expectError(
-        makeHost()->floatToInt(slice(floats::kOne), 4), HostFunctionError::FloatInputMalformed);
+        makeHost()->floatToInt(slice(FloatTest::kOne), 4), HostFunctionError::FloatInputMalformed);
 }
 
 TEST_F(FloatToIntImpl, MalformedInputs)
@@ -28,43 +28,43 @@ TEST_F(FloatToIntImpl, MalformedInputs)
 
 TEST_F(FloatToIntImpl, Zero)
 {
-    expectValue(makeHost()->floatToInt(slice(floats::kIntZero), 0), std::int64_t{0});
+    expectValue(makeHost()->floatToInt(slice(FloatTest::kIntZero), 0), std::int64_t{0});
 }
 
 TEST_F(FloatToIntImpl, One)
 {
-    expectValue(makeHost()->floatToInt(slice(floats::kOne), 0), std::int64_t{1});
+    expectValue(makeHost()->floatToInt(slice(FloatTest::kOne), 0), std::int64_t{1});
 }
 
 TEST_F(FloatToIntImpl, MinusOne)
 {
-    expectValue(makeHost()->floatToInt(slice(floats::kMinusOne), 0), std::int64_t{-1});
+    expectValue(makeHost()->floatToInt(slice(FloatTest::kMinusOne), 0), std::int64_t{-1});
 }
 
 TEST_F(FloatToIntImpl, Max)
 {
-    expectValue(makeHost()->floatToInt(slice(floats::kIntMax), 0), kMax64);
+    expectValue(makeHost()->floatToInt(slice(FloatTest::kIntMax), 0), kMax64);
 }
 
 TEST_F(FloatToIntImpl, Min)
 {
     // floatIntMin rounds to -(2^63-1), i.e. -kMax64.
-    expectValue(makeHost()->floatToInt(slice(floats::kIntMin), 0), -kMax64);
+    expectValue(makeHost()->floatToInt(slice(FloatTest::kIntMin), 0), -kMax64);
 }
 
 TEST_F(FloatToIntImpl, OverflowsInt64IsComputationError)
 {
     expectError(
-        makeHost()->floatToInt(slice(floats::kUintMax), 0),
+        makeHost()->floatToInt(slice(FloatTest::kUintMax), 0),
         HostFunctionError::FloatComputationError);
 }
 
 TEST_F(FloatToIntImpl, PiRoundsByMode)
 {
-    expectValue(makeHost()->floatToInt(slice(floats::kPi), 0), std::int64_t{3});  // ToNearest
-    expectValue(makeHost()->floatToInt(slice(floats::kPi), 1), std::int64_t{3});  // TowardsZero
-    expectValue(makeHost()->floatToInt(slice(floats::kPi), 2), std::int64_t{3});  // Downward
-    expectValue(makeHost()->floatToInt(slice(floats::kPi), 3), std::int64_t{4});  // Upward
+    expectValue(makeHost()->floatToInt(slice(FloatTest::kPi), 0), std::int64_t{3});  // ToNearest
+    expectValue(makeHost()->floatToInt(slice(FloatTest::kPi), 1), std::int64_t{3});  // TowardsZero
+    expectValue(makeHost()->floatToInt(slice(FloatTest::kPi), 2), std::int64_t{3});  // Downward
+    expectValue(makeHost()->floatToInt(slice(FloatTest::kPi), 3), std::int64_t{4});  // Upward
 }
 
 }  // namespace xrpl::test
diff --git a/src/tests/libxrpl/tx/wasm/host_functions/FloatToMantExp.cpp b/src/tests/libxrpl/tx/wasm/host_functions/FloatToMantExp.cpp
index 4f7fbd0c6a..877db427d5 100644
--- a/src/tests/libxrpl/tx/wasm/host_functions/FloatToMantExp.cpp
+++ b/src/tests/libxrpl/tx/wasm/host_functions/FloatToMantExp.cpp
@@ -29,51 +29,51 @@ TEST_F(FloatToMantExpImpl, MalformedInput)
 
 TEST_F(FloatToMantExpImpl, Zero)
 {
-    expectValue(makeHost()->floatToMantExp(slice(floats::kIntZero)), pair(0, kExpMin));
+    expectValue(makeHost()->floatToMantExp(slice(FloatTest::kIntZero)), pair(0, kExpMin));
 }
 
 TEST_F(FloatToMantExpImpl, One)
 {
     expectValue(
-        makeHost()->floatToMantExp(slice(floats::kOne)),
-        pair(1'000'000'000'000'000'000, -floats::kNormalExp));
+        makeHost()->floatToMantExp(slice(FloatTest::kOne)),
+        pair(1'000'000'000'000'000'000, -FloatTest::kNormalExp));
 }
 
 TEST_F(FloatToMantExpImpl, MinusOne)
 {
     expectValue(
-        makeHost()->floatToMantExp(slice(floats::kMinusOne)),
-        pair(-1'000'000'000'000'000'000, -floats::kNormalExp));
+        makeHost()->floatToMantExp(slice(FloatTest::kMinusOne)),
+        pair(-1'000'000'000'000'000'000, -FloatTest::kNormalExp));
 }
 
 TEST_F(FloatToMantExpImpl, Ten)
 {
     expectValue(
-        makeHost()->floatToMantExp(slice(floats::kTen)),
-        pair(1'000'000'000'000'000'000, -floats::kNormalExp + 1));
+        makeHost()->floatToMantExp(slice(FloatTest::kTen)),
+        pair(1'000'000'000'000'000'000, -FloatTest::kNormalExp + 1));
 }
 
 TEST_F(FloatToMantExpImpl, Pi)
 {
     expectValue(
-        makeHost()->floatToMantExp(slice(floats::kPi)),
-        pair(3'141'592'653'589'793'000, -floats::kNormalExp));
+        makeHost()->floatToMantExp(slice(FloatTest::kPi)),
+        pair(3'141'592'653'589'793'000, -FloatTest::kNormalExp));
 }
 
 TEST_F(FloatToMantExpImpl, IntMax)
 {
-    expectValue(makeHost()->floatToMantExp(slice(floats::kIntMax)), pair(kMax64, 0));
+    expectValue(makeHost()->floatToMantExp(slice(FloatTest::kIntMax)), pair(kMax64, 0));
 }
 
 TEST_F(FloatToMantExpImpl, IntMin)
 {
-    expectValue(makeHost()->floatToMantExp(slice(floats::kIntMin)), pair(-kMax64, 0));
+    expectValue(makeHost()->floatToMantExp(slice(FloatTest::kIntMin)), pair(-kMax64, 0));
 }
 
 TEST_F(FloatToMantExpImpl, Max)
 {
     expectValue(
-        makeHost()->floatToMantExp(slice(floats::kMax)),
+        makeHost()->floatToMantExp(slice(FloatTest::kMax)),
         pair(Number::kMaxRep, Number::kMaxExponent));
 }