[WIP] Checkpoint

Author: ximinez

include/xrpl/protocol/SField.h

@@ -135,7 +135,10 @@ class SField
         sMD_Always = 0x10,   // value when node containing it is affected at all
         sMD_BaseTen = 0x20,  // value is treated as base 10, overriding behavior
         sMD_PseudoAccount = 0x40,  // if this field is set in an ACCOUNT_ROOT
-        // _only_, then it is a pseudo-account
+                                   // _only_, then it is a pseudo-account
+        sMD_NeedsAsset = 0x80,     // This field needs to be associated with an
+                                   // asset before it is serialized as a ledger
+                                   // object. Intended for STNumber.
         sMD_Default =
             sMD_ChangeOrig | sMD_ChangeNew | sMD_DeleteFinal | sMD_Create
     };

include/xrpl/protocol/STAmount.h

@@ -731,17 +731,32 @@ getRate(STAmount const& offerOut, STAmount const& offerIn);
  * @param rounding Optional Number rounding mode
  *
  */
-STAmount
+[[nodiscard]] STAmount
 roundToScale(
     STAmount const& value,
     std::int32_t scale,
     Number::rounding_mode rounding = Number::getround());
 
+/** Round an arbitrary precision Number IN PLACE to the precision of a given
+ * Asset.
+ *
+ * This is used to ensure that calculations do not collect dust for IOUs, or
+ * fractional amounts for the integral types XRP and MPT.
+ *
+ * @param asset The relevant asset
+ * @param value The lvalue to be rounded
+ */
+template <AssetType A>
+void
+roundToAsset(A const& asset, Number& value)
+{
+    value = STAmount{asset, value};
+}
+
 /** Round an arbitrary precision Number to the precision of a given Asset.
  *
- * This is used to ensure that calculations do not collect dust beyond the
- * precision of the reference value for IOUs, or fractional amounts for the
- * integral types XRP and MPT.
+ * This is used to ensure that calculations do not collect dust beyond specified
+ * scale for IOUs, or fractional amounts for the integral types XRP and MPT.
  *
  * @param asset The relevant asset
  * @param value The value to be rounded
@@ -750,7 +765,7 @@ roundToScale(
  * @param rounding Optional Number rounding mode
  */
 template <AssetType A>
-Number
+[[nodiscard]] Number
 roundToAsset(
     A const& asset,
     Number const& value,

include/xrpl/protocol/STNumber.h

@@ -4,6 +4,7 @@
 #include <xrpl/basics/CountedObject.h>
 #include <xrpl/basics/Number.h>
 #include <xrpl/protocol/STBase.h>
+#include <xrpl/protocol/STTakesAsset.h>
 
 #include <ostream>
 
@@ -20,7 +21,7 @@ namespace ripple {
  * without paying the storage cost of duplicating asset information
  * that may be deduced from the context.
  */
-class STNumber : public STBase, public CountedObject<STNumber>
+class STNumber : public STTakesAsset, public CountedObject<STNumber>
 {
 private:
     Number value_;
@@ -56,6 +57,9 @@ class STNumber : public STBase, public CountedObject<STNumber>
     bool
     isDefault() const override;
 
+    void
+    associateAsset(Asset const& a) override;
+
     operator Number() const
     {
         return value_;

include/xrpl/protocol/STTakesAsset.h

@@ -0,0 +1,29 @@
+#ifndef XRPL_PROTOCOL_STTAKESASSET_H_INCLUDED
+#define XRPL_PROTOCOL_STTAKESASSET_H_INCLUDED
+
+#include <xrpl/protocol/Asset.h>
+#include <xrpl/protocol/STBase.h>
+
+namespace ripple {
+
+class STTakesAsset : public STBase
+{
+protected:
+    std::optional<Asset> asset_;
+
+public:
+    using STBase::STBase;
+    using STBase::operator=;
+
+    virtual void
+    associateAsset(Asset const& a);
+};
+
+class STLedgerEntry;
+
+void
+associateAsset(SLE& sle, Asset const& asset);
+
+}  // namespace ripple
+
+#endif

include/xrpl/protocol/detail/sfields.macro

@@ -207,22 +207,22 @@ TYPED_SFIELD(sfLoanID,                   UINT256,   38)
 
 // number (common)
 TYPED_SFIELD(sfNumber,                   NUMBER,     1)
-TYPED_SFIELD(sfAssetsAvailable,          NUMBER,     2)
-TYPED_SFIELD(sfAssetsMaximum,            NUMBER,     3)
-TYPED_SFIELD(sfAssetsTotal,              NUMBER,     4)
-TYPED_SFIELD(sfLossUnrealized,           NUMBER,     5)
-TYPED_SFIELD(sfDebtTotal,                NUMBER,     6)
-TYPED_SFIELD(sfDebtMaximum,              NUMBER,     7)
-TYPED_SFIELD(sfCoverAvailable,           NUMBER,     8)
+TYPED_SFIELD(sfAssetsAvailable,          NUMBER,     2, SField::sMD_NeedsAsset | SField::sMD_Default)
+TYPED_SFIELD(sfAssetsMaximum,            NUMBER,     3, SField::sMD_NeedsAsset | SField::sMD_Default)
+TYPED_SFIELD(sfAssetsTotal,              NUMBER,     4, SField::sMD_NeedsAsset | SField::sMD_Default)
+TYPED_SFIELD(sfLossUnrealized,           NUMBER,     5, SField::sMD_NeedsAsset | SField::sMD_Default)
+TYPED_SFIELD(sfDebtTotal,                NUMBER,     6, SField::sMD_NeedsAsset | SField::sMD_Default)
+TYPED_SFIELD(sfDebtMaximum,              NUMBER,     7, SField::sMD_NeedsAsset | SField::sMD_Default)
+TYPED_SFIELD(sfCoverAvailable,           NUMBER,     8, SField::sMD_NeedsAsset | SField::sMD_Default)
 TYPED_SFIELD(sfLoanOriginationFee,       NUMBER,     9)
 TYPED_SFIELD(sfLoanServiceFee,           NUMBER,     10)
 TYPED_SFIELD(sfLatePaymentFee,           NUMBER,     11)
 TYPED_SFIELD(sfClosePaymentFee,          NUMBER,     12)
-TYPED_SFIELD(sfPrincipalOutstanding,     NUMBER,     13)
+TYPED_SFIELD(sfPrincipalOutstanding,     NUMBER,     13, SField::sMD_NeedsAsset | SField::sMD_Default)
 TYPED_SFIELD(sfPrincipalRequested,       NUMBER,     14)
-TYPED_SFIELD(sfTotalValueOutstanding,    NUMBER,     15)
+TYPED_SFIELD(sfTotalValueOutstanding,    NUMBER,     15, SField::sMD_NeedsAsset | SField::sMD_Default)
 TYPED_SFIELD(sfPeriodicPayment,          NUMBER,     16)
-TYPED_SFIELD(sfManagementFeeOutstanding, NUMBER,     17)
+TYPED_SFIELD(sfManagementFeeOutstanding, NUMBER,     17, SField::sMD_NeedsAsset | SField::sMD_Default)
 
 // int32
 TYPED_SFIELD(sfLoanScale,                INT32,      1)

src/libxrpl/protocol/STNumber.cpp

@@ -1,9 +1,12 @@
+#include <xrpl/protocol/STNumber.h>
+// Do not remove. Keep STNumber.h first
 #include <xrpl/basics/Number.h>
 #include <xrpl/beast/core/LexicalCast.h>
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STAmount.h>
 #include <xrpl/protocol/STBase.h>
-#include <xrpl/protocol/STNumber.h>
+#include <xrpl/protocol/STIssue.h>
 #include <xrpl/protocol/Serializer.h>
 
 #include <boost/lexical_cast.hpp>
@@ -17,11 +20,11 @@
 namespace ripple {
 
 STNumber::STNumber(SField const& field, Number const& value)
-    : STBase(field), value_(value)
+    : STTakesAsset(field), value_(value)
 {
 }
 
-STNumber::STNumber(SerialIter& sit, SField const& field) : STBase(field)
+STNumber::STNumber(SerialIter& sit, SField const& field) : STTakesAsset(field)
 {
     // We must call these methods in separate statements
     // to guarantee their order of execution.
@@ -42,6 +45,19 @@ STNumber::getText() const
     return to_string(value_);
 }
 
+void
+STNumber::associateAsset(Asset const& a)
+{
+    STTakesAsset::associateAsset(a);
+
+    XRPL_ASSERT_PARTS(
+        getFName().shouldMeta(SField::sMD_NeedsAsset),
+        "STNumber::associateAsset",
+        "field needs asset");
+
+    roundToAsset(a, value_);
+}
+
 void
 STNumber::add(Serializer& s) const
 {
@@ -51,8 +67,47 @@ STNumber::add(Serializer& s) const
         getFName().fieldType == getSType(),
         "ripple::STNumber::add : field type match");
 
-    auto const mantissa = value_.mantissa();
-    auto const exponent = value_.exponent();
+    SField const& field = getFName();
+    auto value = value_;
+#if 0
+    if (field.shouldMeta(SField::sMD_NeedsAsset))
+    {
+        // asset is defined in the STTakesAsset base class
+        if (asset_)
+            roundToAsset(*asset_, value);
+        else
+        {
+            // There may be circumstances where an already-rounded Number is
+            // passed through to serialization without an asset. We can't be
+            // 100% sure, but we can check a couple of conditions that indicate
+            // it's _probably_ rounded.
+            XRPL_ASSERT_PARTS(
+                Number::getMantissaScale() == MantissaRange::small,
+                "ripple::STNumber::add",
+                "STNumber only used with large mantissa scale");
+            std::uint64_t mantissa =
+                value < beast::zero ? -value.mantissa() : value.mantissa();
+            auto exponent = value.exponent();
+            if (mantissa < Number::minMantissa())
+            {
+                mantissa *= 10;
+                --exponent;
+            }
+            XRPL_ASSERT_PARTS(
+                exponent <= 0 || (mantissa % 1000 == 0),
+                "ripple::STNumber::add",
+                "STNumber is probably already rounded");
+            /*
+            Throw<std::runtime_error>(
+                "ripple::STNumber::add : asset required for field " +
+                field.getName());
+            */
+        }
+    }
+#endif
+
+    auto const mantissa = value.mantissa();
+    auto const exponent = value.exponent();
     XRPL_ASSERT_PARTS(
         mantissa <= std::numeric_limits<std::int64_t>::max() &&
             mantissa >= std::numeric_limits<std::int64_t>::min(),

src/libxrpl/protocol/STTakesAsset.cpp

@@ -0,0 +1,37 @@
+#include <xrpl/protocol/STTakesAsset.h>
+// Do not remove. Force STTakesAsset.h first
+#include <xrpl/protocol/STLedgerEntry.h>
+
+namespace ripple {
+
+void
+STTakesAsset::associateAsset(Asset const& a)
+{
+    asset_.emplace(a);
+}
+
+void
+associateAsset(SLE& sle, Asset const& asset)
+{
+#if 1
+    // Iterating by offset is the only way to get non-const references
+    for (int i = 0; i < sle.getCount(); ++i)
+    {
+        STBase& entry = sle.getIndex(i);
+        SField const& field = entry.getFName();
+        if (field.shouldMeta(SField::sMD_NeedsAsset))
+        {
+            auto const type = entry.getSType();
+            // If the field is not set or present, skip it.
+            if (type == STI_NOTPRESENT)
+                continue;
+            // If the type doesn't downcast, then the flag shouldn't be on the
+            // SField
+            auto& ta = entry.downcast<STTakesAsset>();
+            ta.associateAsset(asset);
+        }
+    }
+#endif
+}
+
+}  // namespace ripple

src/test/app/Loan_test.cpp

@@ -350,8 +350,14 @@ class Loan_test : public beast::unit_test::suite
                     env.balance(account, broker.asset) -
                         (balanceBefore - balanceChangeAmount),
                     borrowerScale);
-                env.test.BEAST_EXPECT(
-                    roundToScale(difference, loanScale) >= beast::zero);
+                env.test.expect(
+                    roundToScale(difference, loanScale) >= beast::zero,
+                    "Balance before: " + to_string(balanceBefore.value()) +
+                        ", expected change: " + to_string(balanceChangeAmount) +
+                        ", difference (balance after - expected): " +
+                        to_string(difference),
+                    __FILE__,
+                    __LINE__);
             }
         }
 
@@ -2451,22 +2457,34 @@ class Loan_test : public beast::unit_test::suite
                     getCurrentState(env, broker, loanKeylet, verifyLoanStatus);
                 env.close();
 
+                BEAST_EXPECT(
+                    STAmount(broker.asset, state.periodicPayment) ==
+                    broker.asset(Number(8333457002039338267, -17)));
+
                 // Make all the payments in one transaction
                 // service fee is 2
                 auto const startingPayments = state.paymentRemaining;
                 STAmount const payoffAmount = [&]() {
-                    NumberRoundModeGuard mg(Number::upward);
+                    // NumberRoundModeGuard mg(Number::upward);
                     auto const rawPayoff = startingPayments *
                         (state.periodicPayment + broker.asset(2).value());
                     STAmount const payoffAmount{broker.asset, rawPayoff};
                     BEAST_EXPECTS(
                         payoffAmount ==
-                            broker.asset(Number(1024014840139457, -12)),
+                            broker.asset(Number(1024014840244721, -12)),
                         to_string(payoffAmount));
                     BEAST_EXPECT(payoffAmount > state.principalOutstanding);
                     return payoffAmount;
                 }();
 
+                auto const totalPayoffValue = state.totalValue +
+                    startingPayments * broker.asset(2).value();
+                STAmount const totalPayoffAmount{
+                    broker.asset, totalPayoffValue};
+
+                log << "Payoff amount: " << payoffAmount
+                    << ". Total Value: " << totalPayoffAmount << std::endl;
+
                 singlePayment(
                     loanKeylet,
                     verifyLoanStatus,
@@ -2653,7 +2671,7 @@ class Loan_test : public beast::unit_test::suite
                     roundedPeriodicPayment ==
                     roundToScale(
                         broker.asset(
-                            Number(8333457001162141, -14), Number::upward),
+                            Number(8333457002039338267, -17), Number::upward),
                         state.loanScale,
                         Number::upward));
                 // 83334570.01162141
@@ -2668,7 +2686,7 @@ class Loan_test : public beast::unit_test::suite
                     totalDue ==
                     roundToScale(
                         broker.asset(
-                            Number(8533457001162141, -14), Number::upward),
+                            Number(8533457002039338267, -17), Number::upward),
                         state.loanScale,
                         Number::upward));
 
@@ -2704,7 +2722,7 @@ class Loan_test : public beast::unit_test::suite
                     transactionAmount ==
                     roundToScale(
                         broker.asset(
-                            Number(9533457001162141, -14), Number::upward),
+                            Number(9533457002039400, -14), Number::upward),
                         state.loanScale,
                         Number::upward));
 
@@ -2805,7 +2823,7 @@ class Loan_test : public beast::unit_test::suite
                             Number::upward) ==
                             roundToScale(
                                 broker.asset(
-                                    Number(8333228695260180, -14),
+                                    Number(8333228691531218890, -17),
                                     Number::upward),
                                 state.loanScale,
                                 Number::upward));
@@ -3643,7 +3661,7 @@ class Loan_test : public beast::unit_test::suite
         env(pay(issuer, borrower, mptAsset(10'000)));
         env.close();
 
-        std::array const assets{xrpAsset, mptAsset, iouAsset};
+        std::array const assets{iouAsset, xrpAsset, mptAsset};
 
         // Create vaults and loan brokers
         std::vector<BrokerInfo> brokers;