Refactoring 1

2025-12-06 17:27:55 +00:00 · 2025-05-16 15:32:31 +01:00
parent e514de76ed
commit 4e50087612
56 changed files with 1582 additions and 531 deletions
--- a/include/xrpl/basics/base_uint.h
+++ b/include/xrpl/basics/base_uint.h
@@ -632,6 +632,13 @@ to_string(base_uint<Bits, Tag> const& a)
    return strHex(a.cbegin(), a.cend());
 }

+template <std::size_t Bits, class Tag>
+inline std::string
+to_short_string(base_uint<Bits, Tag> const& a)
+{
+    return to_string(a).substr(0, 8) + "...";
+}
+
 template <std::size_t Bits, class Tag>
 inline std::ostream&
 operator<<(std::ostream& out, base_uint<Bits, Tag> const& u)
--- a/include/xrpl/beast/utility/instrumentation.h
+++ b/include/xrpl/beast/utility/instrumentation.h
@@ -39,11 +39,16 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #endif

 #define XRPL_ASSERT ALWAYS_OR_UNREACHABLE
+#define XRPL_ASSERT_PARTS(cond, function, description, ...) \
+    XRPL_ASSERT(cond, function " : " description)

 // How to use the instrumentation macros:
 //
 // * XRPL_ASSERT if cond must be true but the line might not be reached during
 //   fuzzing. Same like `assert` in normal use.
+// * XRPL_ASSERT_PARTS is for convenience, and works like XRPL_ASSERT, but
+//   splits the message param into "function" and "description", then joins
+//   them with " : " before passing to XRPL_ASSERT.
 // * ALWAYS if cond must be true _and_ the line must be reached during fuzzing.
 //   Same like `assert` in normal use.
 // * REACHABLE if the line must be reached during fuzzing
--- a/include/xrpl/protocol/Protocol.h
+++ b/include/xrpl/protocol/Protocol.h
@@ -23,6 +23,8 @@
 #include <xrpl/basics/ByteUtilities.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/basics/partitioned_unordered_map.h>
+#include <xrpl/basics/safe_cast.h>
+#include <xrpl/protocol/Units.h>

 #include <cstdint>

--- a/include/xrpl/protocol/SField.h
+++ b/include/xrpl/protocol/SField.h
@@ -22,6 +22,7 @@

 #include <xrpl/basics/safe_cast.h>
 #include <xrpl/json/json_value.h>
+#include <xrpl/protocol/Units.h>

 #include <cstdint>
 #include <map>
@@ -149,7 +150,9 @@ public:
        sMD_DeleteFinal = 0x04,  // final value when it is deleted
        sMD_Create = 0x08,       // value when it's created
        sMD_Always = 0x10,  // value when node containing it is affected at all
-        sMD_BaseTen = 0x20,
+        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
        sMD_Default =
            sMD_ChangeOrig | sMD_ChangeNew | sMD_DeleteFinal | sMD_Create
    };
@@ -306,6 +309,7 @@ public:
 private:
    static int num;
    static std::map<int, SField const*> knownCodeToField;
+    static std::map<std::string, SField const*> knownNameToField;
 };

 /** A field with a type known at compile time. */
--- a/include/xrpl/protocol/STLedgerEntry.h
+++ b/include/xrpl/protocol/STLedgerEntry.h
@@ -26,7 +26,9 @@
 namespace ripple {

 class Rules;
+namespace test {
 class Invariants_test;
+}

 class STLedgerEntry final : public STObject, public CountedObject<STLedgerEntry>
 {
@@ -36,6 +38,8 @@ class STLedgerEntry final : public STObject, public CountedObject<STLedgerEntry>
 public:
    using pointer = std::shared_ptr<STLedgerEntry>;
    using ref = std::shared_ptr<STLedgerEntry> const&;
+    using const_pointer = std::shared_ptr<STLedgerEntry const>;
+    using const_ref = std::shared_ptr<STLedgerEntry const> const&;

    /** Create an empty object with the given key and type. */
    explicit STLedgerEntry(Keylet const& k);
@@ -54,7 +58,7 @@ public:
    getText() const override;

    Json::Value
-    getJson(JsonOptions options) const override;
+    getJson(JsonOptions options = JsonOptions::none) const override;

    /** Returns the 'key' (or 'index') of this item.
        The key identifies this entry's position in
@@ -84,7 +88,8 @@ private:
    void
    setSLEType();

-    friend Invariants_test;  // this test wants access to the private type_
+    friend test::Invariants_test;  // this test wants access to the private
+                                   // type_

    STBase*
    copy(std::size_t n, void* buf) const override;
--- a/include/xrpl/protocol/STObject.h
+++ b/include/xrpl/protocol/STObject.h
@@ -25,7 +25,6 @@
 #include <xrpl/basics/chrono.h>
 #include <xrpl/basics/contract.h>
 #include <xrpl/beast/utility/instrumentation.h>
-#include <xrpl/protocol/FeeUnits.h>
 #include <xrpl/protocol/HashPrefix.h>
 #include <xrpl/protocol/SOTemplate.h>
 #include <xrpl/protocol/STAmount.h>
@@ -34,6 +33,7 @@
 #include <xrpl/protocol/STIssue.h>
 #include <xrpl/protocol/STPathSet.h>
 #include <xrpl/protocol/STVector256.h>
+#include <xrpl/protocol/Units.h>
 #include <xrpl/protocol/detail/STVar.h>

 #include <boost/iterator/transform_iterator.hpp>
--- a/include/xrpl/protocol/STValidation.h
+++ b/include/xrpl/protocol/STValidation.h
@@ -22,10 +22,10 @@

 #include <xrpl/basics/Log.h>
 #include <xrpl/beast/utility/instrumentation.h>
-#include <xrpl/protocol/FeeUnits.h>
 #include <xrpl/protocol/PublicKey.h>
 #include <xrpl/protocol/STObject.h>
 #include <xrpl/protocol/SecretKey.h>
+#include <xrpl/protocol/Units.h>

 #include <cstdint>
 #include <functional>
--- a/include/xrpl/protocol/TxFlags.h
+++ b/include/xrpl/protocol/TxFlags.h
@@ -130,6 +130,8 @@ constexpr std::uint32_t tfTrustSetPermissionMask = (~tfTrustSetMask) & (~tfTrust
 // EnableAmendment flags:
 constexpr std::uint32_t tfGotMajority                      = 0x00010000;
 constexpr std::uint32_t tfLostMajority                     = 0x00020000;
+constexpr std::uint32_t tfChangeMask =
+    ~( tfUniversal | tfGotMajority | tfLostMajority);

 // PaymentChannelClaim flags:
 constexpr std::uint32_t tfRenew                            = 0x00010000;
@@ -144,7 +146,8 @@ constexpr std::uint32_t const tfTransferable               = 0x00000008;
 constexpr std::uint32_t const tfMutable                    = 0x00000010;

 // MPTokenIssuanceCreate flags:
-// NOTE - there is intentionally no flag here for lsfMPTLocked, which this transaction cannot mutate. 
+// NOTE - there is intentionally no flag here for lsfMPTLocked, which
+// this transaction cannot mutate.
 constexpr std::uint32_t const tfMPTCanLock                 = lsfMPTCanLock;
 constexpr std::uint32_t const tfMPTRequireAuth             = lsfMPTRequireAuth;
 constexpr std::uint32_t const tfMPTCanEscrow               = lsfMPTCanEscrow;
--- a/include/xrpl/protocol/TxFormats.h
+++ b/include/xrpl/protocol/TxFormats.h
@@ -59,7 +59,8 @@ enum TxType : std::uint16_t
 #pragma push_macro("TRANSACTION")
 #undef TRANSACTION

-#define TRANSACTION(tag, value, name, delegatable, fields) tag = value,
+#define TRANSACTION(tag, value, ...) \
+    tag = value,

 #include <xrpl/protocol/detail/transactions.macro>

--- a/include/xrpl/protocol/FeeUnits.h
+++ b/include/xrpl/protocol/FeeUnits.h
@@ -16,8 +16,8 @@
    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

-#ifndef BASICS_FEES_H_INCLUDED
-#define BASICS_FEES_H_INCLUDED
+#ifndef PROTOCOL_UNITS_H_INCLUDED
+#define PROTOCOL_UNITS_H_INCLUDED

 #include <xrpl/basics/safe_cast.h>
 #include <xrpl/beast/utility/Zero.h>
@@ -38,23 +38,23 @@

 namespace ripple {

-namespace feeunit {
+namespace unit {

 /** "drops" are the smallest divisible amount of XRP. This is what most
    of the code uses. */
 struct dropTag;
-/** "fee units" calculations are a not-really-unitless value that is used
-    to express the cost of a given transaction vs. a reference transaction.
-    They are primarily used by the Transactor classes. */
-struct feeunitTag;
 /** "fee levels" are used by the transaction queue to compare the relative
    cost of transactions that require different levels of effort to process.
    See also: src/ripple/app/misc/FeeEscalation.md#fee-level */
 struct feelevelTag;
-/** unitless values are plain scalars wrapped in a TaggedFee. They are
+/** unitless values are plain scalars wrapped in a ValueUnit. They are
    used for calculations in this header. */
 struct unitlessTag;

+/** Units to represent basis points (bips) and 1/10 basis points */
+class BipsTag;
+class TenthBipsTag;
+
 template <class T>
 using enable_if_unit_t = typename std::enable_if_t<
    std::is_class_v<T> && std::is_object_v<typename T::unit_type> &&
@@ -62,32 +62,33 @@ using enable_if_unit_t = typename std::enable_if_t<

 /** `is_usable_unit_v` is checked to ensure that only values with
    known valid type tags can be used (sometimes transparently) in
-    non-fee contexts. At the time of implementation, this includes
+    non-unit contexts. At the time of implementation, this includes
    all known tags, but more may be added in the future, and they
    should not be added automatically unless determined to be
    appropriate.
 */
 template <class T, class = enable_if_unit_t<T>>
 constexpr bool is_usable_unit_v =
-    std::is_same_v<typename T::unit_type, feeunitTag> ||
    std::is_same_v<typename T::unit_type, feelevelTag> ||
    std::is_same_v<typename T::unit_type, unitlessTag> ||
-    std::is_same_v<typename T::unit_type, dropTag>;
+    std::is_same_v<typename T::unit_type, dropTag> ||
+    std::is_same_v<typename T::unit_type, BipsTag> ||
+    std::is_same_v<typename T::unit_type, TenthBipsTag>;

 template <class UnitTag, class T>
-class TaggedFee : private boost::totally_ordered<TaggedFee<UnitTag, T>>,
-                  private boost::additive<TaggedFee<UnitTag, T>>,
-                  private boost::equality_comparable<TaggedFee<UnitTag, T>, T>,
-                  private boost::dividable<TaggedFee<UnitTag, T>, T>,
-                  private boost::modable<TaggedFee<UnitTag, T>, T>,
-                  private boost::unit_steppable<TaggedFee<UnitTag, T>>
+class ValueUnit : private boost::totally_ordered<ValueUnit<UnitTag, T>>,
+                  private boost::additive<ValueUnit<UnitTag, T>>,
+                  private boost::equality_comparable<ValueUnit<UnitTag, T>, T>,
+                  private boost::dividable<ValueUnit<UnitTag, T>, T>,
+                  private boost::modable<ValueUnit<UnitTag, T>, T>,
+                  private boost::unit_steppable<ValueUnit<UnitTag, T>>
 {
 public:
    using unit_type = UnitTag;
    using value_type = T;

 private:
-    value_type fee_;
+    value_type value_;

 protected:
    template <class Other>
@@ -95,44 +96,44 @@ protected:
        std::is_arithmetic_v<Other> && std::is_arithmetic_v<value_type> &&
        std::is_convertible_v<Other, value_type>;

-    template <class OtherFee, class = enable_if_unit_t<OtherFee>>
-    static constexpr bool is_compatiblefee_v =
-        is_compatible_v<typename OtherFee::value_type> &&
-        std::is_same_v<UnitTag, typename OtherFee::unit_type>;
+    template <class OtherValue, class = enable_if_unit_t<OtherValue>>
+    static constexpr bool is_compatiblevalue_v =
+        is_compatible_v<typename OtherValue::value_type> &&
+        std::is_same_v<UnitTag, typename OtherValue::unit_type>;

    template <class Other>
    using enable_if_compatible_t =
        typename std::enable_if_t<is_compatible_v<Other>>;

-    template <class OtherFee>
-    using enable_if_compatiblefee_t =
-        typename std::enable_if_t<is_compatiblefee_v<OtherFee>>;
+    template <class OtherValue>
+    using enable_if_compatiblevalue_t =
+        typename std::enable_if_t<is_compatiblevalue_v<OtherValue>>;

 public:
-    TaggedFee() = default;
-    constexpr TaggedFee(TaggedFee const& other) = default;
-    constexpr TaggedFee&
-    operator=(TaggedFee const& other) = default;
+    ValueUnit() = default;
+    constexpr ValueUnit(ValueUnit const& other) = default;
+    constexpr ValueUnit&
+    operator=(ValueUnit const& other) = default;

-    constexpr explicit TaggedFee(beast::Zero) : fee_(0)
+    constexpr explicit ValueUnit(beast::Zero) : value_(0)
    {
    }

-    constexpr TaggedFee&
+    constexpr ValueUnit&
    operator=(beast::Zero)
    {
-        fee_ = 0;
+        value_ = 0;
        return *this;
    }

-    constexpr explicit TaggedFee(value_type fee) : fee_(fee)
+    constexpr explicit ValueUnit(value_type value) : value_(value)
    {
    }

-    TaggedFee&
-    operator=(value_type fee)
+    constexpr ValueUnit&
+    operator=(value_type value)
    {
-        fee_ = fee;
+        value_ = value;
        return *this;
    }

@@ -144,153 +145,181 @@ public:
        class = std::enable_if_t<
            is_compatible_v<Other> &&
            is_safetocasttovalue_v<value_type, Other>>>
-    constexpr TaggedFee(TaggedFee<unit_type, Other> const& fee)
-        : TaggedFee(safe_cast<value_type>(fee.fee()))
+    constexpr ValueUnit(ValueUnit<unit_type, Other> const& value)
+        : ValueUnit(safe_cast<value_type>(value.value()))
    {
    }

-    constexpr TaggedFee
+    constexpr ValueUnit
+    operator+(value_type const& rhs) const
+    {
+        return ValueUnit{value_ + rhs};
+    }
+
+    friend constexpr ValueUnit
+    operator+(value_type lhs, ValueUnit const& rhs)
+    {
+        // addition is commutative
+        return rhs + lhs;
+    }
+
+    constexpr ValueUnit
+    operator-(value_type const& rhs) const
+    {
+        return ValueUnit{value_ - rhs};
+    }
+
+    friend constexpr ValueUnit
+    operator-(value_type lhs, ValueUnit const& rhs)
+    {
+        // subtraction is NOT commutative, but (lhs + (-rhs)) is addition, which
+        // is
+        return -rhs + lhs;
+    }
+
+    constexpr ValueUnit
    operator*(value_type const& rhs) const
    {
-        return TaggedFee{fee_ * rhs};
+        return ValueUnit{value_ * rhs};
    }

-    friend constexpr TaggedFee
-    operator*(value_type lhs, TaggedFee const& rhs)
+    friend constexpr ValueUnit
+    operator*(value_type lhs, ValueUnit const& rhs)
    {
        // multiplication is commutative
        return rhs * lhs;
    }

    constexpr value_type
-    operator/(TaggedFee const& rhs) const
+    operator/(ValueUnit const& rhs) const
    {
-        return fee_ / rhs.fee_;
+        return value_ / rhs.value_;
    }

-    TaggedFee&
-    operator+=(TaggedFee const& other)
+    ValueUnit&
+    operator+=(ValueUnit const& other)
    {
-        fee_ += other.fee();
+        value_ += other.value();
        return *this;
    }

-    TaggedFee&
-    operator-=(TaggedFee const& other)
+    ValueUnit&
+    operator-=(ValueUnit const& other)
    {
-        fee_ -= other.fee();
+        value_ -= other.value();
        return *this;
    }

-    TaggedFee&
+    ValueUnit&
    operator++()
    {
-        ++fee_;
+        ++value_;
        return *this;
    }

-    TaggedFee&
+    ValueUnit&
    operator--()
    {
-        --fee_;
+        --value_;
        return *this;
    }

-    TaggedFee&
+    ValueUnit&
    operator*=(value_type const& rhs)
    {
-        fee_ *= rhs;
+        value_ *= rhs;
        return *this;
    }

-    TaggedFee&
+    ValueUnit&
    operator/=(value_type const& rhs)
    {
-        fee_ /= rhs;
+        value_ /= rhs;
        return *this;
    }

    template <class transparent = value_type>
-    std::enable_if_t<std::is_integral_v<transparent>, TaggedFee&>
+    std::enable_if_t<std::is_integral_v<transparent>, ValueUnit&>
    operator%=(value_type const& rhs)
    {
-        fee_ %= rhs;
+        value_ %= rhs;
        return *this;
    }

-    TaggedFee
+    ValueUnit
    operator-() const
    {
        static_assert(
-            std::is_signed_v<T>, "- operator illegal on unsigned fee types");
-        return TaggedFee{-fee_};
+            std::is_signed_v<T>, "- operator illegal on unsigned value types");
+        return ValueUnit{-value_};
    }

-    bool
-    operator==(TaggedFee const& other) const
+    constexpr bool
+    operator==(ValueUnit const& other) const
    {
-        return fee_ == other.fee_;
+        return value_ == other.value_;
    }

    template <class Other, class = enable_if_compatible_t<Other>>
-    bool
-    operator==(TaggedFee<unit_type, Other> const& other) const
+    constexpr bool
+    operator==(ValueUnit<unit_type, Other> const& other) const
    {
-        return fee_ == other.fee();
+        return value_ == other.value();
    }

-    bool
+    constexpr bool
    operator==(value_type other) const
    {
-        return fee_ == other;
+        return value_ == other;
    }

    template <class Other, class = enable_if_compatible_t<Other>>
-    bool
-    operator!=(TaggedFee<unit_type, Other> const& other) const
+    constexpr bool
+    operator!=(ValueUnit<unit_type, Other> const& other) const
    {
        return !operator==(other);
    }

-    bool
-    operator<(TaggedFee const& other) const
+    constexpr bool
+    operator<(ValueUnit const& other) const
    {
-        return fee_ < other.fee_;
+        return value_ < other.value_;
    }

    /** Returns true if the amount is not zero */
    explicit constexpr
    operator bool() const noexcept
    {
-        return fee_ != 0;
+        return value_ != 0;
    }

    /** Return the sign of the amount */
    constexpr int
    signum() const noexcept
    {
-        return (fee_ < 0) ? -1 : (fee_ ? 1 : 0);
+        return (value_ < 0) ? -1 : (value_ ? 1 : 0);
    }

    /** Returns the number of drops */
+    // TODO: Move this to a new class, maybe with the old "TaggedFee" name
    constexpr value_type
    fee() const
    {
-        return fee_;
+        return value_;
    }

    template <class Other>
    constexpr double
-    decimalFromReference(TaggedFee<unit_type, Other> reference) const
+    decimalFromReference(ValueUnit<unit_type, Other> reference) const
    {
-        return static_cast<double>(fee_) / reference.fee();
+        return static_cast<double>(value_) / reference.value();
    }

    // `is_usable_unit_v` is checked to ensure that only values with
    // known valid type tags can be converted to JSON. At the time
    // of implementation, that includes all known tags, but more may
    // be added in the future.
-    std::enable_if_t<is_usable_unit_v<TaggedFee>, Json::Value>
+    std::enable_if_t<is_usable_unit_v<ValueUnit>, Json::Value>
    jsonClipped() const
    {
        if constexpr (std::is_integral_v<value_type>)
@@ -303,15 +332,15 @@ public:
            constexpr auto min = std::numeric_limits<jsontype>::min();
            constexpr auto max = std::numeric_limits<jsontype>::max();

-            if (fee_ < min)
+            if (value_ < min)
                return min;
-            if (fee_ > max)
+            if (value_ > max)
                return max;
-            return static_cast<jsontype>(fee_);
+            return static_cast<jsontype>(value_);
        }
        else
        {
-            return fee_;
+            return value_;
        }
    }

@@ -322,30 +351,30 @@ public:
    constexpr value_type
    value() const
    {
-        return fee_;
+        return value_;
    }

    friend std::istream&
-    operator>>(std::istream& s, TaggedFee& val)
+    operator>>(std::istream& s, ValueUnit& val)
    {
-        s >> val.fee_;
+        s >> val.value_;
        return s;
    }
 };

-// Output Fees as just their numeric value.
+// Output Values as just their numeric value.
 template <class Char, class Traits, class UnitTag, class T>
 std::basic_ostream<Char, Traits>&
-operator<<(std::basic_ostream<Char, Traits>& os, TaggedFee<UnitTag, T> const& q)
+operator<<(std::basic_ostream<Char, Traits>& os, ValueUnit<UnitTag, T> const& q)
 {
    return os << q.value();
 }

 template <class UnitTag, class T>
 std::string
-to_string(TaggedFee<UnitTag, T> const& amount)
+to_string(ValueUnit<UnitTag, T> const& amount)
 {
-    return std::to_string(amount.fee());
+    return std::to_string(amount.value());
 }

 template <class Source, class = enable_if_unit_t<Source>>
@@ -408,10 +437,10 @@ using enable_muldiv_commute_t =
    typename std::enable_if_t<can_muldiv_commute_v<Source1, Source2, Dest>>;

 template <class T>
-TaggedFee<unitlessTag, T>
+ValueUnit<unitlessTag, T>
 scalar(T value)
 {
-    return TaggedFee<unitlessTag, T>{value};
+    return ValueUnit<unitlessTag, T>{value};
 }

 template <
@@ -422,18 +451,17 @@ template <
 std::optional<Dest>
 mulDivU(Source1 value, Dest mul, Source2 div)
 {
-    // Fees can never be negative in any context.
+    // values can never be negative in any context.
    if (value.value() < 0 || mul.value() < 0 || div.value() < 0)
    {
        // split the asserts so if one hits, the user can tell which
        // without a debugger.
        XRPL_ASSERT(
-            value.value() >= 0,
-            "ripple::feeunit::mulDivU : minimum value input");
+            value.value() >= 0, "ripple::unit::mulDivU : minimum value input");
        XRPL_ASSERT(
-            mul.value() >= 0, "ripple::feeunit::mulDivU : minimum mul input");
+            mul.value() >= 0, "ripple::unit::mulDivU : minimum mul input");
        XRPL_ASSERT(
-            div.value() >= 0, "ripple::feeunit::mulDivU : minimum div input");
+            div.value() >= 0, "ripple::unit::mulDivU : minimum div input");
        return std::nullopt;
    }

@@ -466,46 +494,57 @@ mulDivU(Source1 value, Dest mul, Source2 div)
    return Dest{static_cast<desttype>(quotient)};
 }

-}  // namespace feeunit
+}  // namespace unit

+// Fee Levels
 template <class T>
-using FeeLevel = feeunit::TaggedFee<feeunit::feelevelTag, T>;
+using FeeLevel = unit::ValueUnit<unit::feelevelTag, T>;
 using FeeLevel64 = FeeLevel<std::uint64_t>;
 using FeeLevelDouble = FeeLevel<double>;

+// Basis points (Bips)
+template <class T>
+using Bips = unit::ValueUnit<unit::BipsTag, T>;
+using Bips16 = Bips<std::uint16_t>;
+using Bips32 = Bips<std::uint32_t>;
+template <class T>
+using TenthBips = unit::ValueUnit<unit::TenthBipsTag, T>;
+using TenthBips16 = TenthBips<std::uint16_t>;
+using TenthBips32 = TenthBips<std::uint32_t>;
+
 template <
    class Source1,
    class Source2,
    class Dest,
-    class = feeunit::enable_muldiv_t<Source1, Source2, Dest>>
+    class = unit::enable_muldiv_t<Source1, Source2, Dest>>
 std::optional<Dest>
 mulDiv(Source1 value, Dest mul, Source2 div)
 {
-    return feeunit::mulDivU(value, mul, div);
+    return unit::mulDivU(value, mul, div);
 }

 template <
    class Source1,
    class Source2,
    class Dest,
-    class = feeunit::enable_muldiv_commute_t<Source1, Source2, Dest>>
+    class = unit::enable_muldiv_commute_t<Source1, Source2, Dest>>
 std::optional<Dest>
 mulDiv(Dest value, Source1 mul, Source2 div)
 {
    // Multiplication is commutative
-    return feeunit::mulDivU(mul, value, div);
+    return unit::mulDivU(mul, value, div);
 }

-template <class Dest, class = feeunit::enable_muldiv_dest_t<Dest>>
+template <class Dest, class = unit::enable_muldiv_dest_t<Dest>>
 std::optional<Dest>
 mulDiv(std::uint64_t value, Dest mul, std::uint64_t div)
 {
    // Give the scalars a non-tag so the
    // unit-handling version gets called.
-    return feeunit::mulDivU(feeunit::scalar(value), mul, feeunit::scalar(div));
+    return unit::mulDivU(unit::scalar(value), mul, unit::scalar(div));
 }

-template <class Dest, class = feeunit::enable_muldiv_dest_t<Dest>>
+template <class Dest, class = unit::enable_muldiv_dest_t<Dest>>
 std::optional<Dest>
 mulDiv(Dest value, std::uint64_t mul, std::uint64_t div)
 {
@@ -516,13 +555,13 @@ mulDiv(Dest value, std::uint64_t mul, std::uint64_t div)
 template <
    class Source1,
    class Source2,
-    class = feeunit::enable_muldiv_sources_t<Source1, Source2>>
+    class = unit::enable_muldiv_sources_t<Source1, Source2>>
 std::optional<std::uint64_t>
 mulDiv(Source1 value, std::uint64_t mul, Source2 div)
 {
    // Give the scalars a dimensionless unit so the
    // unit-handling version gets called.
-    auto unitresult = feeunit::mulDivU(value, feeunit::scalar(mul), div);
+    auto unitresult = unit::mulDivU(value, unit::scalar(mul), div);

    if (!unitresult)
        return std::nullopt;
@@ -533,7 +572,7 @@ mulDiv(Source1 value, std::uint64_t mul, Source2 div)
 template <
    class Source1,
    class Source2,
-    class = feeunit::enable_muldiv_sources_t<Source1, Source2>>
+    class = unit::enable_muldiv_sources_t<Source1, Source2>>
 std::optional<std::uint64_t>
 mulDiv(std::uint64_t value, Source1 mul, Source2 div)
 {
@@ -553,6 +592,16 @@ safe_cast(Src s) noexcept
    return Dest{safe_cast<typename Dest::value_type>(s.value())};
 }

+template <class Dest, class Src>
+constexpr std::enable_if_t<
+    std::is_integral_v<typename Dest::value_type> && std::is_integral_v<Src>,
+    Dest>
+safe_cast(Src s) noexcept
+{
+    // Dest may not have an explicit value constructor
+    return Dest{safe_cast<typename Dest::value_type>(s)};
+}
+
 template <class Dest, class Src>
 constexpr std::enable_if_t<
    std::is_same_v<typename Dest::unit_type, typename Src::unit_type> &&
@@ -565,6 +614,16 @@ unsafe_cast(Src s) noexcept
    return Dest{unsafe_cast<typename Dest::value_type>(s.value())};
 }

+template <class Dest, class Src>
+constexpr std::enable_if_t<
+    std::is_integral_v<typename Dest::value_type> && std::is_integral_v<Src>,
+    Dest>
+unsafe_cast(Src s) noexcept
+{
+    // Dest may not have an explicit value constructor
+    return Dest{unsafe_cast<typename Dest::value_type>(s)};
+}
+
 }  // namespace ripple

-#endif  // BASICS_FEES_H_INCLUDED
+#endif  // PROTOCOL_UNITS_H_INCLUDED
--- a/include/xrpl/protocol/XRPAmount.h
+++ b/include/xrpl/protocol/XRPAmount.h
@@ -24,7 +24,7 @@
 #include <xrpl/basics/contract.h>
 #include <xrpl/beast/utility/Zero.h>
 #include <xrpl/json/json_value.h>
-#include <xrpl/protocol/FeeUnits.h>
+#include <xrpl/protocol/Units.h>

 #include <boost/multiprecision/cpp_int.hpp>
 #include <boost/operators.hpp>
@@ -42,7 +42,7 @@ class XRPAmount : private boost::totally_ordered<XRPAmount>,
                  private boost::additive<XRPAmount, std::int64_t>
 {
 public:
-    using unit_type = feeunit::dropTag;
+    using unit_type = unit::dropTag;
    using value_type = std::int64_t;

 private:
--- a/include/xrpl/protocol/detail/sfields.macro
+++ b/include/xrpl/protocol/detail/sfields.macro
@@ -172,7 +172,8 @@ TYPED_SFIELD(sfNFTokenID,                UINT256,   10)
 TYPED_SFIELD(sfEmitParentTxnID,          UINT256,   11)
 TYPED_SFIELD(sfEmitNonce,                UINT256,   12)
 TYPED_SFIELD(sfEmitHookHash,             UINT256,   13)
-TYPED_SFIELD(sfAMMID,                    UINT256,   14)
+TYPED_SFIELD(sfAMMID,                    UINT256,   14,
+    SField::sMD_PseudoAccount |SField::sMD_Default)

 // 256-bit (uncommon)
 TYPED_SFIELD(sfBookDirectory,            UINT256,   16)
@@ -194,7 +195,8 @@ TYPED_SFIELD(sfHookHash,                 UINT256,   31)
 TYPED_SFIELD(sfHookNamespace,            UINT256,   32)
 TYPED_SFIELD(sfHookSetTxnID,             UINT256,   33)
 TYPED_SFIELD(sfDomainID,                 UINT256,   34)
-TYPED_SFIELD(sfVaultID,                  UINT256,   35)
+TYPED_SFIELD(sfVaultID,                  UINT256,   35,
+    SField::sMD_PseudoAccount | SField::sMD_Default)

 // number (common)
 TYPED_SFIELD(sfNumber,                   NUMBER,     1)
--- a/include/xrpl/protocol/detail/transactions.macro
+++ b/include/xrpl/protocol/detail/transactions.macro
@@ -22,14 +22,47 @@
 #endif

 /**
- * TRANSACTION(tag, value, name, delegatable, fields)
+ * TRANSACTION(tag, value, name, delegatable, privileges, fields)
+ *
+ * To ease maintenance, you may replace any unneeded values with "..."
+ * e.g. #define TRANSACTION(tag, value, name, ...)
 *
 * You must define a transactor class in the `ripple` namespace named `name`,
- * and include its header in `src/xrpld/app/tx/detail/applySteps.cpp`.
+ * and include its header alongside the TRANSACTOR definition using this
+ * format:
+ * #if TRANSACTION_INCLUDE
+ * #   include <xrpld/app/tx/detail/HEADER.h>
+ * #endif
+ *
+ * The `privileges` parameter of the TRANSACTION macro is a bitfield
+ * defining which operations the transaction can perform.
+ *
+ * The values are only used in InvariantCheck.cpp
+ * Valid values are
+    noPriv - The transaction can not do any of the enumerated operations
+    createAcct - The transaction can create a new ACCOUNT_ROOT object.
+    createPseudoAcct - The transaction can create a pseudo account,
+        which implies createAcct
+    mustDeleteAcct - The transaction must delete an ACCOUNT_ROOT object
+    mayDeleteAcct - The transaction may delete an ACCOUNT_ROOT object,
+        but does not have to
+    overrideFreeze - The transaction can override some freeze rules
+    changeNFTCounts - The transaction can mint or burn an NFT
+    createMPTIssuance - The transaction can create a new MPT issuance
+    destroyMPTIssuance - The transaction can destroy an MPT issuance
+    mustAuthorizeMPT - The transaction MUST create or delete an MPT
+        object (except by issuer)
+    mayAuthorizeMPT - The transaction MAY create or delete an MPT
+        object (except by issuer)
 */

 /** This transaction type executes a payment. */
-TRANSACTION(ttPAYMENT, 0, Payment, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/Payment.h>
+#endif
+TRANSACTION(ttPAYMENT, 0, Payment,
+    Delegation::delegatable,
+    createAcct, ({
    {sfDestination, soeREQUIRED},
    {sfAmount, soeREQUIRED, soeMPTSupported},
    {sfSendMax, soeOPTIONAL, soeMPTSupported},
@@ -41,7 +74,12 @@ TRANSACTION(ttPAYMENT, 0, Payment, Delegation::delegatable, ({
 }))

 /** This transaction type creates an escrow object. */
-TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/Escrow.h>
+#endif
+TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate,
+    Delegation::delegatable,
+    noPriv, ({
    {sfDestination, soeREQUIRED},
    {sfAmount, soeREQUIRED},
    {sfCondition, soeOPTIONAL},
@@ -51,7 +89,9 @@ TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate, Delegation::delegatable, ({
 }))

 /** This transaction type completes an existing escrow. */
-TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish, Delegation::delegatable, ({
+TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish,
+    Delegation::delegatable,
+    noPriv, ({
    {sfOwner, soeREQUIRED},
    {sfOfferSequence, soeREQUIRED},
    {sfFulfillment, soeOPTIONAL},
@@ -61,7 +101,12 @@ TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish, Delegation::delegatable, ({


 /** This transaction type adjusts various account settings. */
-TRANSACTION(ttACCOUNT_SET, 3, AccountSet, Delegation::notDelegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/SetAccount.h>
+#endif
+TRANSACTION(ttACCOUNT_SET, 3, AccountSet,
+    Delegation::notDelegatable,
+    noPriv, ({
    {sfEmailHash, soeOPTIONAL},
    {sfWalletLocator, soeOPTIONAL},
    {sfWalletSize, soeOPTIONAL},
@@ -75,20 +120,35 @@ TRANSACTION(ttACCOUNT_SET, 3, AccountSet, Delegation::notDelegatable, ({
 }))

 /** This transaction type cancels an existing escrow. */
-TRANSACTION(ttESCROW_CANCEL, 4, EscrowCancel, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/Escrow.h>
+#endif
+TRANSACTION(ttESCROW_CANCEL, 4, EscrowCancel,
+    Delegation::delegatable,
+    noPriv, ({
    {sfOwner, soeREQUIRED},
    {sfOfferSequence, soeREQUIRED},
 }))

 /** This transaction type sets or clears an account's "regular key". */
-TRANSACTION(ttREGULAR_KEY_SET, 5, SetRegularKey, Delegation::notDelegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/SetRegularKey.h>
+#endif
+TRANSACTION(ttREGULAR_KEY_SET, 5, SetRegularKey,
+    Delegation::notDelegatable,
+    noPriv, ({
    {sfRegularKey, soeOPTIONAL},
 }))

 // 6 deprecated

 /** This transaction type creates an offer to trade one asset for another. */
-TRANSACTION(ttOFFER_CREATE, 7, OfferCreate, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/CreateOffer.h>
+#endif
+TRANSACTION(ttOFFER_CREATE, 7, OfferCreate,
+    Delegation::delegatable,
+    noPriv, ({
    {sfTakerPays, soeREQUIRED},
    {sfTakerGets, soeREQUIRED},
    {sfExpiration, soeOPTIONAL},
@@ -96,14 +156,24 @@ TRANSACTION(ttOFFER_CREATE, 7, OfferCreate, Delegation::delegatable, ({
 }))

 /** This transaction type cancels existing offers to trade one asset for another. */
-TRANSACTION(ttOFFER_CANCEL, 8, OfferCancel, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/CancelOffer.h>
+#endif
+TRANSACTION(ttOFFER_CANCEL, 8, OfferCancel,
+    Delegation::delegatable,
+    noPriv, ({
    {sfOfferSequence, soeREQUIRED},
 }))

 // 9 deprecated

 /** This transaction type creates a new set of tickets. */
-TRANSACTION(ttTICKET_CREATE, 10, TicketCreate, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/CreateTicket.h>
+#endif
+TRANSACTION(ttTICKET_CREATE, 10, TicketCreate,
+    Delegation::delegatable,
+    noPriv, ({
    {sfTicketCount, soeREQUIRED},
 }))

@@ -112,13 +182,23 @@ TRANSACTION(ttTICKET_CREATE, 10, TicketCreate, Delegation::delegatable, ({
 /** This transaction type modifies the signer list associated with an account. */
 // The SignerEntries are optional because a SignerList is deleted by
 // setting the SignerQuorum to zero and omitting SignerEntries.
-TRANSACTION(ttSIGNER_LIST_SET, 12, SignerListSet, Delegation::notDelegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/SetSignerList.h>
+#endif
+TRANSACTION(ttSIGNER_LIST_SET, 12, SignerListSet,
+    Delegation::notDelegatable,
+    noPriv, ({
    {sfSignerQuorum, soeREQUIRED},
    {sfSignerEntries, soeOPTIONAL},
 }))

 /** This transaction type creates a new unidirectional XRP payment channel. */
-TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/PayChan.h>
+#endif
+TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate,
+    Delegation::delegatable,
+    noPriv, ({
    {sfDestination, soeREQUIRED},
    {sfAmount, soeREQUIRED},
    {sfSettleDelay, soeREQUIRED},
@@ -128,14 +208,18 @@ TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate, Delegation::delegatable,
 }))

 /** This transaction type funds an existing unidirectional XRP payment channel. */
-TRANSACTION(ttPAYCHAN_FUND, 14, PaymentChannelFund, Delegation::delegatable, ({
+TRANSACTION(ttPAYCHAN_FUND, 14, PaymentChannelFund,
+    Delegation::delegatable,
+    noPriv, ({
    {sfChannel, soeREQUIRED},
    {sfAmount, soeREQUIRED},
    {sfExpiration, soeOPTIONAL},
 }))

 /** This transaction type submits a claim against an existing unidirectional payment channel. */
-TRANSACTION(ttPAYCHAN_CLAIM, 15, PaymentChannelClaim, Delegation::delegatable, ({
+TRANSACTION(ttPAYCHAN_CLAIM, 15, PaymentChannelClaim,
+    Delegation::delegatable,
+    noPriv, ({
    {sfChannel, soeREQUIRED},
    {sfAmount, soeOPTIONAL},
    {sfBalance, soeOPTIONAL},
@@ -145,7 +229,12 @@ TRANSACTION(ttPAYCHAN_CLAIM, 15, PaymentChannelClaim, Delegation::delegatable, (
 }))

 /** This transaction type creates a new check. */
-TRANSACTION(ttCHECK_CREATE, 16, CheckCreate, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/CreateCheck.h>
+#endif
+TRANSACTION(ttCHECK_CREATE, 16, CheckCreate,
+    Delegation::delegatable,
+    noPriv, ({
    {sfDestination, soeREQUIRED},
    {sfSendMax, soeREQUIRED},
    {sfExpiration, soeOPTIONAL},
@@ -154,19 +243,34 @@ TRANSACTION(ttCHECK_CREATE, 16, CheckCreate, Delegation::delegatable, ({
 }))

 /** This transaction type cashes an existing check. */
-TRANSACTION(ttCHECK_CASH, 17, CheckCash, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/CashCheck.h>
+#endif
+TRANSACTION(ttCHECK_CASH, 17, CheckCash,
+    Delegation::delegatable,
+    noPriv, ({
    {sfCheckID, soeREQUIRED},
    {sfAmount, soeOPTIONAL},
    {sfDeliverMin, soeOPTIONAL},
 }))

 /** This transaction type cancels an existing check. */
-TRANSACTION(ttCHECK_CANCEL, 18, CheckCancel, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/CancelCheck.h>
+#endif
+TRANSACTION(ttCHECK_CANCEL, 18, CheckCancel,
+    Delegation::delegatable,
+    noPriv, ({
    {sfCheckID, soeREQUIRED},
 }))

 /** This transaction type grants or revokes authorization to transfer funds. */
-TRANSACTION(ttDEPOSIT_PREAUTH, 19, DepositPreauth, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/DepositPreauth.h>
+#endif
+TRANSACTION(ttDEPOSIT_PREAUTH, 19, DepositPreauth,
+    Delegation::delegatable,
+    noPriv, ({
    {sfAuthorize, soeOPTIONAL},
    {sfUnauthorize, soeOPTIONAL},
    {sfAuthorizeCredentials, soeOPTIONAL},
@@ -174,14 +278,24 @@ TRANSACTION(ttDEPOSIT_PREAUTH, 19, DepositPreauth, Delegation::delegatable, ({
 }))

 /** This transaction type modifies a trustline between two accounts. */
-TRANSACTION(ttTRUST_SET, 20, TrustSet, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/SetTrust.h>
+#endif
+TRANSACTION(ttTRUST_SET, 20, TrustSet,
+    Delegation::delegatable,
+    noPriv, ({
    {sfLimitAmount, soeOPTIONAL},
    {sfQualityIn, soeOPTIONAL},
    {sfQualityOut, soeOPTIONAL},
 }))

 /** This transaction type deletes an existing account. */
-TRANSACTION(ttACCOUNT_DELETE, 21, AccountDelete, Delegation::notDelegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/DeleteAccount.h>
+#endif
+TRANSACTION(ttACCOUNT_DELETE, 21, AccountDelete,
+    Delegation::notDelegatable,
+    mustDeleteAcct, ({
    {sfDestination, soeREQUIRED},
    {sfDestinationTag, soeOPTIONAL},
    {sfCredentialIDs, soeOPTIONAL},
@@ -190,7 +304,12 @@ TRANSACTION(ttACCOUNT_DELETE, 21, AccountDelete, Delegation::notDelegatable, ({
 // 22 reserved

 /** This transaction mints a new NFT. */
-TRANSACTION(ttNFTOKEN_MINT, 25, NFTokenMint, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/NFTokenMint.h>
+#endif
+TRANSACTION(ttNFTOKEN_MINT, 25, NFTokenMint,
+    Delegation::delegatable,
+    changeNFTCounts, ({
    {sfNFTokenTaxon, soeREQUIRED},
    {sfTransferFee, soeOPTIONAL},
    {sfIssuer, soeOPTIONAL},
@@ -201,13 +320,23 @@ TRANSACTION(ttNFTOKEN_MINT, 25, NFTokenMint, Delegation::delegatable, ({
 }))

 /** This transaction burns (i.e. destroys) an existing NFT. */
-TRANSACTION(ttNFTOKEN_BURN, 26, NFTokenBurn, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/NFTokenBurn.h>
+#endif
+TRANSACTION(ttNFTOKEN_BURN, 26, NFTokenBurn,
+    Delegation::delegatable,
+    changeNFTCounts, ({
    {sfNFTokenID, soeREQUIRED},
    {sfOwner, soeOPTIONAL},
 }))

 /** This transaction creates a new offer to buy or sell an NFT. */
-TRANSACTION(ttNFTOKEN_CREATE_OFFER, 27, NFTokenCreateOffer, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/NFTokenCreateOffer.h>
+#endif
+TRANSACTION(ttNFTOKEN_CREATE_OFFER, 27, NFTokenCreateOffer,
+    Delegation::delegatable,
+    noPriv, ({
    {sfNFTokenID, soeREQUIRED},
    {sfAmount, soeREQUIRED},
    {sfDestination, soeOPTIONAL},
@@ -216,25 +345,45 @@ TRANSACTION(ttNFTOKEN_CREATE_OFFER, 27, NFTokenCreateOffer, Delegation::delegata
 }))

 /** This transaction cancels an existing offer to buy or sell an existing NFT. */
-TRANSACTION(ttNFTOKEN_CANCEL_OFFER, 28, NFTokenCancelOffer, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/NFTokenCancelOffer.h>
+#endif
+TRANSACTION(ttNFTOKEN_CANCEL_OFFER, 28, NFTokenCancelOffer,
+    Delegation::delegatable,
+    noPriv, ({
    {sfNFTokenOffers, soeREQUIRED},
 }))

 /** This transaction accepts an existing offer to buy or sell an existing  NFT. */
-TRANSACTION(ttNFTOKEN_ACCEPT_OFFER, 29, NFTokenAcceptOffer, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/NFTokenAcceptOffer.h>
+#endif
+TRANSACTION(ttNFTOKEN_ACCEPT_OFFER, 29, NFTokenAcceptOffer,
+    Delegation::delegatable,
+    noPriv, ({
    {sfNFTokenBuyOffer, soeOPTIONAL},
    {sfNFTokenSellOffer, soeOPTIONAL},
    {sfNFTokenBrokerFee, soeOPTIONAL},
 }))

 /** This transaction claws back issued tokens. */
-TRANSACTION(ttCLAWBACK, 30, Clawback, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/Clawback.h>
+#endif
+TRANSACTION(ttCLAWBACK, 30, Clawback,
+    Delegation::delegatable,
+    noPriv, ({
    {sfAmount, soeREQUIRED, soeMPTSupported},
    {sfHolder, soeOPTIONAL},
 }))

 /** This transaction claws back tokens from an AMM pool. */
-TRANSACTION(ttAMM_CLAWBACK, 31, AMMClawback, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/AMMClawback.h>
+#endif
+TRANSACTION(ttAMM_CLAWBACK, 31, AMMClawback,
+    Delegation::delegatable,
+    mayDeleteAcct | overrideFreeze, ({
    {sfHolder, soeREQUIRED},
    {sfAsset, soeREQUIRED},
    {sfAsset2, soeREQUIRED},
@@ -242,14 +391,24 @@ TRANSACTION(ttAMM_CLAWBACK, 31, AMMClawback, Delegation::delegatable, ({
 }))

 /** This transaction type creates an AMM instance */
-TRANSACTION(ttAMM_CREATE, 35, AMMCreate, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/AMMCreate.h>
+#endif
+TRANSACTION(ttAMM_CREATE, 35, AMMCreate,
+    Delegation::delegatable,
+    createPseudoAcct, ({
    {sfAmount, soeREQUIRED},
    {sfAmount2, soeREQUIRED},
    {sfTradingFee, soeREQUIRED},
 }))

 /** This transaction type deposits into an AMM instance */
-TRANSACTION(ttAMM_DEPOSIT, 36, AMMDeposit, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/AMMDeposit.h>
+#endif
+TRANSACTION(ttAMM_DEPOSIT, 36, AMMDeposit,
+    Delegation::delegatable,
+    noPriv, ({
    {sfAsset, soeREQUIRED},
    {sfAsset2, soeREQUIRED},
    {sfAmount, soeOPTIONAL},
@@ -260,7 +419,12 @@ TRANSACTION(ttAMM_DEPOSIT, 36, AMMDeposit, Delegation::delegatable, ({
 }))

 /** This transaction type withdraws from an AMM instance */
-TRANSACTION(ttAMM_WITHDRAW, 37, AMMWithdraw, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/AMMWithdraw.h>
+#endif
+TRANSACTION(ttAMM_WITHDRAW, 37, AMMWithdraw,
+    Delegation::delegatable,
+    mayDeleteAcct, ({
    {sfAsset, soeREQUIRED},
    {sfAsset2, soeREQUIRED},
    {sfAmount, soeOPTIONAL},
@@ -270,14 +434,24 @@ TRANSACTION(ttAMM_WITHDRAW, 37, AMMWithdraw, Delegation::delegatable, ({
 }))

 /** This transaction type votes for the trading fee */
-TRANSACTION(ttAMM_VOTE, 38, AMMVote, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/AMMVote.h>
+#endif
+TRANSACTION(ttAMM_VOTE, 38, AMMVote,
+    Delegation::delegatable,
+    noPriv, ({
    {sfAsset, soeREQUIRED},
    {sfAsset2, soeREQUIRED},
    {sfTradingFee, soeREQUIRED},
 }))

 /** This transaction type bids for the auction slot */
-TRANSACTION(ttAMM_BID, 39, AMMBid, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/AMMBid.h>
+#endif
+TRANSACTION(ttAMM_BID, 39, AMMBid,
+    Delegation::delegatable,
+    noPriv, ({
    {sfAsset, soeREQUIRED},
    {sfAsset2, soeREQUIRED},
    {sfBidMin, soeOPTIONAL},
@@ -286,20 +460,32 @@ TRANSACTION(ttAMM_BID, 39, AMMBid, Delegation::delegatable, ({
 }))

 /** This transaction type deletes AMM in the empty state */
-TRANSACTION(ttAMM_DELETE, 40, AMMDelete, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/AMMDelete.h>
+#endif
+TRANSACTION(ttAMM_DELETE, 40, AMMDelete,
+    Delegation::delegatable,
+    mustDeleteAcct, ({
    {sfAsset, soeREQUIRED},
    {sfAsset2, soeREQUIRED},
 }))

 /** This transactions creates a crosschain sequence number */
-TRANSACTION(ttXCHAIN_CREATE_CLAIM_ID, 41, XChainCreateClaimID, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/XChainBridge.h>
+#endif
+TRANSACTION(ttXCHAIN_CREATE_CLAIM_ID, 41, XChainCreateClaimID,
+    Delegation::delegatable,
+    noPriv, ({
    {sfXChainBridge, soeREQUIRED},
    {sfSignatureReward, soeREQUIRED},
    {sfOtherChainSource, soeREQUIRED},
 }))

 /** This transactions initiates a crosschain transaction */
-TRANSACTION(ttXCHAIN_COMMIT, 42, XChainCommit, Delegation::delegatable, ({
+TRANSACTION(ttXCHAIN_COMMIT, 42, XChainCommit,
+    Delegation::delegatable,
+    noPriv, ({
    {sfXChainBridge, soeREQUIRED},
    {sfXChainClaimID, soeREQUIRED},
    {sfAmount, soeREQUIRED},
@@ -307,7 +493,9 @@ TRANSACTION(ttXCHAIN_COMMIT, 42, XChainCommit, Delegation::delegatable, ({
 }))

 /** This transaction completes a crosschain transaction */
-TRANSACTION(ttXCHAIN_CLAIM, 43, XChainClaim, Delegation::delegatable, ({
+TRANSACTION(ttXCHAIN_CLAIM, 43, XChainClaim,
+    Delegation::delegatable,
+    noPriv, ({
    {sfXChainBridge, soeREQUIRED},
    {sfXChainClaimID, soeREQUIRED},
    {sfDestination, soeREQUIRED},
@@ -316,7 +504,9 @@ TRANSACTION(ttXCHAIN_CLAIM, 43, XChainClaim, Delegation::delegatable, ({
 }))

 /** This transaction initiates a crosschain account create transaction */
-TRANSACTION(ttXCHAIN_ACCOUNT_CREATE_COMMIT, 44, XChainAccountCreateCommit, Delegation::delegatable, ({
+TRANSACTION(ttXCHAIN_ACCOUNT_CREATE_COMMIT, 44, XChainAccountCreateCommit,
+    Delegation::delegatable,
+    noPriv, ({
    {sfXChainBridge, soeREQUIRED},
    {sfDestination, soeREQUIRED},
    {sfAmount, soeREQUIRED},
@@ -324,7 +514,9 @@ TRANSACTION(ttXCHAIN_ACCOUNT_CREATE_COMMIT, 44, XChainAccountCreateCommit, Deleg
 }))

 /** This transaction adds an attestation to a claim */
-TRANSACTION(ttXCHAIN_ADD_CLAIM_ATTESTATION, 45, XChainAddClaimAttestation, Delegation::delegatable, ({
+TRANSACTION(ttXCHAIN_ADD_CLAIM_ATTESTATION, 45, XChainAddClaimAttestation,
+    Delegation::delegatable,
+    createAcct, ({
    {sfXChainBridge, soeREQUIRED},

    {sfAttestationSignerAccount, soeREQUIRED},
@@ -340,7 +532,10 @@ TRANSACTION(ttXCHAIN_ADD_CLAIM_ATTESTATION, 45, XChainAddClaimAttestation, Deleg
 }))

 /** This transaction adds an attestation to an account */
-TRANSACTION(ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION, 46, XChainAddAccountCreateAttestation, Delegation::delegatable, ({
+TRANSACTION(ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION, 46,
+    XChainAddAccountCreateAttestation,
+    Delegation::delegatable,
+    createAcct, ({
    {sfXChainBridge, soeREQUIRED},

    {sfAttestationSignerAccount, soeREQUIRED},
@@ -357,31 +552,47 @@ TRANSACTION(ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION, 46, XChainAddAccountCreateA
 }))

 /** This transaction modifies a sidechain */
-TRANSACTION(ttXCHAIN_MODIFY_BRIDGE, 47, XChainModifyBridge, Delegation::delegatable, ({
+TRANSACTION(ttXCHAIN_MODIFY_BRIDGE, 47, XChainModifyBridge,
+    Delegation::delegatable,
+    noPriv, ({
    {sfXChainBridge, soeREQUIRED},
    {sfSignatureReward, soeOPTIONAL},
    {sfMinAccountCreateAmount, soeOPTIONAL},
 }))

 /** This transactions creates a sidechain */
-TRANSACTION(ttXCHAIN_CREATE_BRIDGE, 48, XChainCreateBridge, Delegation::delegatable, ({
+TRANSACTION(ttXCHAIN_CREATE_BRIDGE, 48, XChainCreateBridge,
+    Delegation::delegatable,
+    noPriv, ({
    {sfXChainBridge, soeREQUIRED},
    {sfSignatureReward, soeREQUIRED},
    {sfMinAccountCreateAmount, soeOPTIONAL},
 }))

 /** This transaction type creates or updates a DID */
-TRANSACTION(ttDID_SET, 49, DIDSet, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/DID.h>
+#endif
+TRANSACTION(ttDID_SET, 49, DIDSet,
+    Delegation::delegatable,
+    noPriv, ({
    {sfDIDDocument, soeOPTIONAL},
    {sfURI, soeOPTIONAL},
    {sfData, soeOPTIONAL},
 }))

 /** This transaction type deletes a DID */
-TRANSACTION(ttDID_DELETE, 50, DIDDelete, Delegation::delegatable, ({}))
+TRANSACTION(ttDID_DELETE, 50, DIDDelete,
+    Delegation::delegatable,
+    noPriv, ({}))

 /** This transaction type creates an Oracle instance */
-TRANSACTION(ttORACLE_SET, 51, OracleSet, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/SetOracle.h>
+#endif
+TRANSACTION(ttORACLE_SET, 51, OracleSet,
+    Delegation::delegatable,
+    noPriv, ({
    {sfOracleDocumentID, soeREQUIRED},
    {sfProvider, soeOPTIONAL},
    {sfURI, soeOPTIONAL},
@@ -391,18 +602,33 @@ TRANSACTION(ttORACLE_SET, 51, OracleSet, Delegation::delegatable, ({
 }))

 /** This transaction type deletes an Oracle instance */
-TRANSACTION(ttORACLE_DELETE, 52, OracleDelete, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/DeleteOracle.h>
+#endif
+TRANSACTION(ttORACLE_DELETE, 52, OracleDelete,
+    Delegation::delegatable,
+    noPriv, ({
    {sfOracleDocumentID, soeREQUIRED},
 }))

 /** This transaction type fixes a problem in the ledger state */
-TRANSACTION(ttLEDGER_STATE_FIX, 53, LedgerStateFix, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/LedgerStateFix.h>
+#endif
+TRANSACTION(ttLEDGER_STATE_FIX, 53, LedgerStateFix,
+    Delegation::delegatable,
+    noPriv, ({
    {sfLedgerFixType, soeREQUIRED},
    {sfOwner, soeOPTIONAL},
 }))

 /** This transaction type creates a MPTokensIssuance instance */
-TRANSACTION(ttMPTOKEN_ISSUANCE_CREATE, 54, MPTokenIssuanceCreate, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/MPTokenIssuanceCreate.h>
+#endif
+TRANSACTION(ttMPTOKEN_ISSUANCE_CREATE, 54, MPTokenIssuanceCreate,
+    Delegation::delegatable,
+    createMPTIssuance, ({
    {sfAssetScale, soeOPTIONAL},
    {sfTransferFee, soeOPTIONAL},
    {sfMaximumAmount, soeOPTIONAL},
@@ -410,24 +636,44 @@ TRANSACTION(ttMPTOKEN_ISSUANCE_CREATE, 54, MPTokenIssuanceCreate, Delegation::de
 }))

 /** This transaction type destroys a MPTokensIssuance instance */
-TRANSACTION(ttMPTOKEN_ISSUANCE_DESTROY, 55, MPTokenIssuanceDestroy, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/MPTokenIssuanceDestroy.h>
+#endif
+TRANSACTION(ttMPTOKEN_ISSUANCE_DESTROY, 55, MPTokenIssuanceDestroy,
+    Delegation::delegatable,
+    destroyMPTIssuance, ({
    {sfMPTokenIssuanceID, soeREQUIRED},
 }))

 /** This transaction type sets flags on a MPTokensIssuance or MPToken instance */
-TRANSACTION(ttMPTOKEN_ISSUANCE_SET, 56, MPTokenIssuanceSet, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/MPTokenIssuanceSet.h>
+#endif
+TRANSACTION(ttMPTOKEN_ISSUANCE_SET, 56, MPTokenIssuanceSet,
+    Delegation::delegatable,
+    noPriv, ({
    {sfMPTokenIssuanceID, soeREQUIRED},
    {sfHolder, soeOPTIONAL},
 }))

 /** This transaction type authorizes a MPToken instance */
-TRANSACTION(ttMPTOKEN_AUTHORIZE, 57, MPTokenAuthorize, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/MPTokenAuthorize.h>
+#endif
+TRANSACTION(ttMPTOKEN_AUTHORIZE, 57, MPTokenAuthorize,
+    Delegation::delegatable,
+    mustAuthorizeMPT, ({
    {sfMPTokenIssuanceID, soeREQUIRED},
    {sfHolder, soeOPTIONAL},
 }))

 /** This transaction type create an Credential instance */
-TRANSACTION(ttCREDENTIAL_CREATE, 58, CredentialCreate, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/Credentials.h>
+#endif
+TRANSACTION(ttCREDENTIAL_CREATE, 58, CredentialCreate,
+    Delegation::delegatable,
+    noPriv, ({
    {sfSubject, soeREQUIRED},
    {sfCredentialType, soeREQUIRED},
    {sfExpiration, soeOPTIONAL},
@@ -435,44 +681,73 @@ TRANSACTION(ttCREDENTIAL_CREATE, 58, CredentialCreate, Delegation::delegatable,
 }))

 /** This transaction type accept an Credential object */
-TRANSACTION(ttCREDENTIAL_ACCEPT, 59, CredentialAccept, Delegation::delegatable, ({
+TRANSACTION(ttCREDENTIAL_ACCEPT, 59, CredentialAccept,
+    Delegation::delegatable,
+    noPriv, ({
    {sfIssuer, soeREQUIRED},
    {sfCredentialType, soeREQUIRED},
 }))

 /** This transaction type delete an Credential object */
-TRANSACTION(ttCREDENTIAL_DELETE, 60, CredentialDelete, Delegation::delegatable, ({
+TRANSACTION(ttCREDENTIAL_DELETE, 60, CredentialDelete,
+    Delegation::delegatable,
+    noPriv, ({
    {sfSubject, soeOPTIONAL},
    {sfIssuer, soeOPTIONAL},
    {sfCredentialType, soeREQUIRED},
 }))

 /** This transaction type modify a NFToken */
-TRANSACTION(ttNFTOKEN_MODIFY, 61, NFTokenModify, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/NFTokenModify.h>
+#endif
+TRANSACTION(ttNFTOKEN_MODIFY, 61, NFTokenModify,
+    Delegation::delegatable,
+    noPriv, ({
    {sfNFTokenID, soeREQUIRED},
    {sfOwner, soeOPTIONAL},
    {sfURI, soeOPTIONAL},
 }))

 /** This transaction type creates or modifies a Permissioned Domain */
-TRANSACTION(ttPERMISSIONED_DOMAIN_SET, 62, PermissionedDomainSet, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/PermissionedDomainSet.h>
+#endif
+TRANSACTION(ttPERMISSIONED_DOMAIN_SET, 62, PermissionedDomainSet,
+    Delegation::delegatable,
+    noPriv, ({
    {sfDomainID, soeOPTIONAL},
    {sfAcceptedCredentials, soeREQUIRED},
 }))

 /** This transaction type deletes a Permissioned Domain */
-TRANSACTION(ttPERMISSIONED_DOMAIN_DELETE, 63, PermissionedDomainDelete, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/PermissionedDomainDelete.h>
+#endif
+TRANSACTION(ttPERMISSIONED_DOMAIN_DELETE, 63, PermissionedDomainDelete,
+    Delegation::delegatable,
+    noPriv, ({
    {sfDomainID, soeREQUIRED},
 }))

 /** This transaction type delegates authorized account specified permissions */
-TRANSACTION(ttDELEGATE_SET, 64, DelegateSet, Delegation::notDelegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/DelegateSet.h>
+#endif
+TRANSACTION(ttDELEGATE_SET, 64, DelegateSet,
+    Delegation::notDelegatable,
+    noPriv, ({
    {sfAuthorize, soeREQUIRED},
    {sfPermissions, soeREQUIRED},
 }))

 /** This transaction creates a single asset vault. */
-TRANSACTION(ttVAULT_CREATE, 65, VaultCreate, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/VaultCreate.h>
+#endif
+TRANSACTION(ttVAULT_CREATE, 65, VaultCreate,
+    Delegation::delegatable,
+    createPseudoAcct | createMPTIssuance, ({
    {sfAsset, soeREQUIRED, soeMPTSupported},
    {sfAssetsMaximum, soeOPTIONAL},
    {sfMPTokenMetadata, soeOPTIONAL},
@@ -482,7 +757,12 @@ TRANSACTION(ttVAULT_CREATE, 65, VaultCreate, Delegation::delegatable, ({
 }))

 /** This transaction updates a single asset vault. */
-TRANSACTION(ttVAULT_SET, 66, VaultSet, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/VaultSet.h>
+#endif
+TRANSACTION(ttVAULT_SET, 66, VaultSet,
+    Delegation::delegatable,
+    noPriv, ({
    {sfVaultID, soeREQUIRED},
    {sfAssetsMaximum, soeOPTIONAL},
    {sfDomainID, soeOPTIONAL}, // PermissionedDomainID
@@ -490,25 +770,45 @@ TRANSACTION(ttVAULT_SET, 66, VaultSet, Delegation::delegatable, ({
 }))

 /** This transaction deletes a single asset vault. */
-TRANSACTION(ttVAULT_DELETE, 67, VaultDelete, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/VaultDelete.h>
+#endif
+TRANSACTION(ttVAULT_DELETE, 67, VaultDelete,
+    Delegation::delegatable,
+    mustDeleteAcct | destroyMPTIssuance, ({
    {sfVaultID, soeREQUIRED},
 }))

 /** This transaction trades assets for shares with a vault. */
-TRANSACTION(ttVAULT_DEPOSIT, 68, VaultDeposit, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/VaultDeposit.h>
+#endif
+TRANSACTION(ttVAULT_DEPOSIT, 68, VaultDeposit,
+    Delegation::delegatable,
+    mayAuthorizeMPT, ({
    {sfVaultID, soeREQUIRED},
    {sfAmount, soeREQUIRED, soeMPTSupported},
 }))

 /** This transaction trades shares for assets with a vault. */
-TRANSACTION(ttVAULT_WITHDRAW, 69, VaultWithdraw, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/VaultWithdraw.h>
+#endif
+TRANSACTION(ttVAULT_WITHDRAW, 69, VaultWithdraw,
+    Delegation::delegatable,
+    noPriv, ({
    {sfVaultID, soeREQUIRED},
    {sfAmount, soeREQUIRED, soeMPTSupported},
    {sfDestination, soeOPTIONAL},
 }))

 /** This transaction claws back tokens from a vault. */
-TRANSACTION(ttVAULT_CLAWBACK, 70, VaultClawback, Delegation::delegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/VaultClawback.h>
+#endif
+TRANSACTION(ttVAULT_CLAWBACK, 70, VaultClawback,
+    Delegation::delegatable,
+    noPriv, ({
    {sfVaultID, soeREQUIRED},
    {sfHolder, soeREQUIRED},
    {sfAmount, soeOPTIONAL, soeMPTSupported},
@@ -518,7 +818,12 @@ TRANSACTION(ttVAULT_CLAWBACK, 70, VaultClawback, Delegation::delegatable, ({

    For details, see: https://xrpl.org/amendments.html
 */
-TRANSACTION(ttAMENDMENT, 100, EnableAmendment, Delegation::notDelegatable, ({
+#if TRANSACTION_INCLUDE
+#   include <xrpld/app/tx/detail/Change.h>
+#endif
+TRANSACTION(ttAMENDMENT, 100, EnableAmendment,
+    Delegation::notDelegatable,
+    noPriv, ({
    {sfLedgerSequence, soeREQUIRED},
    {sfAmendment, soeREQUIRED},
 }))
@@ -526,7 +831,9 @@ TRANSACTION(ttAMENDMENT, 100, EnableAmendment, Delegation::notDelegatable, ({
 /** This system-generated transaction type is used to update the network's fee settings.
    For details, see: https://xrpl.org/fee-voting.html
 */
-TRANSACTION(ttFEE, 101, SetFee, Delegation::notDelegatable, ({
+TRANSACTION(ttFEE, 101, SetFee,
+    Delegation::notDelegatable,
+    noPriv, ({
    {sfLedgerSequence, soeOPTIONAL},
    // Old version uses raw numbers
    {sfBaseFee, soeOPTIONAL},
@@ -543,7 +850,9 @@ TRANSACTION(ttFEE, 101, SetFee, Delegation::notDelegatable, ({

    For details, see: https://xrpl.org/negative-unl.html
 */
-TRANSACTION(ttUNL_MODIFY, 102, UNLModify, Delegation::notDelegatable, ({
+TRANSACTION(ttUNL_MODIFY, 102, UNLModify,
+    Delegation::notDelegatable,
+    noPriv, ({
    {sfUNLModifyDisabling, soeREQUIRED},
    {sfLedgerSequence, soeREQUIRED},
    {sfUNLModifyValidator, soeREQUIRED},
--- a/include/xrpl/protocol/jss.h
+++ b/include/xrpl/protocol/jss.h
@@ -703,7 +703,7 @@ JSS(write_load);              // out: GetCounts
 #pragma push_macro("TRANSACTION")
 #undef TRANSACTION

-#define TRANSACTION(tag, value, name, delegatable, fields) JSS(name);
+#define TRANSACTION(tag, value, name, ...) JSS(name);

 #include <xrpl/protocol/detail/transactions.macro>