From d6353e593f9f60c7007c8bd4ea1b288d91e701b8 Mon Sep 17 00:00:00 2001
From: Ed Hennis <ed@ripple.com>
Date: Thu, 24 Apr 2025 16:36:26 -0400
Subject: [PATCH] Get arithmetic operators working for typed-values

---
 include/xrpl/protocol/STObject.h    | 26 ++++++++++++++++++++++++--
 src/test/ledger/Invariants_test.cpp |  6 +-----
 2 files changed, 25 insertions(+), 7 deletions(-)

diff --git a/include/xrpl/protocol/STObject.h b/include/xrpl/protocol/STObject.h
index 14f276ce90..2f44e36990 100644
--- a/include/xrpl/protocol/STObject.h
+++ b/include/xrpl/protocol/STObject.h
@@ -518,8 +518,26 @@ protected:
 // Constraint += and -= ValueProxy operators
 // to value types that support arithmetic operations
 template <typename U>
-concept IsArithmetic = std::is_arithmetic_v<U> || std::is_same_v<U, STAmount> ||
-    std::is_same_v<U, STNumber> || std::is_same_v<U, Number>;
+concept IsArithmeticNumber = std::is_arithmetic_v<U> ||
+    std::is_same_v<U, Number> || std::is_same_v<U, STAmount>;
+template <
+    typename U,
+    typename Value = U::value_type,
+    typename Unit = U::unit_type>
+concept IsArithmeticValueUnit =
+    std::is_same_v<U, unit::ValueUnit<Unit, Value>> &&
+    IsArithmeticNumber<Value> && std::is_class_v<Unit>;
+template <typename U, typename Value = U::value_type>
+concept IsArithmeticST = !IsArithmeticValueUnit<U> && IsArithmeticNumber<Value>;
+template <typename U>
+concept IsArithmetic =
+    IsArithmeticNumber<U> || IsArithmeticST<U> || IsArithmeticValueUnit<U>;
+
+template <class T, class U>
+concept Addable = requires(T t, U u) { t = t + u; };
+template <typename T, typename U>
+concept IsArithmeticCompatible =
+    IsArithmetic<typename T::value_type> && Addable<typename T::value_type, U>;
 
 template <class T>
 class STObject::ValueProxy : public Proxy<T>
@@ -539,10 +557,12 @@ public:
     // Convenience operators for value types supporting
     // arithmetic operations
     template <IsArithmetic U>
+        requires IsArithmeticCompatible<T, U>
     ValueProxy&
     operator+=(U const& u);
 
     template <IsArithmetic U>
+        requires IsArithmeticCompatible<T, U>
     ValueProxy&
     operator-=(U const& u);
 
@@ -778,6 +798,7 @@ STObject::ValueProxy<T>::operator=(U&& u)
 
 template <typename T>
 template <IsArithmetic U>
+    requires IsArithmeticCompatible<T, U>
 STObject::ValueProxy<T>&
 STObject::ValueProxy<T>::operator+=(U const& u)
 {
@@ -787,6 +808,7 @@ STObject::ValueProxy<T>::operator+=(U const& u)
 
 template <class T>
 template <IsArithmetic U>
+    requires IsArithmeticCompatible<T, U>
 STObject::ValueProxy<T>&
 STObject::ValueProxy<T>::operator-=(U const& u)
 {
diff --git a/src/test/ledger/Invariants_test.cpp b/src/test/ledger/Invariants_test.cpp
index ac8adf5a77..0927c8fcb3 100644
--- a/src/test/ledger/Invariants_test.cpp
+++ b/src/test/ledger/Invariants_test.cpp
@@ -1382,11 +1382,7 @@ class Invariants_test : public beast::unit_test::suite
                         sle->at(sfOwner) = sle->at(sfAccount);
                     },
                     [](SLE::pointer& sle) {
-                        // The operator overloads aren't playing nice with the
-                        // custom class, so just do it the hard way for now.
-                        auto value = sle->at(sfManagementFeeRate).value();
-                        ++value;
-                        sle->at(sfManagementFeeRate) = value;
+                        sle->at(sfManagementFeeRate) += TenthBips16(1);
                     },
                     [](SLE::pointer& sle) { sle->at(sfCoverRateMinimum) += 1; },
                     [](SLE::pointer& sle) {