Damn consequences...

include/xrpl/basics/Number.h

@@ -13,12 +13,28 @@ class Number;
 std::string
 to_string(Number const& amount);
 
+template <class T1, class T2>
+concept ArithmeticWithNumber =
+    std::is_arithmetic_v<std::remove_reference_t<T1>> &&
+    std::is_convertible_v<T2, Number>;
+
+template <class T1, class T2>
+concept OneNumberParam =
+    ArithmeticWithNumber<T1, T2> || ArithmeticWithNumber<T2, T1>;
+
 class Number
 {
     using rep = std::int64_t;
     rep mantissa_{0};
     int exponent_{std::numeric_limits<int>::lowest()};
 
+    using urep = std::make_unsigned_t<rep>;
+
+    template <class T>
+    rep
+    utoi(T mantissa)
+        requires std::is_unsigned_v<T>;
+
 public:
     // The range for the mantissa when normalized
     constexpr static std::int64_t minMantissa = 1'000'000'000'000'000LL;
@@ -35,7 +51,10 @@ public:
 
     explicit constexpr Number() = default;
 
-    Number(rep mantissa);
+    template <class T>
+    explicit Number(T mantissa)
+        requires std::is_unsigned_v<T>;
+    explicit Number(rep mantissa);
     explicit Number(rep mantissa, int exponent);
     explicit constexpr Number(rep mantissa, int exponent, unchecked) noexcept;
 
@@ -59,13 +78,39 @@ public:
 
     Number&
     operator+=(Number const& x);
+    template <class T>
+    Number&
+    operator+=(T x)
+    {
+        return operator+=(Number(x));
+    }
+
     Number&
     operator-=(Number const& x);
+    template <class T>
+    Number&
+    operator-=(T x)
+    {
+        return operator-=(Number(x));
+    }
 
     Number&
     operator*=(Number const& x);
+    template <class T>
+    Number&
+    operator*=(T x)
+    {
+        return operator*=(Number(x));
+    }
+
     Number&
     operator/=(Number const& x);
+    template <class T>
+    Number&
+    operator/=(T x)
+    {
+        return operator/=(Number(x));
+    }
 
     static constexpr Number
     min() noexcept;
@@ -87,12 +132,26 @@ public:
     {
         return x.mantissa_ == y.mantissa_ && x.exponent_ == y.exponent_;
     }
+    template <class T1, class T2>
+    friend constexpr bool
+    operator==(T1&& x, T2&& y) noexcept
+        requires OneNumberParam<T1, T2>
+    {
+        return operator==(Number(x), Number(y));
+    }
 
     friend constexpr bool
     operator!=(Number const& x, Number const& y) noexcept
     {
         return !(x == y);
     }
+    template <class T1, class T2>
+    friend constexpr bool
+    operator!=(T1&& x, T2&& y) noexcept
+        requires OneNumberParam<T1, T2>
+    {
+        return operator!=(Number(x), Number(y));
+    }
 
     friend constexpr bool
     operator<(Number const& x, Number const& y) noexcept
@@ -123,6 +182,13 @@ public:
         // If equal exponents, compare mantissas
         return x.mantissa_ < y.mantissa_;
     }
+    template <class T1, class T2>
+    friend constexpr bool
+    operator<(T1&& x, T2&& y) noexcept
+        requires OneNumberParam<T1, T2>
+    {
+        return operator<(Number(x), Number(y));
+    }
 
     /** Return the sign of the amount */
     constexpr int
@@ -154,18 +220,39 @@ public:
     {
         return y < x;
     }
+    template <class T1, class T2>
+    friend constexpr bool
+    operator>(T1&& x, T2&& y) noexcept
+        requires OneNumberParam<T1, T2>
+    {
+        return operator>(Number(x), Number(y));
+    }
 
     friend constexpr bool
     operator<=(Number const& x, Number const& y) noexcept
     {
         return !(y < x);
     }
+    template <class T1, class T2>
+    friend constexpr bool
+    operator<=(T1&& x, T2&& y) noexcept
+        requires OneNumberParam<T1, T2>
+    {
+        return operator<=(Number(x), Number(y));
+    }
 
     friend constexpr bool
     operator>=(Number const& x, Number const& y) noexcept
     {
         return !(x < y);
     }
+    template <class T1, class T2>
+    friend constexpr bool
+    operator>=(T1&& x, T2&& y) noexcept
+        requires OneNumberParam<T1, T2>
+    {
+        return operator>=(Number(x), Number(y));
+    }
 
     friend std::ostream&
     operator<<(std::ostream& os, Number const& x)
@@ -192,6 +279,16 @@ private:
     class Guard;
 };
 
+template <class T>
+Number::rep
+Number::utoi(T mantissa)
+    requires std::is_unsigned_v<T>
+{
+    if (mantissa > std::numeric_limits<rep>::max())
+        throw std::overflow_error("too high");
+    return static_cast<rep>(mantissa);
+}
+
 inline constexpr Number::Number(rep mantissa, int exponent, unchecked) noexcept
     : mantissa_{mantissa}, exponent_{exponent}
 {
@@ -207,6 +304,13 @@ inline Number::Number(rep mantissa) : Number{mantissa, 0}
 {
 }
 
+template <class T>
+Number::Number(T mantissa)
+    requires std::is_unsigned_v<T>
+    : Number{utoi(mantissa), 0}
+{
+}
+
 inline constexpr Number::rep
 Number::mantissa() const noexcept
 {
@@ -277,6 +381,14 @@ operator+(Number const& x, Number const& y)
     return z;
 }
 
+template <class T1, class T2>
+constexpr Number
+operator+(T1&& x, T2&& y)
+    requires OneNumberParam<T1, T2>
+{
+    return operator+(Number(x), Number(y));
+}
+
 inline Number
 operator-(Number const& x, Number const& y)
 {
@@ -285,6 +397,14 @@ operator-(Number const& x, Number const& y)
     return z;
 }
 
+template <class T1, class T2>
+constexpr Number
+operator-(T1&& x, T2&& y)
+    requires OneNumberParam<T1, T2>
+{
+    return operator-(Number(x), Number(y));
+}
+
 inline Number
 operator*(Number const& x, Number const& y)
 {
@@ -293,6 +413,14 @@ operator*(Number const& x, Number const& y)
     return z;
 }
 
+template <class T1, class T2>
+constexpr Number
+operator*(T1&& x, T2&& y)
+    requires OneNumberParam<T1, T2>
+{
+    return operator*(Number(x), Number(y));
+}
+
 inline Number
 operator/(Number const& x, Number const& y)
 {
@@ -301,6 +429,14 @@ operator/(Number const& x, Number const& y)
     return z;
 }
 
+template <class T1, class T2>
+constexpr Number
+operator/(T1&& x, T2&& y)
+    requires OneNumberParam<T1, T2>
+{
+    return operator/(Number(x), Number(y));
+}
+
 inline constexpr Number
 Number::min() noexcept
 {

include/xrpl/protocol/Fees.h

@@ -29,7 +29,9 @@ struct Fees
     XRPAmount
     accountReserve(std::size_t ownerCount) const
     {
-        return reserve + ownerCount * increment;
+        auto const p = ownerCount * increment;
+        auto const s = reserve + p;
+        return s;
     }
 };
 

include/xrpl/protocol/IOUAmount.h

@@ -42,7 +42,7 @@ public:
     IOUAmount() = default;
     explicit IOUAmount(Number const& other);
     IOUAmount(beast::Zero);
-    IOUAmount(std::int64_t mantissa, int exponent);
+    IOUAmount(std::int64_t mantissa, int exponent = 0);
 
     IOUAmount& operator=(beast::Zero);
 

include/xrpl/protocol/MPTAmount.h

@@ -64,7 +64,7 @@ public:
 
     operator Number() const noexcept
     {
-        return value();
+        return Number{value()};
     }
 
     /** Return the sign of the amount */

include/xrpl/protocol/XRPAmount.h

@@ -20,7 +20,9 @@ namespace ripple {
 class XRPAmount : private boost::totally_ordered<XRPAmount>,
                   private boost::additive<XRPAmount>,
                   private boost::equality_comparable<XRPAmount, std::int64_t>,
-                  private boost::additive<XRPAmount, std::int64_t>
+                  private boost::equality_comparable<XRPAmount, int>,
+                  private boost::additive<XRPAmount, std::int64_t>,
+                  private boost::additive<XRPAmount, int>
 {
 public:
     using unit_type = unit::dropTag;
@@ -68,11 +70,13 @@ public:
         return XRPAmount{drops_ * rhs};
     }
 
+    template <class T>
     friend constexpr XRPAmount
-    operator*(value_type lhs, XRPAmount const& rhs)
+    operator*(T lhs, XRPAmount const& rhs)
+        requires std::is_convertible_v<T, value_type>
     {
         // multiplication is commutative
-        return rhs * lhs;
+        return rhs.operator*(lhs);
     }
 
     XRPAmount&
@@ -127,6 +131,12 @@ public:
     {
         return drops_ == other;
     }
+    friend bool
+    operator==(value_type lhs, XRPAmount const& rhs)
+    {
+        // multiplication is commutative
+        return rhs.operator==(lhs);
+    }
 
     bool
     operator<(XRPAmount const& other) const
@@ -143,7 +153,7 @@ public:
 
     operator Number() const noexcept
     {
-        return drops();
+        return Number{drops()};
     }
 
     /** Return the sign of the amount */