From d9f77a3fdc744e7434a10bcb7c449cb4040afebe Mon Sep 17 00:00:00 2001
From: Gregory Tsipenyuk <gtsipenyuk@ripple.com>
Date: Mon, 5 Aug 2024 11:36:51 -0400
Subject: [PATCH] Add TypedFieldAmount to declare Amount fields. Remove VT
 template parameter. Deduce value type from ValueType alias.

---
 include/xrpl/protocol/SField.h     |  57 +++--
 include/xrpl/protocol/SOTemplate.h |  11 +-
 include/xrpl/protocol/STObject.h   | 338 +++++++++++++++--------------
 src/libxrpl/protocol/SField.cpp    |  14 +-
 src/libxrpl/protocol/STObject.cpp  |   3 +-
 5 files changed, 234 insertions(+), 189 deletions(-)

diff --git a/include/xrpl/protocol/SField.h b/include/xrpl/protocol/SField.h
index 1c34a9b8438..4483f6bf3b4 100644
--- a/include/xrpl/protocol/SField.h
+++ b/include/xrpl/protocol/SField.h
@@ -304,15 +304,8 @@ class SField
 
 enum class SFieldMPT { None, Yes, No };
 
-// clang-format off
-template <typename T, SFieldMPT F>
-concept ValidFields = (std::is_same_v<T, STEitherAmount> &&
-                       (F == SFieldMPT::No || F == SFieldMPT::Yes)) ||
-    (!std::is_same_v<T, STEitherAmount> && F == SFieldMPT::None);
-
 /** A field with a type known at compile time. */
-template <class T, SFieldMPT M = SFieldMPT::None>
-    requires ValidFields<T, M>
+template <class T>
 struct TypedField : SField
 {
     using type = T;
@@ -322,25 +315,49 @@ struct TypedField : SField
 };
 
 /** Indicate std::optional field semantics. */
-template <class T, SFieldMPT M = SFieldMPT::None>
-    requires ValidFields<T, M>
+template <class T>
 struct OptionaledField
 {
-    TypedField<T, M> const* f;
+    TypedField<T> const* f;
+
+    explicit OptionaledField(TypedField<T> const& f_) : f(&f_)
+    {
+    }
+};
+
+template <class T>
+inline OptionaledField<T>
+operator~(TypedField<T> const& f)
+{
+    return OptionaledField<T>(f);
+}
+
+// Amount fields
+
+/** A field with a type known at compile time. */
+template <SFieldMPT>
+struct TypedFieldAmount : public TypedField<STEitherAmount>
+{
+    template <class... Args>
+    explicit TypedFieldAmount(private_access_tag_t pat, Args&&... args);
+};
 
-    explicit OptionaledField(TypedField<T, M> const& f_) : f(&f_)
+/** Indicate std::optional field semantics. */
+template <SFieldMPT M>
+struct OptionaledFieldAmount : public OptionaledField<STEitherAmount>
+{
+    explicit OptionaledFieldAmount(TypedFieldAmount<M> const& f_)
+        : OptionaledField<STEitherAmount>(f_)
     {
     }
 };
 
-template <class T, SFieldMPT M = SFieldMPT::None>
-    requires ValidFields<T, M>
-inline OptionaledField<T, M>
-operator~(TypedField<T, M> const& f)
+template <SFieldMPT M>
+inline OptionaledFieldAmount<M>
+operator~(TypedFieldAmount<M> const& f)
 {
-    return OptionaledField<T, M>(f);
+    return OptionaledFieldAmount<M>(f);
 }
-// clang-format on
 
 //------------------------------------------------------------------------------
 
@@ -359,8 +376,8 @@ using SF_UINT384 = TypedField<STBitString<384>>;
 using SF_UINT512 = TypedField<STBitString<512>>;
 
 using SF_ACCOUNT = TypedField<STAccount>;
-using SF_AMOUNT = TypedField<STEitherAmount, SFieldMPT::No>;
-using SF_EITHER_AMOUNT = TypedField<STEitherAmount, SFieldMPT::Yes>;
+using SF_AMOUNT = TypedFieldAmount<SFieldMPT::No>;
+using SF_EITHER_AMOUNT = TypedFieldAmount<SFieldMPT::Yes>;
 using SF_ISSUE = TypedField<STIssue>;
 using SF_CURRENCY = TypedField<STCurrency>;
 using SF_VL = TypedField<STBlob>;
diff --git a/include/xrpl/protocol/SOTemplate.h b/include/xrpl/protocol/SOTemplate.h
index 2ea726c6e29..0ea420a483b 100644
--- a/include/xrpl/protocol/SOTemplate.h
+++ b/include/xrpl/protocol/SOTemplate.h
@@ -75,10 +75,15 @@ class SOElement
     {
         init(fieldName);
     }
+    SOElement(TypedFieldAmount<SFieldMPT::No> const& fieldName, SOEStyle style)
+        : sField_(fieldName), style_(style), supportMpt_(soeMPTNotSupported)
+    {
+        init(fieldName);
+    }
     SOElement(
-        TypedField<STEitherAmount, SFieldMPT::Yes> const& fieldName,
+        TypedFieldAmount<SFieldMPT::Yes> const& fieldName,
         SOEStyle style,
-        SOETxMPTAmount supportMpt = SOETxMPTAmount::soeMPTNotSupported)
+        SOETxMPTAmount supportMpt = soeMPTNotSupported)
         : sField_(fieldName), style_(style), supportMpt_(supportMpt)
     {
         init(fieldName);
@@ -99,7 +104,7 @@ class SOElement
     bool
     supportMPT() const
     {
-        return supportMpt_ == SOETxMPTAmount::soeMPTSupported;
+        return supportMpt_ == soeMPTSupported;
     }
 };
 
diff --git a/include/xrpl/protocol/STObject.h b/include/xrpl/protocol/STObject.h
index 2a08447a91b..e2f9f32dc13 100644
--- a/include/xrpl/protocol/STObject.h
+++ b/include/xrpl/protocol/STObject.h
@@ -44,6 +44,9 @@
 
 namespace ripple {
 
+template <typename T, SFieldMPT M>
+using ValueType = std::conditional<M == SFieldMPT::No, STAmount, T>::type;
+
 class STArray;
 
 inline void
@@ -55,11 +58,11 @@ throwFieldNotFound(SField const& field)
 class STObject : public STBase, public CountedObject<STObject>
 {
     // Proxy value for a STBase derived class
-    template <class T, SFieldMPT, class VT = T::value_type>
+    template <class T, SFieldMPT = SFieldMPT::None>
     class Proxy;
-    template <class T, SFieldMPT, class VT = T::value_type>
+    template <class T, SFieldMPT = SFieldMPT::None>
     class ValueProxy;
-    template <class T, SFieldMPT, class VT = T::value_type>
+    template <class T, SFieldMPT = SFieldMPT::None>
     class OptionalProxy;
 
     struct Transform
@@ -239,8 +242,7 @@ class STObject : public STBase, public CountedObject<STObject>
     STEitherAmount const&
     getFieldAmount(SField const& field) const;
     STAmount const&
-    getFieldAmount(
-        TypedField<STEitherAmount, SFieldMPT::No> const& field) const;
+    getFieldAmount(TypedFieldAmount<SFieldMPT::No> const& field) const;
     STPathSet const&
     getFieldPathSet(SField const& field) const;
     const STVector256&
@@ -257,14 +259,15 @@ class STObject : public STBase, public CountedObject<STObject>
         @return The value of the specified field.
         @throws STObject::FieldErr if the field is not present.
     */
-    template <class T, SFieldMPT M>
+    template <class T>
     typename T::value_type
-    operator[](TypedField<T, M> const& f) const;
+    operator[](TypedField<T> const& f) const;
 
-    /** Overload for amount fields that don't support MPT
+    /** Overload for amount fields
      */
-    STAmount
-    operator[](TypedField<STEitherAmount, SFieldMPT::No> const& f) const;
+    template <SFieldMPT M>
+    typename ValueType<STEitherAmount, M>::value_type
+    operator[](TypedFieldAmount<M> const& f) const;
 
     /** Get the value of a field as a std::optional
 
@@ -274,14 +277,16 @@ class STObject : public STBase, public CountedObject<STObject>
         @return std::nullopt if the field is not present, else the value of
            the specified field.
     */
-    template <class T, SFieldMPT M>
+    template <class T>
     std::optional<std::decay_t<typename T::value_type>>
-    operator[](OptionaledField<T, M> const& of) const;
+    operator[](OptionaledField<T> const& of) const;
 
-    /** Overload for amount fields that don't support MPT
+    /** Overload for amount fields
      */
-    std::optional<STAmount>
-    operator[](OptionaledField<STEitherAmount, SFieldMPT::No> const& of) const;
+    template <SFieldMPT M>
+    std::optional<
+        std::decay_t<typename ValueType<STEitherAmount, M>::value_type>>
+    operator[](OptionaledFieldAmount<M> const& of) const;
 
     /** Get a modifiable field value.
         @param A TypedField built from an SField value representing the desired
@@ -290,14 +295,15 @@ class STObject : public STBase, public CountedObject<STObject>
         @return A modifiable reference to the value of the specified field.
         @throws STObject::FieldErr if the field is not present.
     */
-    template <class T, SFieldMPT M>
-    ValueProxy<T, M>
-    operator[](TypedField<T, M> const& f);
+    template <class T>
+    ValueProxy<T>
+    operator[](TypedField<T> const& f);
 
-    /** Overload for amount fields that don't support MPT
+    /** Overload for amount fields
      */
-    ValueProxy<STEitherAmount, SFieldMPT::No, STAmount>
-    operator[](TypedField<STEitherAmount, SFieldMPT::No> const& f);
+    template <SFieldMPT M>
+    ValueProxy<STEitherAmount, M>
+    operator[](TypedFieldAmount<M> const& f);
 
     /** Return a modifiable field value as std::optional
 
@@ -308,14 +314,15 @@ class STObject : public STBase, public CountedObject<STObject>
             reference to the value of the specified field. Returns
             std::nullopt if the field is not present.
     */
-    template <class T, SFieldMPT M>
-    OptionalProxy<T, M>
-    operator[](OptionaledField<T, M> const& of);
+    template <class T>
+    OptionalProxy<T>
+    operator[](OptionaledField<T> const& of);
 
-    /** Overload for amount fields that don't support MPT
+    /** Overload for amount fields
      */
-    OptionalProxy<STEitherAmount, SFieldMPT::No, STAmount>
-    operator[](OptionaledField<STEitherAmount, SFieldMPT::No> const& of);
+    template <SFieldMPT M>
+    OptionalProxy<STEitherAmount, M>
+    operator[](OptionaledFieldAmount<M> const& of);
 
     /** Get the value of a field.
         @param A TypedField built from an SField value representing the desired
@@ -324,14 +331,15 @@ class STObject : public STBase, public CountedObject<STObject>
         @return The value of the specified field.
         @throws STObject::FieldErr if the field is not present.
     */
-    template <class T, SFieldMPT M>
+    template <class T>
     typename T::value_type
-    at(TypedField<T, M> const& f) const;
+    at(TypedField<T> const& f) const;
 
-    /** Overload for amount fields that don't support MPT
+    /** Overload for amount fields
      */
-    STAmount
-    at(TypedField<STEitherAmount, SFieldMPT::No> const& f) const;
+    template <SFieldMPT M>
+    typename ValueType<STEitherAmount, M>::value_type
+    at(TypedFieldAmount<M> const& f) const;
 
     /** Get the value of a field as std::optional
 
@@ -341,14 +349,16 @@ class STObject : public STBase, public CountedObject<STObject>
         @return std::nullopt if the field is not present, else the value of
            the specified field.
     */
-    template <class T, SFieldMPT M>
+    template <class T>
     std::optional<std::decay_t<typename T::value_type>>
-    at(OptionaledField<T, M> const& of) const;
+    at(OptionaledField<T> const& of) const;
 
-    /** Overload for amount fields that don't support MPT
+    /** Overload for amount fields
      */
-    std::optional<STAmount>
-    at(OptionaledField<STEitherAmount, SFieldMPT::No> const& of) const;
+    template <SFieldMPT M>
+    std::optional<
+        std::decay_t<typename ValueType<STEitherAmount, M>::value_type>>
+    at(OptionaledFieldAmount<M> const& of) const;
 
     /** Get a modifiable field value.
         @param A TypedField built from an SField value representing the desired
@@ -357,14 +367,15 @@ class STObject : public STBase, public CountedObject<STObject>
         @return A modifiable reference to the value of the specified field.
         @throws STObject::FieldErr if the field is not present.
     */
-    template <class T, SFieldMPT M>
-    ValueProxy<T, M>
-    at(TypedField<T, M> const& f);
+    template <class T>
+    ValueProxy<T>
+    at(TypedField<T> const& f);
 
     /** Overload for amount fields that don't support MPT
      */
-    ValueProxy<STEitherAmount, SFieldMPT::No, STAmount>
-    at(TypedField<STEitherAmount, SFieldMPT::No> const& f);
+    template <SFieldMPT M>
+    ValueProxy<STEitherAmount, M>
+    at(TypedFieldAmount<M> const& f);
 
     /** Return a modifiable field value as std::optional
 
@@ -375,14 +386,15 @@ class STObject : public STBase, public CountedObject<STObject>
             reference to the value of the specified field. Returns
             std::nullopt if the field is not present.
     */
-    template <class T, SFieldMPT M>
-    OptionalProxy<T, M>
-    at(OptionaledField<T, M> const& of);
+    template <class T>
+    OptionalProxy<T>
+    at(OptionaledField<T> const& of);
 
     /** Overload for amount fields that don't support MPT
      */
-    OptionalProxy<STEitherAmount, SFieldMPT::No, STAmount>
-    at(OptionaledField<STEitherAmount, SFieldMPT::No> const& of);
+    template <SFieldMPT M>
+    OptionalProxy<STEitherAmount, M>
+    at(OptionaledFieldAmount<M> const& of);
 
     /** Set a field.
         if the field already exists, it is replaced.
@@ -473,13 +485,13 @@ class STObject : public STBase, public CountedObject<STObject>
     static std::vector<STBase const*>
     getSortedFields(STObject const& objToSort, WhichFields whichFields);
 
-    template <class T, SFieldMPT M>
+    template <class T>
     typename T::value_type
-    atImpl(TypedField<T, M> const& f) const;
+    atImpl(TypedField<T> const& f) const;
 
-    template <class T, SFieldMPT M>
+    template <class T>
     std::optional<std::decay_t<typename T::value_type>>
-    atImpl(OptionaledField<T, M> const& of) const;
+    atImpl(OptionaledField<T> const& of) const;
 
     // Implementation for getting (most) fields that return by value.
     //
@@ -527,19 +539,19 @@ class STObject : public STBase, public CountedObject<STObject>
 
 //------------------------------------------------------------------------------
 
-template <class T, SFieldMPT M, class VT>
+template <class T, SFieldMPT M>
 class STObject::Proxy
 {
 protected:
-    using value_type = VT;
+    using value_type = ValueType<T, M>::value_type;
 
     STObject* st_;
     SOEStyle style_;
-    TypedField<T, M> const* f_;
+    TypedField<T> const* f_;
 
     Proxy(Proxy const&) = default;
 
-    Proxy(STObject* st, TypedField<T, M> const* f);
+    Proxy(STObject* st, TypedField<T> const* f);
 
     value_type
     value() const;
@@ -552,11 +564,11 @@ class STObject::Proxy
     assign(U&& u);
 };
 
-template <class T, SFieldMPT M, class VT>
-class STObject::ValueProxy : private Proxy<T, M, VT>
+template <class T, SFieldMPT M>
+class STObject::ValueProxy : private Proxy<T, M>
 {
 private:
-    using value_type = VT;
+    using value_type = ValueType<T, M>::value_type;
 
 public:
     ValueProxy(ValueProxy const&) = default;
@@ -572,14 +584,14 @@ class STObject::ValueProxy : private Proxy<T, M, VT>
 private:
     friend class STObject;
 
-    ValueProxy(STObject* st, TypedField<T, M> const* f);
+    ValueProxy(STObject* st, TypedField<T> const* f);
 };
 
-template <class T, SFieldMPT M, class VT>
-class STObject::OptionalProxy : private Proxy<T, M, VT>
+template <class T, SFieldMPT M>
+class STObject::OptionalProxy : private Proxy<T, M>
 {
 private:
-    using value_type = VT;
+    using value_type = ValueType<T, M>::value_type;
 
     using optional_type = std::optional<typename std::decay<value_type>::type>;
 
@@ -694,7 +706,7 @@ class STObject::OptionalProxy : private Proxy<T, M, VT>
 private:
     friend class STObject;
 
-    OptionalProxy(STObject* st, TypedField<T, M> const* f);
+    OptionalProxy(STObject* st, TypedField<T> const* f);
 
     bool
     engaged() const noexcept;
@@ -711,8 +723,8 @@ class STObject::FieldErr : public std::runtime_error
     using std::runtime_error::runtime_error;
 };
 
-template <class T, SFieldMPT M, class VT>
-STObject::Proxy<T, M, VT>::Proxy(STObject* st, TypedField<T, M> const* f)
+template <class T, SFieldMPT M>
+STObject::Proxy<T, M>::Proxy(STObject* st, TypedField<T> const* f)
     : st_(st), f_(f)
 {
     if (st_->mType)
@@ -729,9 +741,9 @@ STObject::Proxy<T, M, VT>::Proxy(STObject* st, TypedField<T, M> const* f)
     }
 }
 
-template <class T, SFieldMPT M, class VT>
+template <class T, SFieldMPT M>
 auto
-STObject::Proxy<T, M, VT>::value() const -> value_type
+STObject::Proxy<T, M>::value() const -> value_type
 {
     auto const t = find();
     if (t)
@@ -750,8 +762,7 @@ STObject::Proxy<T, M, VT>::value() const -> value_type
 
 template <>
 inline auto
-STObject::Proxy<STEitherAmount, SFieldMPT::No, STAmount>::value() const
-    -> STAmount
+STObject::Proxy<STEitherAmount, SFieldMPT::No>::value() const -> STAmount
 {
     auto const t = find();
     if (t)
@@ -768,17 +779,17 @@ STObject::Proxy<STEitherAmount, SFieldMPT::No, STAmount>::value() const
     return STAmount{};
 }
 
-template <class T, SFieldMPT M, class VT>
+template <class T, SFieldMPT M>
 inline T const*
-STObject::Proxy<T, M, VT>::find() const
+STObject::Proxy<T, M>::find() const
 {
     return dynamic_cast<T const*>(st_->peekAtPField(*f_));
 }
 
-template <class T, SFieldMPT M, class VT>
+template <class T, SFieldMPT M>
 template <class U>
 void
-STObject::Proxy<T, M, VT>::assign(U&& u)
+STObject::Proxy<T, M>::assign(U&& u)
 {
     if (style_ == soeDEFAULT && u == value_type{})
     {
@@ -796,71 +807,68 @@ STObject::Proxy<T, M, VT>::assign(U&& u)
 
 //------------------------------------------------------------------------------
 
-template <class T, SFieldMPT M, class VT>
+template <class T, SFieldMPT M>
 template <class U>
-std::enable_if_t<std::is_assignable_v<T, U>, STObject::ValueProxy<T, M, VT>&>
-STObject::ValueProxy<T, M, VT>::operator=(U&& u)
+std::enable_if_t<std::is_assignable_v<T, U>, STObject::ValueProxy<T, M>&>
+STObject::ValueProxy<T, M>::operator=(U&& u)
 {
     this->assign(std::forward<U>(u));
     return *this;
 }
 
-template <class T, SFieldMPT M, class VT>
-STObject::ValueProxy<T, M, VT>::operator value_type() const
+template <class T, SFieldMPT M>
+STObject::ValueProxy<T, M>::operator value_type() const
 {
     return this->value();
 }
 
-template <class T, SFieldMPT M, class VT>
-STObject::ValueProxy<T, M, VT>::ValueProxy(
-    STObject* st,
-    TypedField<T, M> const* f)
-    : Proxy<T, M, VT>(st, f)
+template <class T, SFieldMPT M>
+STObject::ValueProxy<T, M>::ValueProxy(STObject* st, TypedField<T> const* f)
+    : Proxy<T, M>(st, f)
 {
 }
 
 //------------------------------------------------------------------------------
 
-template <class T, SFieldMPT M, class VT>
-STObject::OptionalProxy<T, M, VT>::operator bool() const noexcept
+template <class T, SFieldMPT M>
+STObject::OptionalProxy<T, M>::operator bool() const noexcept
 {
     return engaged();
 }
 
-template <class T, SFieldMPT M, class VT>
+template <class T, SFieldMPT M>
 auto
-STObject::OptionalProxy<T, M, VT>::operator*() const -> value_type
+STObject::OptionalProxy<T, M>::operator*() const -> value_type
 {
     return this->value();
 }
 
-template <class T, SFieldMPT M, class VT>
-STObject::OptionalProxy<T, M, VT>::operator typename STObject::
-    OptionalProxy<T, M, VT>::optional_type() const
+template <class T, SFieldMPT M>
+STObject::OptionalProxy<T, M>::operator typename STObject::OptionalProxy<T, M>::
+    optional_type() const
 {
     return optional_value();
 }
 
-template <class T, SFieldMPT M, class VT>
-typename STObject::OptionalProxy<T, M, VT>::optional_type
-STObject::OptionalProxy<T, M, VT>::operator~() const
+template <class T, SFieldMPT M>
+typename STObject::OptionalProxy<T, M>::optional_type
+STObject::OptionalProxy<T, M>::operator~() const
 {
     return optional_value();
 }
 
-template <class T, SFieldMPT M, class VT>
+template <class T, SFieldMPT M>
 auto
-STObject::OptionalProxy<T, M, VT>::operator=(std::nullopt_t const&)
+STObject::OptionalProxy<T, M>::operator=(std::nullopt_t const&)
     -> OptionalProxy&
 {
     disengage();
     return *this;
 }
 
-template <class T, SFieldMPT M, class VT>
+template <class T, SFieldMPT M>
 auto
-STObject::OptionalProxy<T, M, VT>::operator=(optional_type&& v)
-    -> OptionalProxy&
+STObject::OptionalProxy<T, M>::operator=(optional_type&& v) -> OptionalProxy&
 {
     if (v)
         this->assign(std::move(*v));
@@ -869,9 +877,9 @@ STObject::OptionalProxy<T, M, VT>::operator=(optional_type&& v)
     return *this;
 }
 
-template <class T, SFieldMPT M, class VT>
+template <class T, SFieldMPT M>
 auto
-STObject::OptionalProxy<T, M, VT>::operator=(optional_type const& v)
+STObject::OptionalProxy<T, M>::operator=(optional_type const& v)
     -> OptionalProxy&
 {
     if (v)
@@ -881,33 +889,33 @@ STObject::OptionalProxy<T, M, VT>::operator=(optional_type const& v)
     return *this;
 }
 
-template <class T, SFieldMPT M, class VT>
+template <class T, SFieldMPT M>
 template <class U>
-std::enable_if_t<std::is_assignable_v<T, U>, STObject::OptionalProxy<T, M, VT>&>
-STObject::OptionalProxy<T, M, VT>::operator=(U&& u)
+std::enable_if_t<std::is_assignable_v<T, U>, STObject::OptionalProxy<T, M>&>
+STObject::OptionalProxy<T, M>::operator=(U&& u)
 {
     this->assign(std::forward<U>(u));
     return *this;
 }
 
-template <class T, SFieldMPT M, class VT>
-STObject::OptionalProxy<T, M, VT>::OptionalProxy(
+template <class T, SFieldMPT M>
+STObject::OptionalProxy<T, M>::OptionalProxy(
     STObject* st,
-    TypedField<T, M> const* f)
-    : Proxy<T, M, VT>(st, f)
+    TypedField<T> const* f)
+    : Proxy<T, M>(st, f)
 {
 }
 
-template <class T, SFieldMPT M, class VT>
+template <class T, SFieldMPT M>
 bool
-STObject::OptionalProxy<T, M, VT>::engaged() const noexcept
+STObject::OptionalProxy<T, M>::engaged() const noexcept
 {
     return this->style_ == soeDEFAULT || this->find() != nullptr;
 }
 
-template <class T, SFieldMPT M, class VT>
+template <class T, SFieldMPT M>
 void
-STObject::OptionalProxy<T, M, VT>::disengage()
+STObject::OptionalProxy<T, M>::disengage()
 {
     if (this->style_ == soeREQUIRED || this->style_ == soeDEFAULT)
         Throw<STObject::FieldErr>(
@@ -918,18 +926,18 @@ STObject::OptionalProxy<T, M, VT>::disengage()
         this->st_->makeFieldAbsent(*this->f_);
 }
 
-template <class T, SFieldMPT M, class VT>
+template <class T, SFieldMPT M>
 auto
-STObject::OptionalProxy<T, M, VT>::optional_value() const -> optional_type
+STObject::OptionalProxy<T, M>::optional_value() const -> optional_type
 {
     if (!engaged())
         return std::nullopt;
     return this->value();
 }
 
-template <class T, SFieldMPT M, class VT>
-typename STObject::OptionalProxy<T, M, VT>::value_type
-STObject::OptionalProxy<T, M, VT>::value_or(value_type val) const
+template <class T, SFieldMPT M>
+typename STObject::OptionalProxy<T, M>::value_type
+STObject::OptionalProxy<T, M>::value_or(value_type val) const
 {
     return engaged() ? this->value() : val;
 }
@@ -1034,64 +1042,67 @@ STObject::getPIndex(int offset)
     return &v_[offset].get();
 }
 
-template <class T, SFieldMPT M>
+template <class T>
 typename T::value_type
-STObject::operator[](TypedField<T, M> const& f) const
+STObject::operator[](TypedField<T> const& f) const
 {
     return at(f);
 }
 
-inline STAmount
-STObject::operator[](TypedField<STEitherAmount, SFieldMPT::No> const& f) const
+template <SFieldMPT M>
+typename ValueType<STEitherAmount, M>::value_type
+STObject::operator[](TypedFieldAmount<M> const& f) const
 {
     return at(f);
 }
 
-template <class T, SFieldMPT M>
+template <class T>
 std::optional<std::decay_t<typename T::value_type>>
-STObject::operator[](OptionaledField<T, M> const& of) const
+STObject::operator[](OptionaledField<T> const& of) const
 {
     return at(of);
 }
 
-inline std::optional<STAmount>
-STObject::operator[](
-    OptionaledField<STEitherAmount, SFieldMPT::No> const& of) const
+template <SFieldMPT M>
+std::optional<std::decay_t<typename ValueType<STEitherAmount, M>::value_type>>
+STObject::operator[](OptionaledFieldAmount<M> const& of) const
 {
     return at(of);
 }
 
-template <class T, SFieldMPT M>
+template <class T>
 inline auto
-STObject::operator[](TypedField<T, M> const& f) -> ValueProxy<T, M>
+STObject::operator[](TypedField<T> const& f) -> ValueProxy<T>
 {
     return at(f);
 }
 
+template <SFieldMPT M>
 inline auto
-STObject::operator[](TypedField<STEitherAmount, SFieldMPT::No> const& f)
-    -> ValueProxy<STEitherAmount, SFieldMPT::No, STAmount>
+STObject::operator[](TypedFieldAmount<M> const& f)
+    -> ValueProxy<STEitherAmount, M>
 {
     return at(f);
 }
 
-template <class T, SFieldMPT M>
+template <class T>
 inline auto
-STObject::operator[](OptionaledField<T, M> const& of) -> OptionalProxy<T, M>
+STObject::operator[](OptionaledField<T> const& of) -> OptionalProxy<T>
 {
     return at(of);
 }
 
+template <SFieldMPT M>
 inline auto
-STObject::operator[](OptionaledField<STEitherAmount, SFieldMPT::No> const& of)
-    -> OptionalProxy<STEitherAmount, SFieldMPT::No, STAmount>
+STObject::operator[](OptionaledFieldAmount<M> const& of)
+    -> OptionalProxy<STEitherAmount, M>
 {
     return at(of);
 }
 
-template <class T, SFieldMPT M>
+template <class T>
 typename T::value_type
-STObject::atImpl(TypedField<T, M> const& f) const
+STObject::atImpl(TypedField<T> const& f) const
 {
     auto const b = peekAtPField(f);
     if (!b)
@@ -1116,22 +1127,26 @@ STObject::atImpl(TypedField<T, M> const& f) const
     return dv;
 }
 
-template <class T, SFieldMPT M>
+template <class T>
 typename T::value_type
-STObject::at(TypedField<T, M> const& f) const
+STObject::at(TypedField<T> const& f) const
 {
     return atImpl(f);
 }
 
-inline STAmount
-STObject::at(TypedField<STEitherAmount, SFieldMPT::No> const& f) const
+template <SFieldMPT M>
+typename ValueType<STEitherAmount, M>::value_type
+STObject::at(TypedFieldAmount<M> const& f) const
 {
-    return get<STAmount>(atImpl(f));
+    if constexpr (M == SFieldMPT::Yes)
+        return atImpl(f);
+    else
+        return get<STAmount>(atImpl(f));
 }
 
-template <class T, SFieldMPT M>
+template <class T>
 std::optional<std::decay_t<typename T::value_type>>
-STObject::atImpl(OptionaledField<T, M> const& of) const
+STObject::atImpl(OptionaledField<T> const& of) const
 {
     auto const b = peekAtPField(*of.f);
     if (!b)
@@ -1149,45 +1164,50 @@ STObject::atImpl(OptionaledField<T, M> const& of) const
     return u->value();
 }
 
-template <class T, SFieldMPT M>
+template <class T>
 std::optional<std::decay_t<typename T::value_type>>
-STObject::at(OptionaledField<T, M> const& of) const
+STObject::at(OptionaledField<T> const& of) const
 {
     return atImpl(of);
 }
 
-inline std::optional<STAmount>
-STObject::at(OptionaledField<STEitherAmount, SFieldMPT::No> const& of) const
+template <SFieldMPT M>
+std::optional<std::decay_t<typename ValueType<STEitherAmount, M>::value_type>>
+STObject::at(OptionaledFieldAmount<M> const& of) const
 {
-    return get<STAmount>(atImpl(of));
+    if constexpr (M == SFieldMPT::Yes)
+        return atImpl(of);
+    else
+        return get<STAmount>(atImpl(of));
 }
 
-template <class T, SFieldMPT M>
+template <class T>
 inline auto
-STObject::at(TypedField<T, M> const& f) -> ValueProxy<T, M>
+STObject::at(TypedField<T> const& f) -> ValueProxy<T>
 {
-    return ValueProxy<T, M>(this, &f);
+    return ValueProxy<T>(this, &f);
 }
 
+template <SFieldMPT M>
 inline auto
-STObject::at(TypedField<STEitherAmount, SFieldMPT::No> const& f)
-    -> ValueProxy<STEitherAmount, SFieldMPT::No, STAmount>
+STObject::at(TypedFieldAmount<M> const& f) -> ValueProxy<STEitherAmount, M>
 {
-    return ValueProxy<STEitherAmount, SFieldMPT::No, STAmount>(this, &f);
+    return ValueProxy<STEitherAmount, M>(this, &f);
 }
 
-template <class T, SFieldMPT M>
+template <class T>
 inline auto
-STObject::at(OptionaledField<T, M> const& of) -> OptionalProxy<T, M>
+STObject::at(OptionaledField<T> const& of) -> OptionalProxy<T>
 {
-    return OptionalProxy<T, M>(this, of.f);
+    return OptionalProxy<T>(this, of.f);
 }
 
+template <SFieldMPT M>
 inline auto
-STObject::at(OptionaledField<STEitherAmount, SFieldMPT::No> const& of)
-    -> OptionalProxy<STEitherAmount, SFieldMPT::No, STAmount>
+STObject::at(OptionaledFieldAmount<M> const& of)
+    -> OptionalProxy<STEitherAmount, M>
 {
-    return OptionalProxy<STEitherAmount, SFieldMPT::No, STAmount>(this, of.f);
+    return OptionalProxy<STEitherAmount, M>(this, of.f);
 }
 
 template <class Tag>
diff --git a/src/libxrpl/protocol/SField.cpp b/src/libxrpl/protocol/SField.cpp
index b3b92475578..38c2148c980 100644
--- a/src/libxrpl/protocol/SField.cpp
+++ b/src/libxrpl/protocol/SField.cpp
@@ -38,15 +38,19 @@ struct SField::private_access_tag_t
 
 static SField::private_access_tag_t access;
 
-// clang-format off
-template <class T, SFieldMPT M>
-    requires ValidFields<T, M>
+template <class T>
 template <class... Args>
-TypedField<T, M>::TypedField(private_access_tag_t pat, Args&&... args)
+TypedField<T>::TypedField(private_access_tag_t pat, Args&&... args)
     : SField(pat, std::forward<Args>(args)...)
 {
 }
-// clang-format on
+
+template <SFieldMPT M>
+template <class... Args>
+TypedFieldAmount<M>::TypedFieldAmount(private_access_tag_t pat, Args&&... args)
+    : TypedField<STEitherAmount>(pat, std::forward<Args>(args)...)
+{
+}
 
 // Construct all compile-time SFields, and register them in the knownCodeToField
 // database:
diff --git a/src/libxrpl/protocol/STObject.cpp b/src/libxrpl/protocol/STObject.cpp
index 299811d093f..6542424e372 100644
--- a/src/libxrpl/protocol/STObject.cpp
+++ b/src/libxrpl/protocol/STObject.cpp
@@ -646,8 +646,7 @@ STObject::getFieldAmount(SField const& field) const
 }
 
 STAmount const&
-STObject::getFieldAmount(
-    TypedField<STEitherAmount, SFieldMPT::No> const& field) const
+STObject::getFieldAmount(TypedFieldAmount<SFieldMPT::No> const& field) const
 {
     static STEitherAmount const empty{};
     return get<STAmount>(getFieldByConstRef<STEitherAmount>(field, empty));