Catch up the consequences of Number changes

- 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.

include/xrpl/protocol/STAmount.h

@@ -40,6 +40,12 @@ private:
     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,9 +141,28 @@ public:
     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
@@ -145,6 +170,17 @@ public:
     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 @@ public:
     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,6 +555,8 @@ inline STAmount::operator bool() const noexcept
 
 inline STAmount::operator Number() const
 {
+    if (enforceConversion_)
+        return toNumber(*enforceConversion_);
     if (native())
         return xrp();
     if (mAsset.holds<MPTIssue>())
@@ -517,6 +564,17 @@ inline STAmount::operator Number() const
     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;
 }