Catch up the consequences of Number changes

ximinez · ximinez · commit 0175dd70dbc6 · 2025-11-06T23:55:05.000-05:00
- Change the Number::maxIntValue to all 9's.
- Add integral() to Asset (copied from Lending)
- Add toNumber() functions to STAmount, MPTAmount, XRPAmount to allow
  explicit conversions with enforcement options.
- Add optional Number::EnforceInteger options to STAmount and STNumber
  ctors, conversions, etc. IOUs are never checked.
- Update Vault transactors, and helper functions, to check restrictions.
- Fix and add Vault tests.
diff --git a/include/xrpl/basics/Number.h b/include/xrpl/basics/Number.h
@@ -53,7 +53,8 @@ class Number
     constexpr static rep maxMantissa = minMantissa * 10 - 1;
     static_assert(maxMantissa == 9'999'999'999'999'999LL);
 
-    constexpr static rep maxIntValue = minMantissa / 10;
+    constexpr static rep maxIntValue = maxMantissa / 10;
+    static_assert(maxIntValue == 999'999'999'999'999LL);
 
     // The range for the exponent when normalized
     constexpr static int minExponent = -32768;
diff --git a/include/xrpl/protocol/Asset.h b/include/xrpl/protocol/Asset.h
@@ -84,6 +84,12 @@ class Asset
         return holds<Issue>() && get<Issue>().native();
     }
 
+    bool
+    integral() const
+    {
+        return !holds<Issue>() || get<Issue>().native();
+    }
+
     friend constexpr bool
     operator==(Asset const& lhs, Asset const& rhs);
 
diff --git a/include/xrpl/protocol/MPTAmount.h b/include/xrpl/protocol/MPTAmount.h
@@ -62,11 +62,17 @@ class MPTAmount : private boost::totally_ordered<MPTAmount>,
     explicit constexpr
     operator bool() const noexcept;
 
-    operator Number() const noexcept
+    operator Number() const
     {
         return {value(), Number::strong};
     }
 
+    Number
+    toNumber(Number::EnforceInteger enforce) const
+    {
+        return {value(), enforce};
+    }
+
     /** Return the sign of the amount */
     constexpr int
     signum() const noexcept;
diff --git a/include/xrpl/protocol/STAmount.h b/include/xrpl/protocol/STAmount.h
@@ -40,6 +40,12 @@ class STAmount final : public STBase, public CountedObject<STAmount>
     exponent_type mOffset;
     bool mIsNegative;
 
+    // The Enforce integer setting is not stored or serialized. If set, it is
+    // used during automatic conversions to Number. If not set, the default
+    // behavior is used. It can also be overridden when coverting by using
+    // toNumber().
+    std::optional<Number::EnforceInteger> enforceConversion_;
+
 public:
     using value_type = STAmount;
 
@@ -135,16 +141,46 @@ class STAmount final : public STBase, public CountedObject<STAmount>
     STAmount(A const& asset, int mantissa, int exponent = 0);
 
     template <AssetType A>
-    STAmount(A const& asset, Number const& number)
+    STAmount(
+        A const& asset,
+        Number const& number,
+        std::optional<Number::EnforceInteger> enforce = std::nullopt)
         : STAmount(asset, number.mantissa(), number.exponent())
     {
+        enforceConversion_ = enforce;
+        if (!enforce)
+        {
+            // Use the default conversion behavior
+            [[maybe_unused]]
+            Number const n = *this;
+        }
+        else if (enforce == Number::strong)
+        {
+            // Throw if it's not valid
+            if (!validNumber())
+            {
+                Throw<std::overflow_error>(
+                    "STAmount::STAmount integer Number lost precision");
+            }
+        }
     }
 
     // Legacy support for new-style amounts
     STAmount(IOUAmount const& amount, Issue const& issue);
     STAmount(XRPAmount const& amount);
     STAmount(MPTAmount const& amount, MPTIssue const& mptIssue);
     operator Number() const;
+    Number
+    toNumber(Number::EnforceInteger enforce) const;
+
+    void
+    setIntegerEnforcement(std::optional<Number::EnforceInteger> enforce);
+
+    std::optional<Number::EnforceInteger>
+    integerEnforcement() const noexcept;
+
+    bool
+    validNumber() const noexcept;
 
     //--------------------------------------------------------------------------
     //
@@ -155,6 +191,9 @@ class STAmount final : public STBase, public CountedObject<STAmount>
     int
     exponent() const noexcept;
 
+    bool
+    integral() const noexcept;
+
     bool
     native() const noexcept;
 
@@ -435,6 +474,12 @@ STAmount::exponent() const noexcept
     return mOffset;
 }
 
+inline bool
+STAmount::integral() const noexcept
+{
+    return mAsset.integral();
+}
+
 inline bool
 STAmount::native() const noexcept
 {
@@ -510,13 +555,26 @@ inline STAmount::operator bool() const noexcept
 
 inline STAmount::operator Number() const
 {
+    if (enforceConversion_)
+        return toNumber(*enforceConversion_);
     if (native())
         return xrp();
     if (mAsset.holds<MPTIssue>())
         return mpt();
     return iou();
 }
 
+inline Number
+STAmount::toNumber(Number::EnforceInteger enforce) const
+{
+    if (native())
+        return xrp().toNumber(enforce);
+    if (mAsset.holds<MPTIssue>())
+        return mpt().toNumber(enforce);
+    // It doesn't make sense to enforce limits on IOUs
+    return iou();
+}
+
 inline STAmount&
 STAmount::operator=(beast::Zero)
 {
@@ -538,6 +596,11 @@ STAmount::operator=(Number const& number)
     mValue = mIsNegative ? -number.mantissa() : number.mantissa();
     mOffset = number.exponent();
     canonicalize();
+
+    // Convert it back to a Number to check that it's valid
+    [[maybe_unused]]
+    Number n = *this;
+
     return *this;
 }
 
@@ -553,7 +616,7 @@ STAmount::clear()
 {
     // The -100 is used to allow 0 to sort less than a small positive values
     // which have a negative exponent.
-    mOffset = native() ? 0 : -100;
+    mOffset = integral() ? 0 : -100;
     mValue = 0;
     mIsNegative = false;
 }
diff --git a/include/xrpl/protocol/STNumber.h b/include/xrpl/protocol/STNumber.h
@@ -56,6 +56,18 @@ class STNumber : public STBase, public CountedObject<STNumber>
     bool
     isDefault() const override;
 
+    /// Sets the flag on the underlying number
+    void
+    setIntegerEnforcement(Number::EnforceInteger enforce);
+
+    /// Gets the flag value on the underlying number
+    Number::EnforceInteger
+    integerEnforcement() const noexcept;
+
+    /// Checks the underlying number
+    bool
+    valid() const noexcept;
+
     operator Number() const
     {
         return value_;
diff --git a/include/xrpl/protocol/SystemParameters.h b/include/xrpl/protocol/SystemParameters.h
@@ -23,6 +23,7 @@ systemName()
 
 /** Number of drops in the genesis account. */
 constexpr XRPAmount INITIAL_XRP{100'000'000'000 * DROPS_PER_XRP};
+static_assert(INITIAL_XRP.drops() == 100'000'000'000'000'000);
 
 /** Returns true if the amount does not exceed the initial XRP in existence. */
 inline bool
diff --git a/include/xrpl/protocol/XRPAmount.h b/include/xrpl/protocol/XRPAmount.h
@@ -146,6 +146,12 @@ class XRPAmount : private boost::totally_ordered<XRPAmount>,
         return {drops(), Number::weak};
     }
 
+    Number
+    toNumber(Number::EnforceInteger enforce) const
+    {
+        return {value(), enforce};
+    }
+
     /** Return the sign of the amount */
     constexpr int
     signum() const noexcept
diff --git a/src/libxrpl/ledger/View.cpp b/src/libxrpl/ledger/View.cpp
@@ -2878,13 +2878,17 @@ assetsToSharesDeposit(
 
     Number const assetTotal = vault->at(sfAssetsTotal);
     STAmount shares{vault->at(sfShareMPTID)};
+    shares.setIntegerEnforcement(Number::weak);
     if (assetTotal == 0)
         return STAmount{
             shares.asset(),
             Number(assets.mantissa(), assets.exponent() + vault->at(sfScale))
-                .truncate()};
+                .truncate(),
+            Number::weak};
 
-    Number const shareTotal = issuance->at(sfOutstandingAmount);
+    Number const shareTotal{
+        unsafe_cast<std::int64_t>(issuance->at(sfOutstandingAmount)),
+        Number::strong};
     shares = (shareTotal * (assets / assetTotal)).truncate();
     return shares;
 }
@@ -2906,14 +2910,17 @@ sharesToAssetsDeposit(
 
     Number const assetTotal = vault->at(sfAssetsTotal);
     STAmount assets{vault->at(sfAsset)};
+    assets.setIntegerEnforcement(Number::weak);
     if (assetTotal == 0)
         return STAmount{
             assets.asset(),
             shares.mantissa(),
             shares.exponent() - vault->at(sfScale),
             false};
 
-    Number const shareTotal = issuance->at(sfOutstandingAmount);
+    Number const shareTotal{
+        unsafe_cast<std::int64_t>(issuance->at(sfOutstandingAmount)),
+        Number::strong};
     assets = assetTotal * (shares / shareTotal);
     return assets;
 }
@@ -2937,9 +2944,12 @@ assetsToSharesWithdraw(
     Number assetTotal = vault->at(sfAssetsTotal);
     assetTotal -= vault->at(sfLossUnrealized);
     STAmount shares{vault->at(sfShareMPTID)};
+    shares.setIntegerEnforcement(Number::weak);
     if (assetTotal == 0)
         return shares;
-    Number const shareTotal = issuance->at(sfOutstandingAmount);
+    Number const shareTotal{
+        unsafe_cast<std::int64_t>(issuance->at(sfOutstandingAmount)),
+        Number::strong};
     Number result = shareTotal * (assets / assetTotal);
     if (truncate == TruncateShares::yes)
         result = result.truncate();
@@ -2965,9 +2975,12 @@ sharesToAssetsWithdraw(
     Number assetTotal = vault->at(sfAssetsTotal);
     assetTotal -= vault->at(sfLossUnrealized);
     STAmount assets{vault->at(sfAsset)};
+    assets.setIntegerEnforcement(Number::weak);
     if (assetTotal == 0)
         return assets;
-    Number const shareTotal = issuance->at(sfOutstandingAmount);
+    Number const shareTotal{
+        unsafe_cast<std::int64_t>(issuance->at(sfOutstandingAmount)),
+        Number::strong};
     assets = assetTotal * (shares / shareTotal);
     return assets;
 }
diff --git a/src/libxrpl/protocol/STAmount.cpp b/src/libxrpl/protocol/STAmount.cpp
@@ -255,6 +255,25 @@ STAmount::move(std::size_t n, void* buf)
     return emplace(n, buf, std::move(*this));
 }
 
+void
+STAmount::setIntegerEnforcement(std::optional<Number::EnforceInteger> enforce)
+{
+    enforceConversion_ = enforce;
+}
+
+std::optional<Number::EnforceInteger>
+STAmount::integerEnforcement() const noexcept
+{
+    return enforceConversion_;
+}
+
+bool
+STAmount::validNumber() const noexcept
+{
+    Number n = toNumber(Number::EnforceInteger::weak);
+    return n.valid();
+}
+
 //------------------------------------------------------------------------------
 //
 // Conversion
diff --git a/src/libxrpl/protocol/STNumber.cpp b/src/libxrpl/protocol/STNumber.cpp
@@ -94,6 +94,24 @@ STNumber::isDefault() const
     return value_ == Number();
 }
 
+void
+STNumber::setIntegerEnforcement(Number::EnforceInteger enforce)
+{
+    value_.setIntegerEnforcement(enforce);
+}
+
+Number::EnforceInteger
+STNumber::integerEnforcement() const noexcept
+{
+    return value_.integerEnforcement();
+}
+
+bool
+STNumber::valid() const noexcept
+{
+    return value_.valid();
+}
+
 std::ostream&
 operator<<(std::ostream& out, STNumber const& rhs)
 {
diff --git a/src/test/app/Vault_test.cpp b/src/test/app/Vault_test.cpp
diff --git a/src/test/basics/Number_test.cpp b/src/test/basics/Number_test.cpp
diff --git a/src/xrpld/app/tx/detail/VaultClawback.cpp b/src/xrpld/app/tx/detail/VaultClawback.cpp
diff --git a/src/xrpld/app/tx/detail/VaultDeposit.cpp b/src/xrpld/app/tx/detail/VaultDeposit.cpp
diff --git a/src/xrpld/app/tx/detail/VaultWithdraw.cpp b/src/xrpld/app/tx/detail/VaultWithdraw.cpp
