Merge branch 'develop' into bthomee/node_depth

.github/scripts/levelization/results/ordering.txt

@@ -42,6 +42,7 @@ libxrpl.tx > xrpl.server
 libxrpl.tx > xrpl.tx
 test.app > test.jtx
 test.app > test.rpc
+test.app > test.shamap
 test.app > test.toplevel
 test.app > test.unit_test
 test.app > xrpl.basics
@@ -57,6 +58,7 @@ test.app > xrpl.protocol
 test.app > xrpl.rdb
 test.app > xrpl.resource
 test.app > xrpl.server
+test.app > xrpl.shamap
 test.app > xrpl.tx
 test.basics > test.jtx
 test.basics > test.unit_test

.github/workflows/publish-docs.yml

@@ -40,9 +40,15 @@ env:
   NPROC_SUBTRACT: ${{ github.event.repository.private && '1' || '2' }}
 
 jobs:
-  build:
+  publish:
     runs-on: ubuntu-latest
     container: ghcr.io/xrplf/ci/tools-rippled-documentation:sha-a8c7be1
+    permissions:
+      pages: write
+      id-token: write
+    environment:
+      name: github-pages
+      url: ${{ steps.deploy.outputs.page_url }}
     steps:
       - name: Checkout repository
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
@@ -87,17 +93,7 @@ jobs:
         with:
           path: ${{ env.BUILD_DIR }}/docs/html
 
-  deploy:
-    if: ${{ github.event_name == 'push' }}
-    needs: build
-    runs-on: ubuntu-latest
-    permissions:
-      pages: write
-      id-token: write
-    environment:
-      name: github-pages
-      url: ${{ steps.deploy.outputs.page_url }}
-    steps:
-      - name: Deploy to GitHub Pages
+      - name: Deploy documentation to GitHub Pages
         id: deploy
+        if: ${{ github.event_name == 'push' }}
         uses: actions/deploy-pages@d6db90164ac5ed86f2b6aed7e0febac5b3c0c03e # v4.0.5

API-CHANGELOG.md

@@ -22,19 +22,6 @@ API version 2 is available in `rippled` version 2.0.0 and later. See [API-VERSIO
 
 This version is supported by all `rippled` versions. For WebSocket and HTTP JSON-RPC requests, it is currently the default API version used when no `api_version` is specified.
 
-## Unreleased
-
-This section contains changes targeting a future version.
-
-### Additions
-
-- `server_definitions`: Added the following new sections to the response ([#6321](https://github.com/XRPLF/rippled/pull/6321)):
-  - `TRANSACTION_FORMATS`: Describes the fields and their optionality for each transaction type, including common fields shared across all transactions.
-  - `LEDGER_ENTRY_FORMATS`: Describes the fields and their optionality for each ledger entry type, including common fields shared across all ledger entries.
-  - `TRANSACTION_FLAGS`: Maps transaction type names to their supported flags and flag values.
-  - `LEDGER_ENTRY_FLAGS`: Maps ledger entry type names to their flags and flag values.
-  - `ACCOUNT_SET_FLAGS`: Maps AccountSet flag names (asf flags) to their numeric values.
-
 ## XRP Ledger server version 3.1.0
 
 [Version 3.1.0](https://github.com/XRPLF/rippled/releases/tag/3.1.0) was released on Jan 27, 2026.

include/xrpl/basics/Slice.h

@@ -11,6 +11,7 @@
 #include <limits>
 #include <stdexcept>
 #include <string>
+#include <string_view>
 #include <type_traits>
 #include <vector>
 
@@ -231,4 +232,11 @@ makeSlice(std::basic_string<char, Traits, Alloc> const& s)
     return Slice(s.data(), s.size());
 }
 
+template <class Traits>
+Slice
+makeSlice(std::basic_string_view<char, Traits> const& s)
+{
+    return Slice(s.data(), s.size());
+}
+
 }  // namespace xrpl

include/xrpl/proto/xrpl.proto

@@ -244,7 +244,15 @@ message TMGetObjectByHash {
 
 message TMLedgerNode {
   required bytes nodedata = 1;
-  optional bytes nodeid = 2;  // missing for ledger base data
+
+  // Used when protocol version <2.3. Not set for ledger base data.
+  optional bytes nodeid = 2;
+
+  // Used when protocol version >=2.3. Neither value is set for ledger base data.
+  oneof reference {
+    bytes id = 3;      // Set for inner nodes.
+    uint32 depth = 4;  // Set for leaf nodes.
+  }
 }
 
 enum TMLedgerInfoType {

include/xrpl/protocol/KnownFormats.h

@@ -30,11 +30,9 @@ public:
         Item(
             char const* name,
             KeyType type,
-            std::vector<SOElement> uniqueFields,
-            std::vector<SOElement> commonFields)
-            : soTemplate_(std::move(uniqueFields), std::move(commonFields))
-            , name_(name)
-            , type_(type)
+            std::initializer_list<SOElement> uniqueFields,
+            std::initializer_list<SOElement> commonFields)
+            : soTemplate_(uniqueFields, commonFields), name_(name), type_(type)
         {
             // Verify that KeyType is appropriate.
             static_assert(
@@ -144,16 +142,16 @@ protected:
 
         @param name The name of this format.
         @param type The type of this format.
-        @param uniqueFields A std::vector of unique fields
-        @param commonFields A std::vector of common fields
+        @param uniqueFields An std::initializer_list of unique fields
+        @param commonFields An std::initializer_list of common fields
 
         @return The created format.
     */
     Item const&
     add(char const* name,
         KeyType type,
-        std::vector<SOElement> uniqueFields,
-        std::vector<SOElement> commonFields = {})
+        std::initializer_list<SOElement> uniqueFields,
+        std::initializer_list<SOElement> commonFields = {})
     {
         if (auto const item = findByType(type))
         {
@@ -162,7 +160,7 @@ protected:
                 item->getName());
         }
 
-        formats_.emplace_front(name, type, std::move(uniqueFields), std::move(commonFields));
+        formats_.emplace_front(name, type, uniqueFields, commonFields);
         Item const& item{formats_.front()};
 
         names_[name] = &item;

include/xrpl/protocol/LedgerFormats.h

@@ -2,34 +2,36 @@
 
 #include <xrpl/protocol/KnownFormats.h>
 
-#include <map>
-#include <string>
-#include <vector>
-
 namespace xrpl {
+
 /** Identifiers for on-ledger objects.
 
-    Each ledger object requires a unique type identifier, which is stored within the object itself;
-   this makes it possible to iterate the entire ledger and determine each object's type and verify
-   that the object you retrieved from a given hash matches the expected type.
+    Each ledger object requires a unique type identifier, which is stored
+    within the object itself; this makes it possible to iterate the entire
+    ledger and determine each object's type and verify that the object you
+    retrieved from a given hash matches the expected type.
 
-    @warning Since these values are stored inside objects stored on the ledger they are part of the
-   protocol.
-   **Changing them should be avoided because without special handling, this will result in a hard
+    @warning Since these values are stored inside objects stored on the ledger
+             they are part of the protocol. **Changing them should be avoided
+             because without special handling, this will result in a hard
    fork.**
 
-    @note Values outside this range may be used internally by the code for various purposes, but
-   attempting to use such values to identify on-ledger objects will result in an invariant failure.
+    @note Values outside this range may be used internally by the code for
+          various purposes, but attempting to use such values to identify
+          on-ledger objects will results in an invariant failure.
 
-    @note When retiring types, the specific values should not be removed but should be marked as
-   [[deprecated]]. This is to avoid accidental reuse of identifiers.
+    @note When retiring types, the specific values should not be removed but
+          should be marked as [[deprecated]]. This is to avoid accidental
+          reuse of identifiers.
 
-    @todo The C++ language does not enable checking for duplicate values here.
-          If it becomes possible then we should do this.
+    @todo The C++ language does not enable checking for duplicate values
+          here. If it becomes possible then we should do this.
 
     @ingroup protocol
 */
-enum LedgerEntryType : std::uint16_t {
+// clang-format off
+enum LedgerEntryType : std::uint16_t
+{
 
 #pragma push_macro("LEDGER_ENTRY")
 #undef LEDGER_ENTRY
@@ -44,10 +46,12 @@ enum LedgerEntryType : std::uint16_t {
     //---------------------------------------------------------------------------
     /** A special type, matching any ledger entry type.
 
-        The value does not represent a concrete type, but rather is used in contexts where the
-       specific type of a ledger object is unimportant, unknown or unavailable.
+        The value does not represent a concrete type, but rather is used in
+        contexts where the specific type of a ledger object is unimportant,
+        unknown or unavailable.
 
-        Objects with this special type cannot be created or stored on the ledger.
+        Objects with this special type cannot be created or stored on the
+        ledger.
 
         \sa keylet::unchecked
     */
@@ -55,11 +59,12 @@ enum LedgerEntryType : std::uint16_t {
 
     /** A special type, matching any ledger type except directory nodes.
 
-        The value does not represent a concrete type, but rather is used in contexts where the
-       ledger object must not be a directory node but its specific type is otherwise unimportant,
-       unknown or unavailable.
+        The value does not represent a concrete type, but rather is used in
+        contexts where the ledger object must not be a directory node but
+        its specific type is otherwise unimportant, unknown or unavailable.
 
-        Objects with this special type cannot be created or stored on the ledger.
+        Objects with this special type cannot be created or stored on the
+        ledger.
 
         \sa keylet::child
      */
@@ -88,188 +93,104 @@ enum LedgerEntryType : std::uint16_t {
                     Support for this type of object was never implemented.
                     No objects of this type were ever created.
      */
-    ltGENERATOR_MAP [[deprecated("This object type is not supported and should not be used.")]] =
-        0x0067,
+    ltGENERATOR_MAP [[deprecated("This object type is not supported and should not be used.")]]  = 0x0067,
 };
-
-/** Ledger object flags.
-
-    These flags are specified in ledger objects and modify their behavior.
-
-    @warning Ledger object flags form part of the protocol.
-    **Changing them should be avoided because without special handling, this will result in a hard
-   fork.**
-
-    @ingroup protocol
-*/
-#pragma push_macro("XMACRO")
-#pragma push_macro("TO_VALUE")
-#pragma push_macro("VALUE_TO_MAP")
-#pragma push_macro("NULL_NAME")
-#pragma push_macro("TO_MAP")
-#pragma push_macro("ALL_LEDGER_FLAGS")
-
-#undef XMACRO
-#undef TO_VALUE
-#undef VALUE_TO_MAP
-#undef NULL_NAME
-#undef TO_MAP
-
-#undef ALL_LEDGER_FLAGS
-
 // clang-format off
 
-#define XMACRO(LEDGER_OBJECT, LSF_FLAG, LSF_FLAG2)                                                                                 \
-    LEDGER_OBJECT(AccountRoot,                                                                                                     \
-        LSF_FLAG(lsfPasswordSpent, 0x00010000)                  /* True, if password set fee is spent. */                          \
-        LSF_FLAG(lsfRequireDestTag, 0x00020000)                 /* True, to require a DestinationTag for payments. */              \
-        LSF_FLAG(lsfRequireAuth, 0x00040000)                    /* True, to require a authorization to hold IOUs. */               \
-        LSF_FLAG(lsfDisallowXRP, 0x00080000)                    /* True, to disallow sending XRP. */                               \
-        LSF_FLAG(lsfDisableMaster, 0x00100000)                  /* True, force regular key */                                      \
-        LSF_FLAG(lsfNoFreeze, 0x00200000)                       /* True, cannot freeze ripple states */                            \
-        LSF_FLAG(lsfGlobalFreeze, 0x00400000)                   /* True, all assets frozen */                                      \
-        LSF_FLAG(lsfDefaultRipple, 0x00800000)                  /* True, incoming trust lines allow rippling by default */         \
-        LSF_FLAG(lsfDepositAuth, 0x01000000)                    /* True, all deposits require authorization */                     \
-        LSF_FLAG(lsfDisallowIncomingNFTokenOffer, 0x04000000)   /* True, reject new incoming NFT offers */                         \
-        LSF_FLAG(lsfDisallowIncomingCheck, 0x08000000)          /* True, reject new checks */                                      \
-        LSF_FLAG(lsfDisallowIncomingPayChan, 0x10000000)        /* True, reject new paychans */                                    \
-        LSF_FLAG(lsfDisallowIncomingTrustline, 0x20000000)      /* True, reject new trustlines (only if no issued assets) */       \
-        LSF_FLAG(lsfAllowTrustLineLocking, 0x40000000)          /* True, enable trustline locking */                               \
-        LSF_FLAG(lsfAllowTrustLineClawback, 0x80000000))        /* True, enable clawback */                                        \
-                                                                                                                                   \
-    LEDGER_OBJECT(Offer,                                                                                                           \
-        LSF_FLAG(lsfPassive, 0x00010000)                                                                                           \
-        LSF_FLAG(lsfSell, 0x00020000)                           /* True, offer was placed as a sell. */                            \
-        LSF_FLAG(lsfHybrid, 0x00040000))                        /* True, offer is hybrid. */                                       \
-                                                                                                                                   \
-    LEDGER_OBJECT(RippleState,                                                                                                     \
-        LSF_FLAG(lsfLowReserve, 0x00010000)                     /* True, if entry counts toward reserve. */                        \
-        LSF_FLAG(lsfHighReserve, 0x00020000)                                                                                       \
-        LSF_FLAG(lsfLowAuth, 0x00040000)                                                                                           \
-        LSF_FLAG(lsfHighAuth, 0x00080000)                                                                                          \
-        LSF_FLAG(lsfLowNoRipple, 0x00100000)                                                                                       \
-        LSF_FLAG(lsfHighNoRipple, 0x00200000)                                                                                      \
-        LSF_FLAG(lsfLowFreeze, 0x00400000)                      /* True, low side has set freeze flag */                           \
-        LSF_FLAG(lsfHighFreeze, 0x00800000)                     /* True, high side has set freeze flag */                          \
-        LSF_FLAG(lsfAMMNode, 0x01000000)                        /* True, trust line to AMM. */                                     \
-                                                                /* Used by client apps to identify payments via AMM. */            \
-        LSF_FLAG(lsfLowDeepFreeze, 0x02000000)                  /* True, low side has set deep freeze flag */                      \
-        LSF_FLAG(lsfHighDeepFreeze, 0x04000000))                /* True, high side has set deep freeze flag */                     \
-                                                                                                                                   \
-    LEDGER_OBJECT(SignerList,                                                                                                      \
-        LSF_FLAG(lsfOneOwnerCount, 0x00010000))                 /* True, uses only one OwnerCount */                               \
-                                                                                                                                   \
-    LEDGER_OBJECT(DirNode,                                                                                                         \
-        LSF_FLAG(lsfNFTokenBuyOffers, 0x00000001)                                                                                  \
-        LSF_FLAG(lsfNFTokenSellOffers, 0x00000002))                                                                                \
-                                                                                                                                   \
-    LEDGER_OBJECT(NFTokenOffer,                                                                                                    \
-        LSF_FLAG(lsfSellNFToken, 0x00000001))                                                                                      \
-                                                                                                                                   \
-    LEDGER_OBJECT(MPTokenIssuance,                                                                                                 \
-        LSF_FLAG(lsfMPTLocked, 0x00000001)                      /* Also used in ltMPTOKEN */                                       \
-        LSF_FLAG(lsfMPTCanLock, 0x00000002)                                                                                        \
-        LSF_FLAG(lsfMPTRequireAuth, 0x00000004)                                                                                    \
-        LSF_FLAG(lsfMPTCanEscrow, 0x00000008)                                                                                      \
-        LSF_FLAG(lsfMPTCanTrade, 0x00000010)                                                                                       \
-        LSF_FLAG(lsfMPTCanTransfer, 0x00000020)                                                                                    \
-        LSF_FLAG(lsfMPTCanClawback, 0x00000040))                                                                                   \
-                                                                                                                                   \
-    LEDGER_OBJECT(MPTokenIssuanceMutable,                                                                                          \
-        LSF_FLAG(lsmfMPTCanMutateCanLock, 0x00000002)                                                                              \
-        LSF_FLAG(lsmfMPTCanMutateRequireAuth, 0x00000004)                                                                          \
-        LSF_FLAG(lsmfMPTCanMutateCanEscrow, 0x00000008)                                                                            \
-        LSF_FLAG(lsmfMPTCanMutateCanTrade, 0x00000010)                                                                             \
-        LSF_FLAG(lsmfMPTCanMutateCanTransfer, 0x00000020)                                                                          \
-        LSF_FLAG(lsmfMPTCanMutateCanClawback, 0x00000040)                                                                          \
-        LSF_FLAG(lsmfMPTCanMutateMetadata, 0x00010000)                                                                             \
-        LSF_FLAG(lsmfMPTCanMutateTransferFee, 0x00020000))                                                                         \
-                                                                                                                                   \
-    LEDGER_OBJECT(MPToken,                                                                                                         \
-        LSF_FLAG2(lsfMPTLocked, 0x00000001)                                                                                        \
-        LSF_FLAG(lsfMPTAuthorized, 0x00000002))                                                                                    \
-                                                                                                                                   \
-    LEDGER_OBJECT(Credential,                                                                                                      \
-        LSF_FLAG(lsfAccepted, 0x00010000))                                                                                         \
-                                                                                                                                   \
-    LEDGER_OBJECT(Vault,                                                                                                           \
-        LSF_FLAG(lsfVaultPrivate, 0x00010000))                                                                                     \
-                                                                                                                                   \
-    LEDGER_OBJECT(Loan,                                                                                                            \
-        LSF_FLAG(lsfLoanDefault, 0x00010000)                                                                                       \
-        LSF_FLAG(lsfLoanImpaired, 0x00020000)                                                                                      \
-        LSF_FLAG(lsfLoanOverpayment, 0x00040000))               /* True, loan allows overpayments */
+/**
+    @ingroup protocol
+*/
+enum LedgerSpecificFlags {
+    // ltACCOUNT_ROOT
+    lsfPasswordSpent = 0x00010000,  // True, if password set fee is spent.
+    lsfRequireDestTag =
+        0x00020000,  // True, to require a DestinationTag for payments.
+    lsfRequireAuth =
+        0x00040000,  // True, to require a authorization to hold IOUs.
+    lsfDisallowXRP = 0x00080000,    // True, to disallow sending XRP.
+    lsfDisableMaster = 0x00100000,  // True, force regular key
+    lsfNoFreeze = 0x00200000,       // True, cannot freeze ripple states
+    lsfGlobalFreeze = 0x00400000,   // True, all assets frozen
+    lsfDefaultRipple =
+        0x00800000,               // True, incoming trust lines allow rippling by default
+    lsfDepositAuth = 0x01000000,  // True, all deposits require authorization
+/*  // reserved for Hooks amendment
+    lsfTshCollect = 0x02000000,     // True, allow TSH collect-calls to acc hooks
+*/
+    lsfDisallowIncomingNFTokenOffer =
+        0x04000000,               // True, reject new incoming NFT offers
+    lsfDisallowIncomingCheck =
+        0x08000000,               // True, reject new checks
+    lsfDisallowIncomingPayChan =
+        0x10000000,               // True, reject new paychans
+    lsfDisallowIncomingTrustline =
+        0x20000000,               // True, reject new trustlines (only if no issued assets)
+    lsfAllowTrustLineLocking =
+        0x40000000,               // True, enable trustline locking
+    lsfAllowTrustLineClawback =
+        0x80000000,               // True, enable clawback
 
-// clang-format on
+    // ltOFFER
+    lsfPassive = 0x00010000,
+    lsfSell = 0x00020000,  // True, offer was placed as a sell.
+    lsfHybrid = 0x00040000,  // True, offer is hybrid.
 
-// Create all the flag values as an enum.
-//
-// example:
-// enum LedgerSpecificFlags {
-//     lsfPasswordSpent = 0x00010000,
-//     lsfRequireDestTag = 0x00020000,
-//     ...
-// };
-#define TO_VALUE(name, value) name = value,
-#define NULL_NAME(name, values) values
-#define NULL_OUTPUT(name, value)
-enum LedgerSpecificFlags : std::uint32_t { XMACRO(NULL_NAME, TO_VALUE, NULL_OUTPUT) };
+    // ltRIPPLE_STATE
+    lsfLowReserve = 0x00010000,  // True, if entry counts toward reserve.
+    lsfHighReserve = 0x00020000,
+    lsfLowAuth = 0x00040000,
+    lsfHighAuth = 0x00080000,
+    lsfLowNoRipple = 0x00100000,
+    lsfHighNoRipple = 0x00200000,
+    lsfLowFreeze = 0x00400000,      // True, low side has set freeze flag
+    lsfHighFreeze = 0x00800000,     // True, high side has set freeze flag
+    lsfLowDeepFreeze = 0x02000000,  // True, low side has set deep freeze flag
+    lsfHighDeepFreeze = 0x04000000, // True, high side has set deep freeze flag
+    lsfAMMNode = 0x01000000,        // True, trust line to AMM. Used by client
+                                    // apps to identify payments via AMM.
 
-// Create getter functions for each set of flags using Meyer's singleton pattern.
-// This avoids static initialization order fiasco while still providing efficient access.
-// This is used below in `getAllLedgerFlags()` to generate the server_definitions RPC output.
-//
-// example:
-// inline LedgerFlagMap const& getAccountRootFlags() {
-//     static LedgerFlagMap const flags = {
-//         {"lsfPasswordSpent", 0x00010000},
-//         {"lsfRequireDestTag", 0x00020000},
-//     ...};
-//     return flags;
-// }
-using LedgerFlagMap = std::map<std::string, std::uint32_t>;
-#define VALUE_TO_MAP(name, value) {#name, value},
-#define TO_MAP(name, values)                         \
-    inline LedgerFlagMap const& get##name##Flags()   \
-    {                                                \
-        static LedgerFlagMap const flags = {values}; \
-        return flags;                                \
-    }
-XMACRO(TO_MAP, VALUE_TO_MAP, VALUE_TO_MAP)
+    // ltSIGNER_LIST
+    lsfOneOwnerCount = 0x00010000,  // True, uses only one OwnerCount
 
-// Create a getter function for all ledger flag maps using Meyer's singleton pattern.
-// This is used to generate the server_definitions RPC output.
-//
-// example:
-// inline std::vector<std::pair<std::string, LedgerFlagMap>> const& getAllLedgerFlags() {
-//     static std::vector<std::pair<std::string, LedgerFlagMap>> const flags = {
-//         {"AccountRoot", getAccountRootFlags()},
-//     ...};
-//     return flags;
-// }
-#define ALL_LEDGER_FLAGS(name, values) {#name, get##name##Flags()},
-inline std::vector<std::pair<std::string, LedgerFlagMap>> const&
-getAllLedgerFlags()
-{
-    static std::vector<std::pair<std::string, LedgerFlagMap>> const flags = {
-        XMACRO(ALL_LEDGER_FLAGS, NULL_OUTPUT, NULL_OUTPUT)};
-    return flags;
-}
+    // ltDIR_NODE
+    lsfNFTokenBuyOffers = 0x00000001,
+    lsfNFTokenSellOffers = 0x00000002,
 
-#undef XMACRO
-#undef TO_VALUE
-#undef VALUE_TO_MAP
-#undef NULL_NAME
-#undef NULL_OUTPUT
-#undef TO_MAP
-#undef ALL_LEDGER_FLAGS
+    // ltNFTOKEN_OFFER
+    lsfSellNFToken = 0x00000001,
 
-#pragma pop_macro("XMACRO")
-#pragma pop_macro("TO_VALUE")
-#pragma pop_macro("VALUE_TO_MAP")
-#pragma pop_macro("NULL_NAME")
-#pragma pop_macro("TO_MAP")
-#pragma pop_macro("ALL_LEDGER_FLAGS")
+    // ltMPTOKEN_ISSUANCE
+    lsfMPTLocked = 0x00000001, // Also used in ltMPTOKEN
+    lsfMPTCanLock = 0x00000002,
+    lsfMPTRequireAuth = 0x00000004,
+    lsfMPTCanEscrow = 0x00000008,
+    lsfMPTCanTrade = 0x00000010,
+    lsfMPTCanTransfer = 0x00000020,
+    lsfMPTCanClawback = 0x00000040,
+
+    lsmfMPTCanMutateCanLock = 0x00000002,
+    lsmfMPTCanMutateRequireAuth = 0x00000004,
+    lsmfMPTCanMutateCanEscrow = 0x00000008,
+    lsmfMPTCanMutateCanTrade = 0x00000010,
+    lsmfMPTCanMutateCanTransfer = 0x00000020,
+    lsmfMPTCanMutateCanClawback = 0x00000040,
+    lsmfMPTCanMutateMetadata = 0x00010000,
+    lsmfMPTCanMutateTransferFee = 0x00020000,
+
+    // ltMPTOKEN
+    lsfMPTAuthorized = 0x00000002,
+
+    // ltCREDENTIAL
+    lsfAccepted = 0x00010000,
+
+    // ltVAULT
+    lsfVaultPrivate = 0x00010000,
+
+    // ltLOAN
+    lsfLoanDefault = 0x00010000,
+    lsfLoanImpaired = 0x00020000,
+    lsfLoanOverpayment = 0x00040000, // True, loan allows overpayments
+};
 
 //------------------------------------------------------------------------------
 
@@ -286,10 +207,6 @@ private:
 public:
     static LedgerFormats const&
     getInstance();
-
-    // Fields shared by all ledger entry formats:
-    static std::vector<SOElement> const&
-    getCommonFields();
 };
 
 }  // namespace xrpl

include/xrpl/protocol/SOTemplate.h

@@ -6,7 +6,6 @@
 #include <functional>
 #include <initializer_list>
 #include <stdexcept>
-#include <vector>
 
 namespace xrpl {
 
@@ -98,12 +97,8 @@ public:
     operator=(SOTemplate&& other) = default;
 
     /** Create a template populated with all fields.
-        After creating the template fields cannot be added, modified, or removed.
-    */
-    SOTemplate(std::vector<SOElement> uniqueFields, std::vector<SOElement> commonFields = {});
-
-    /** Create a template populated with all fields.
-        Note: Defers to the vector constructor above.
+        After creating the template fields cannot be
+        added, modified, or removed.
     */
     SOTemplate(
         std::initializer_list<SOElement> uniqueFields,

include/xrpl/protocol/TxFlags.h

@@ -3,444 +3,294 @@
 #include <xrpl/protocol/LedgerFormats.h>
 
 #include <cstdint>
-#include <map>
-#include <string>
-#include <utility>
-#include <vector>
 
 namespace xrpl {
 
 /** Transaction flags.
 
-    These flags are specified in a transaction's 'Flags' field and modify
-    the behavior of that transaction.
+    These flags are specified in a transaction's 'Flags' field and modify the
+    behavior of that transaction.
 
     There are two types of flags:
 
-        (1) Universal flags: these are flags which apply to, and are interpreted the same way by,
-            all transactions, except, perhaps, to special pseudo-transactions.
+        (1) Universal flags: these are flags which apply to, and are interpreted
+                             the same way by, all transactions, except, perhaps,
+                             to special pseudo-transactions.
 
-        (2) Tx-Specific flags: these are flags which are interpreted according to the type of the
-            transaction being executed. That is, the same numerical flag value may have different
-            effects, depending on the transaction being executed.
+        (2) Tx-Specific flags: these are flags which are interpreted according
+                               to the type of the transaction being executed.
+                               That is, the same numerical flag value may have
+                               different effects, depending on the transaction
+                               being executed.
 
-    @note The universal transaction flags occupy the high-order 8 bits.
-          The tx-specific flags occupy the remaining 24 bits.
+    @note The universal transaction flags occupy the high-order 8 bits. The
+          tx-specific flags occupy the remaining 24 bits.
 
-    @warning Transaction flags form part of the protocol.
-             **Changing them should be avoided because without special handling, this will result in
-             a hard fork.**
+    @warning Transaction flags form part of the protocol. **Changing them
+             should be avoided because without special handling, this will
+             result in a hard fork.**
 
     @ingroup protocol
 */
 
-using FlagValue = std::uint32_t;
-
-// Universal Transaction flags:
-inline constexpr FlagValue tfFullyCanonicalSig = 0x80000000;
-inline constexpr FlagValue tfInnerBatchTxn = 0x40000000;
-inline constexpr FlagValue tfUniversal = tfFullyCanonicalSig | tfInnerBatchTxn;
-inline constexpr FlagValue tfUniversalMask = ~tfUniversal;
-
-#pragma push_macro("XMACRO")
-#pragma push_macro("TO_VALUE")
-#pragma push_macro("VALUE_TO_MAP")
-#pragma push_macro("NULL_NAME")
-#pragma push_macro("NULL_OUTPUT")
-#pragma push_macro("TO_MAP")
-#pragma push_macro("TO_MASK")
-#pragma push_macro("VALUE_TO_MASK")
-#pragma push_macro("ALL_TX_FLAGS")
-#pragma push_macro("NULL_MASK_ADJ")
-#pragma push_macro("MASK_ADJ_TO_MASK")
-
-#undef XMACRO
-#undef TO_VALUE
-#undef VALUE_TO_MAP
-#undef NULL_NAME
-#undef NULL_OUTPUT
-#undef TO_MAP
-#undef TO_MASK
-#undef VALUE_TO_MASK
-#undef NULL_MASK_ADJ
-#undef MASK_ADJ_TO_MASK
-
+// Formatting equals sign aligned 4 spaces after longest prefix, except for
+// wrapped lines
 // clang-format off
-#undef ALL_TX_FLAGS
+// Universal Transaction flags:
+constexpr std::uint32_t tfFullyCanonicalSig                = 0x80000000;
+constexpr std::uint32_t tfInnerBatchTxn                    = 0x40000000;
+constexpr std::uint32_t tfUniversal                        = tfFullyCanonicalSig | tfInnerBatchTxn;
+constexpr std::uint32_t tfUniversalMask                    = ~tfUniversal;
 
-// XMACRO parameters:
-// - TRANSACTION: handles the transaction name, its flags, and mask adjustment
-// - TF_FLAG: defines a new flag constant
-// - TF_FLAG2: references an existing flag constant (no new definition)
-// - MASK_ADJ: specifies flags to add back to the mask (making them invalid for this tx type)
-//
-// Note: MASK_ADJ is used when a universal flag should be invalid for a specific transaction.
-// For example, Batch uses MASK_ADJ(tfInnerBatchTxn) because the outer Batch transaction
-// must not have tfInnerBatchTxn set (only inner transactions should have it).
-//
-// TODO: Consider rewriting this using reflection in C++26 or later. Alternatively this could be a DSL processed by a script at build time.
-#define XMACRO(TRANSACTION, TF_FLAG, TF_FLAG2, MASK_ADJ)                                                                                                       \
-    TRANSACTION(AccountSet,                                                                                                                                    \
-        TF_FLAG(tfRequireDestTag, 0x00010000)                                                                                                                  \
-        TF_FLAG(tfOptionalDestTag, 0x00020000)                                                                                                                 \
-        TF_FLAG(tfRequireAuth, 0x00040000)                                                                                                                     \
-        TF_FLAG(tfOptionalAuth, 0x00080000)                                                                                                                    \
-        TF_FLAG(tfDisallowXRP, 0x00100000)                                                                                                                     \
-        TF_FLAG(tfAllowXRP, 0x00200000),                                                                                                                       \
-        MASK_ADJ(0))                                                                                                                                           \
-                                                                                                                                                               \
-    TRANSACTION(OfferCreate,                                                                                                                                   \
-        TF_FLAG(tfPassive, 0x00010000)                                                                                                                         \
-        TF_FLAG(tfImmediateOrCancel, 0x00020000)                                                                                                               \
-        TF_FLAG(tfFillOrKill, 0x00040000)                                                                                                                      \
-        TF_FLAG(tfSell, 0x00080000)                                                                                                                            \
-        TF_FLAG(tfHybrid, 0x00100000),                                                                                                                         \
-        MASK_ADJ(0))                                                                                                                                           \
-                                                                                                                                                               \
-    TRANSACTION(Payment,                                                                                                                                       \
-        TF_FLAG(tfNoRippleDirect, 0x00010000)                                                                                                                  \
-        TF_FLAG(tfPartialPayment, 0x00020000)                                                                                                                  \
-        TF_FLAG(tfLimitQuality, 0x00040000),                                                                                                                   \
-        MASK_ADJ(0))                                                                                                                                           \
-                                                                                                                                                               \
-    TRANSACTION(TrustSet,                                                                                                                                      \
-        TF_FLAG(tfSetfAuth, 0x00010000)                                                                                                                        \
-        TF_FLAG(tfSetNoRipple, 0x00020000)                                                                                                                     \
-        TF_FLAG(tfClearNoRipple, 0x00040000)                                                                                                                   \
-        TF_FLAG(tfSetFreeze, 0x00100000)                                                                                                                       \
-        TF_FLAG(tfClearFreeze, 0x00200000)                                                                                                                     \
-        TF_FLAG(tfSetDeepFreeze, 0x00400000)                                                                                                                   \
-        TF_FLAG(tfClearDeepFreeze, 0x00800000),                                                                                                                \
-        MASK_ADJ(0))                                                                                                                                           \
-                                                                                                                                                               \
-    TRANSACTION(EnableAmendment,                                                                                                                               \
-        TF_FLAG(tfGotMajority, 0x00010000)                                                                                                                     \
-        TF_FLAG(tfLostMajority, 0x00020000),                                                                                                                   \
-        MASK_ADJ(0))                                                                                                                                           \
-                                                                                                                                                               \
-    TRANSACTION(PaymentChannelClaim,                                                                                                                           \
-        TF_FLAG(tfRenew, 0x00010000)                                                                                                                           \
-        TF_FLAG(tfClose, 0x00020000),                                                                                                                          \
-        MASK_ADJ(0))                                                                                                                                           \
-                                                                                                                                                               \
-    TRANSACTION(NFTokenMint,                                                                                                                                   \
-        TF_FLAG(tfBurnable, 0x00000001)                                                                                                                        \
-        TF_FLAG(tfOnlyXRP, 0x00000002)                                                                                                                         \
-        /* deprecated TF_FLAG(tfTrustLine, 0x00000004) */                                                                                                      \
-        TF_FLAG(tfTransferable, 0x00000008)                                                                                                                    \
-        TF_FLAG(tfMutable, 0x00000010),                                                                                                                        \
-        MASK_ADJ(0))                                                                                                                                           \
-                                                                                                                                                               \
-    TRANSACTION(MPTokenIssuanceCreate,                                                                                                                         \
-        /* Note: tf/lsfMPTLocked is intentionally omitted since this transaction is not allowed to modify it. */                                               \
-        TF_FLAG(tfMPTCanLock, lsfMPTCanLock)                                                                                                                   \
-        TF_FLAG(tfMPTRequireAuth, lsfMPTRequireAuth)                                                                                                           \
-        TF_FLAG(tfMPTCanEscrow, lsfMPTCanEscrow)                                                                                                               \
-        TF_FLAG(tfMPTCanTrade, lsfMPTCanTrade)                                                                                                                 \
-        TF_FLAG(tfMPTCanTransfer, lsfMPTCanTransfer)                                                                                                           \
-        TF_FLAG(tfMPTCanClawback, lsfMPTCanClawback),                                                                                                          \
-        MASK_ADJ(0))                                                                                                                                           \
-                                                                                                                                                               \
-    TRANSACTION(MPTokenAuthorize,                                                                                                                              \
-        TF_FLAG(tfMPTUnauthorize, 0x00000001),                                                                                                                 \
-        MASK_ADJ(0))                                                                                                                                           \
-                                                                                                                                                               \
-    TRANSACTION(MPTokenIssuanceSet,                                                                                                                            \
-        TF_FLAG(tfMPTLock, 0x00000001)                                                                                                                         \
-        TF_FLAG(tfMPTUnlock, 0x00000002),                                                                                                                      \
-        MASK_ADJ(0))                                                                                                                                           \
-                                                                                                                                                               \
-    TRANSACTION(NFTokenCreateOffer,                                                                                                                            \
-        TF_FLAG(tfSellNFToken, 0x00000001),                                                                                                                    \
-        MASK_ADJ(0))                                                                                                                                           \
-                                                                                                                                                               \
-    TRANSACTION(AMMDeposit,                                                                                                                                    \
-        TF_FLAG(tfLPToken, 0x00010000)                                                                                                                         \
-        TF_FLAG(tfSingleAsset, 0x00080000)                                                                                                                     \
-        TF_FLAG(tfTwoAsset, 0x00100000)                                                                                                                        \
-        TF_FLAG(tfOneAssetLPToken, 0x00200000)                                                                                                                 \
-        TF_FLAG(tfLimitLPToken, 0x00400000)                                                                                                                    \
-        TF_FLAG(tfTwoAssetIfEmpty, 0x00800000),                                                                                                                \
-        MASK_ADJ(0))                                                                                                                                           \
-                                                                                                                                                               \
-    TRANSACTION(AMMWithdraw,                                                                                                                                   \
-        TF_FLAG2(tfLPToken, 0x00010000)                                                                                                                        \
-        TF_FLAG(tfWithdrawAll, 0x00020000)                                                                                                                     \
-        TF_FLAG(tfOneAssetWithdrawAll, 0x00040000)                                                                                                             \
-        TF_FLAG2(tfSingleAsset, 0x00080000)                                                                                                                    \
-        TF_FLAG2(tfTwoAsset, 0x00100000)                                                                                                                       \
-        TF_FLAG2(tfOneAssetLPToken, 0x00200000)                                                                                                                \
-        TF_FLAG2(tfLimitLPToken, 0x00400000),                                                                                                                  \
-        MASK_ADJ(0))                                                                                                                                           \
-                                                                                                                                                               \
-    TRANSACTION(AMMClawback,                                                                                                                                   \
-        TF_FLAG(tfClawTwoAssets, 0x00000001),                                                                                                                  \
-        MASK_ADJ(0))                                                                                                                                           \
-                                                                                                                                                               \
-    TRANSACTION(XChainModifyBridge,                                                                                                                            \
-        TF_FLAG(tfClearAccountCreateAmount, 0x00010000),                                                                                                       \
-        MASK_ADJ(0))                                                                                                                                           \
-                                                                                                                                                               \
-    TRANSACTION(VaultCreate,                                                                                                                                   \
-        TF_FLAG(tfVaultPrivate, lsfVaultPrivate)                                                                                                               \
-        TF_FLAG(tfVaultShareNonTransferable, 0x00020000),                                                                                                      \
-        MASK_ADJ(0))                                                                                                                                           \
-                                                                                                                                                               \
-    TRANSACTION(Batch,                                                                                                                                         \
-        TF_FLAG(tfAllOrNothing, 0x00010000)                                                                                                                    \
-        TF_FLAG(tfOnlyOne, 0x00020000)                                                                                                                         \
-        TF_FLAG(tfUntilFailure, 0x00040000)                                                                                                                    \
-        TF_FLAG(tfIndependent, 0x00080000),                                                                                                                    \
-        MASK_ADJ(tfInnerBatchTxn))                      /* Batch must reject tfInnerBatchTxn - only inner transactions should have this flag */                \
-                                                                                                                                                               \
-    TRANSACTION(LoanSet,                                /* True indicates the loan supports overpayments */                                                    \
-        TF_FLAG(tfLoanOverpayment, 0x00010000),                                                                                                                \
-        MASK_ADJ(0))                                                                                                                                           \
-                                                                                                                                                               \
-    TRANSACTION(LoanPay,                                /* True indicates any excess in this payment can be used as an overpayment. */                         \
-                                                        /* False: no overpayments will be taken. */                                                            \
-        TF_FLAG2(tfLoanOverpayment, 0x00010000)                                                                                                                \
-        TF_FLAG(tfLoanFullPayment, 0x00020000)          /* True indicates that the payment is an early full payment. */                                        \
-                                                        /* It must pay the entire loan including close interest and fees, or it will fail. */                  \
-                                                        /* False: Not a full payment. */                                                                       \
-        TF_FLAG(tfLoanLatePayment, 0x00040000),         /* True indicates that the payment is late, and includes late interest and fees. */                    \
-                                                        /* If the loan is not late, it will fail. */                                                           \
-                                                        /* False: not a late payment. If the current payment is overdue, the transaction will fail.*/          \
-        MASK_ADJ(0))                                                                                                                                           \
-                                                                                                                                                               \
-    TRANSACTION(LoanManage,                                                                                                                                    \
-        TF_FLAG(tfLoanDefault, 0x00010000)                                                                                                                     \
-        TF_FLAG(tfLoanImpair, 0x00020000)                                                                                                                      \
-        TF_FLAG(tfLoanUnimpair, 0x00040000),                                                                                                                   \
-        MASK_ADJ(0))
+// AccountSet flags:
+constexpr std::uint32_t tfRequireDestTag                   = 0x00010000;
+constexpr std::uint32_t tfOptionalDestTag                  = 0x00020000;
+constexpr std::uint32_t tfRequireAuth                      = 0x00040000;
+constexpr std::uint32_t tfOptionalAuth                     = 0x00080000;
+constexpr std::uint32_t tfDisallowXRP                      = 0x00100000;
+constexpr std::uint32_t tfAllowXRP                         = 0x00200000;
+constexpr std::uint32_t tfAccountSetMask =
+    ~(tfUniversal | tfRequireDestTag | tfOptionalDestTag | tfRequireAuth |
+      tfOptionalAuth | tfDisallowXRP | tfAllowXRP);
 
-// clang-format on
+// AccountSet SetFlag/ClearFlag values
+constexpr std::uint32_t asfRequireDest                     =  1;
+constexpr std::uint32_t asfRequireAuth                     =  2;
+constexpr std::uint32_t asfDisallowXRP                     =  3;
+constexpr std::uint32_t asfDisableMaster                   =  4;
+constexpr std::uint32_t asfAccountTxnID                    =  5;
+constexpr std::uint32_t asfNoFreeze                        =  6;
+constexpr std::uint32_t asfGlobalFreeze                    =  7;
+constexpr std::uint32_t asfDefaultRipple                   =  8;
+constexpr std::uint32_t asfDepositAuth                     =  9;
+constexpr std::uint32_t asfAuthorizedNFTokenMinter         = 10;
+/*  // reserved for Hooks amendment
+constexpr std::uint32_t asfTshCollect                      = 11;
+*/
+constexpr std::uint32_t asfDisallowIncomingNFTokenOffer    = 12;
+constexpr std::uint32_t asfDisallowIncomingCheck           = 13;
+constexpr std::uint32_t asfDisallowIncomingPayChan         = 14;
+constexpr std::uint32_t asfDisallowIncomingTrustline       = 15;
+constexpr std::uint32_t asfAllowTrustLineClawback          = 16;
+constexpr std::uint32_t asfAllowTrustLineLocking           = 17;
 
-// Create all the flag values.
-//
-// example:
-// inline constexpr FlagValue tfAccountSetRequireDestTag = 0x00010000;
-#define TO_VALUE(name, value) inline constexpr FlagValue name = value;
-#define NULL_NAME(name, values, maskAdj) values
-#define NULL_OUTPUT(name, value)
-#define NULL_MASK_ADJ(value)
-XMACRO(NULL_NAME, TO_VALUE, NULL_OUTPUT, NULL_MASK_ADJ)
+// OfferCreate flags:
+constexpr std::uint32_t tfPassive                          = 0x00010000;
+constexpr std::uint32_t tfImmediateOrCancel                = 0x00020000;
+constexpr std::uint32_t tfFillOrKill                       = 0x00040000;
+constexpr std::uint32_t tfSell                             = 0x00080000;
+constexpr std::uint32_t tfHybrid                           = 0x00100000;
+constexpr std::uint32_t tfOfferCreateMask =
+    ~(tfUniversal | tfPassive | tfImmediateOrCancel | tfFillOrKill | tfSell | tfHybrid);
 
-// Create masks for each transaction type that has flags.
-//
-// example:
-// inline constexpr FlagValue tfAccountSetMask = ~(tfUniversal | tfRequireDestTag |
-//     tfOptionalDestTag | tfRequireAuth | tfOptionalAuth | tfDisallowXRP | tfAllowXRP);
-//
-// The mask adjustment (maskAdj) allows adding flags back to the mask, making them invalid.
-// For example, Batch uses MASK_ADJ(tfInnerBatchTxn) to reject tfInnerBatchTxn on outer Batch.
-#define TO_MASK(name, values, maskAdj) \
-    inline constexpr FlagValue tf##name##Mask = ~(tfUniversal values) | maskAdj;
-#define VALUE_TO_MASK(name, value) | name
-#define MASK_ADJ_TO_MASK(value) value
-XMACRO(TO_MASK, VALUE_TO_MASK, VALUE_TO_MASK, MASK_ADJ_TO_MASK)
+// Payment flags:
+constexpr std::uint32_t tfNoRippleDirect                   = 0x00010000;
+constexpr std::uint32_t tfPartialPayment                   = 0x00020000;
+constexpr std::uint32_t tfLimitQuality                     = 0x00040000;
+constexpr std::uint32_t tfPaymentMask =
+    ~(tfUniversal | tfPartialPayment | tfLimitQuality | tfNoRippleDirect);
+constexpr std::uint32_t tfMPTPaymentMask = ~(tfUniversal | tfPartialPayment);
 
-// Verify that tfBatchMask correctly rejects tfInnerBatchTxn.
-// The outer Batch transaction must NOT have tfInnerBatchTxn set; only inner transactions should
-// have it.
-static_assert(
-    (tfBatchMask & tfInnerBatchTxn) == tfInnerBatchTxn,
-    "tfBatchMask must include tfInnerBatchTxn to reject it on outer Batch");
+// TrustSet flags:
+constexpr std::uint32_t tfSetfAuth                         = 0x00010000;
+constexpr std::uint32_t tfSetNoRipple                      = 0x00020000;
+constexpr std::uint32_t tfClearNoRipple                    = 0x00040000;
+constexpr std::uint32_t tfSetFreeze                        = 0x00100000;
+constexpr std::uint32_t tfClearFreeze                      = 0x00200000;
+constexpr std::uint32_t tfSetDeepFreeze                    = 0x00400000;
+constexpr std::uint32_t tfClearDeepFreeze                  = 0x00800000;
+constexpr std::uint32_t tfTrustSetMask =
+    ~(tfUniversal | tfSetfAuth | tfSetNoRipple | tfClearNoRipple | tfSetFreeze |
+      tfClearFreeze | tfSetDeepFreeze | tfClearDeepFreeze);
+constexpr std::uint32_t tfTrustSetPermissionMask = ~(tfUniversal | tfSetfAuth | tfSetFreeze | tfClearFreeze);
 
-// Verify that other transaction masks correctly allow tfInnerBatchTxn.
-// Inner transactions need tfInnerBatchTxn to be valid, so these masks must not reject it.
-static_assert(
-    (tfPaymentMask & tfInnerBatchTxn) == 0,
-    "tfPaymentMask must not reject tfInnerBatchTxn");
-static_assert(
-    (tfAccountSetMask & tfInnerBatchTxn) == 0,
-    "tfAccountSetMask must not reject tfInnerBatchTxn");
+// EnableAmendment flags:
+constexpr std::uint32_t tfGotMajority                      = 0x00010000;
+constexpr std::uint32_t tfLostMajority                     = 0x00020000;
+constexpr std::uint32_t tfChangeMask =
+    ~( tfUniversal | tfGotMajority | tfLostMajority);
 
-// Create getter functions for each set of flags using Meyer's singleton pattern.
-// This avoids static initialization order fiasco while still providing efficient access.
-// This is used below in `getAllTxFlags()` to generate the server_definitions RPC
-// output.
-//
-// example:
-// inline FlagMap const& getAccountSetFlags() {
-//     static FlagMap const flags = {
-//         {"tfRequireDestTag", 0x00010000},
-//         {"tfOptionalDestTag", 0x00020000},
-//     ...};
-//     return flags;
-// }
-using FlagMap = std::map<std::string, FlagValue>;
-#define VALUE_TO_MAP(name, value) {#name, value},
-#define TO_MAP(name, values, maskAdj)          \
-    inline FlagMap const& get##name##Flags()   \
-    {                                          \
-        static FlagMap const flags = {values}; \
-        return flags;                          \
-    }
-XMACRO(TO_MAP, VALUE_TO_MAP, VALUE_TO_MAP, NULL_MASK_ADJ)
+// PaymentChannelClaim flags:
+constexpr std::uint32_t tfRenew                            = 0x00010000;
+constexpr std::uint32_t tfClose                            = 0x00020000;
+constexpr std::uint32_t tfPayChanClaimMask = ~(tfUniversal | tfRenew | tfClose);
 
-inline FlagMap const&
-getUniversalFlags()
-{
-    static FlagMap const flags = {
-        {"tfFullyCanonicalSig", tfFullyCanonicalSig}, {"tfInnerBatchTxn", tfInnerBatchTxn}};
-    return flags;
-}
+// NFTokenMint flags:
+constexpr std::uint32_t const tfBurnable                   = 0x00000001;
+constexpr std::uint32_t const tfOnlyXRP                    = 0x00000002;
+constexpr std::uint32_t const tfTrustLine                  = 0x00000004;
+constexpr std::uint32_t const tfTransferable               = 0x00000008;
+constexpr std::uint32_t const tfMutable                    = 0x00000010;
 
-// Create a getter function for all transaction flag maps using Meyer's singleton pattern.
-// This is used to generate the server_definitions RPC output.
-//
-// example:
-// inline FlagMapPairList const& getAllTxFlags() {
-//     static FlagMapPairList const flags = {
-//         {"AccountSet", getAccountSetFlags()},
-//     ...};
-//     return flags;
-// }
-using FlagMapPairList = std::vector<std::pair<std::string, FlagMap>>;
-#define ALL_TX_FLAGS(name, values, maskAdj) {#name, get##name##Flags()},
-inline FlagMapPairList const&
-getAllTxFlags()
-{
-    static FlagMapPairList const flags = {
-        {"universal", getUniversalFlags()},
-        XMACRO(ALL_TX_FLAGS, NULL_OUTPUT, NULL_OUTPUT, NULL_MASK_ADJ)};
-    return flags;
-}
-
-#undef XMACRO
-#undef TO_VALUE
-#undef VALUE_TO_MAP
-#undef NULL_NAME
-#undef NULL_OUTPUT
-#undef TO_MAP
-#undef TO_MASK
-#undef VALUE_TO_MASK
-#undef ALL_TX_FLAGS
-#undef NULL_MASK_ADJ
-#undef MASK_ADJ_TO_MASK
-
-#pragma pop_macro("XMACRO")
-#pragma pop_macro("TO_VALUE")
-#pragma pop_macro("VALUE_TO_MAP")
-#pragma pop_macro("NULL_NAME")
-#pragma pop_macro("NULL_OUTPUT")
-#pragma pop_macro("TO_MAP")
-#pragma pop_macro("TO_MASK")
-#pragma pop_macro("VALUE_TO_MASK")
-#pragma pop_macro("ALL_TX_FLAGS")
-#pragma pop_macro("NULL_MASK_ADJ")
-#pragma pop_macro("MASK_ADJ_TO_MASK")
-
-// Additional transaction masks and combos
-inline constexpr FlagValue tfMPTPaymentMask = ~(tfUniversal | tfPartialPayment);
-inline constexpr FlagValue tfTrustSetPermissionMask =
-    ~(tfUniversal | tfSetfAuth | tfSetFreeze | tfClearFreeze);
+// MPTokenIssuanceCreate flags:
+// Note: tf/lsfMPTLocked is intentionally omitted, since this transaction
+// is not allowed to modify it.
+constexpr std::uint32_t const tfMPTCanLock                 = lsfMPTCanLock;
+constexpr std::uint32_t const tfMPTRequireAuth             = lsfMPTRequireAuth;
+constexpr std::uint32_t const tfMPTCanEscrow               = lsfMPTCanEscrow;
+constexpr std::uint32_t const tfMPTCanTrade                = lsfMPTCanTrade;
+constexpr std::uint32_t const tfMPTCanTransfer             = lsfMPTCanTransfer;
+constexpr std::uint32_t const tfMPTCanClawback             = lsfMPTCanClawback;
+constexpr std::uint32_t const tfMPTokenIssuanceCreateMask  =
+  ~(tfUniversal | tfMPTCanLock | tfMPTRequireAuth | tfMPTCanEscrow | tfMPTCanTrade | tfMPTCanTransfer | tfMPTCanClawback);
 
 // MPTokenIssuanceCreate MutableFlags:
 // Indicating specific fields or flags may be changed after issuance.
-inline constexpr FlagValue tmfMPTCanMutateCanLock = lsmfMPTCanMutateCanLock;
-inline constexpr FlagValue tmfMPTCanMutateRequireAuth = lsmfMPTCanMutateRequireAuth;
-inline constexpr FlagValue tmfMPTCanMutateCanEscrow = lsmfMPTCanMutateCanEscrow;
-inline constexpr FlagValue tmfMPTCanMutateCanTrade = lsmfMPTCanMutateCanTrade;
-inline constexpr FlagValue tmfMPTCanMutateCanTransfer = lsmfMPTCanMutateCanTransfer;
-inline constexpr FlagValue tmfMPTCanMutateCanClawback = lsmfMPTCanMutateCanClawback;
-inline constexpr FlagValue tmfMPTCanMutateMetadata = lsmfMPTCanMutateMetadata;
-inline constexpr FlagValue tmfMPTCanMutateTransferFee = lsmfMPTCanMutateTransferFee;
-inline constexpr FlagValue tmfMPTokenIssuanceCreateMutableMask =
-    ~(tmfMPTCanMutateCanLock | tmfMPTCanMutateRequireAuth | tmfMPTCanMutateCanEscrow |
-      tmfMPTCanMutateCanTrade | tmfMPTCanMutateCanTransfer | tmfMPTCanMutateCanClawback |
-      tmfMPTCanMutateMetadata | tmfMPTCanMutateTransferFee);
+constexpr std::uint32_t const tmfMPTCanMutateCanLock = lsmfMPTCanMutateCanLock;
+constexpr std::uint32_t const tmfMPTCanMutateRequireAuth = lsmfMPTCanMutateRequireAuth;
+constexpr std::uint32_t const tmfMPTCanMutateCanEscrow = lsmfMPTCanMutateCanEscrow;
+constexpr std::uint32_t const tmfMPTCanMutateCanTrade = lsmfMPTCanMutateCanTrade;
+constexpr std::uint32_t const tmfMPTCanMutateCanTransfer = lsmfMPTCanMutateCanTransfer;
+constexpr std::uint32_t const tmfMPTCanMutateCanClawback = lsmfMPTCanMutateCanClawback;
+constexpr std::uint32_t const tmfMPTCanMutateMetadata = lsmfMPTCanMutateMetadata;
+constexpr std::uint32_t const tmfMPTCanMutateTransferFee = lsmfMPTCanMutateTransferFee;
+constexpr std::uint32_t const tmfMPTokenIssuanceCreateMutableMask =
+  ~(tmfMPTCanMutateCanLock | tmfMPTCanMutateRequireAuth | tmfMPTCanMutateCanEscrow | tmfMPTCanMutateCanTrade
+    | tmfMPTCanMutateCanTransfer | tmfMPTCanMutateCanClawback | tmfMPTCanMutateMetadata | tmfMPTCanMutateTransferFee);
+
+// MPTokenAuthorize flags:
+constexpr std::uint32_t const tfMPTUnauthorize             = 0x00000001;
+constexpr std::uint32_t const tfMPTokenAuthorizeMask  = ~(tfUniversal | tfMPTUnauthorize);
+
+// MPTokenIssuanceSet flags:
+constexpr std::uint32_t const tfMPTLock                   = 0x00000001;
+constexpr std::uint32_t const tfMPTUnlock                 = 0x00000002;
+constexpr std::uint32_t const tfMPTokenIssuanceSetMask  = ~(tfUniversal | tfMPTLock | tfMPTUnlock);
+constexpr std::uint32_t const tfMPTokenIssuanceSetPermissionMask = ~(tfUniversal | tfMPTLock | tfMPTUnlock);
 
 // MPTokenIssuanceSet MutableFlags:
 // Set or Clear flags.
+constexpr std::uint32_t const tmfMPTSetCanLock             = 0x00000001;
+constexpr std::uint32_t const tmfMPTClearCanLock           = 0x00000002;
+constexpr std::uint32_t const tmfMPTSetRequireAuth         = 0x00000004;
+constexpr std::uint32_t const tmfMPTClearRequireAuth       = 0x00000008;
+constexpr std::uint32_t const tmfMPTSetCanEscrow           = 0x00000010;
+constexpr std::uint32_t const tmfMPTClearCanEscrow         = 0x00000020;
+constexpr std::uint32_t const tmfMPTSetCanTrade            = 0x00000040;
+constexpr std::uint32_t const tmfMPTClearCanTrade          = 0x00000080;
+constexpr std::uint32_t const tmfMPTSetCanTransfer         = 0x00000100;
+constexpr std::uint32_t const tmfMPTClearCanTransfer       = 0x00000200;
+constexpr std::uint32_t const tmfMPTSetCanClawback         = 0x00000400;
+constexpr std::uint32_t const tmfMPTClearCanClawback       = 0x00000800;
+constexpr std::uint32_t const tmfMPTokenIssuanceSetMutableMask = ~(tmfMPTSetCanLock | tmfMPTClearCanLock |
+    tmfMPTSetRequireAuth | tmfMPTClearRequireAuth | tmfMPTSetCanEscrow | tmfMPTClearCanEscrow |
+    tmfMPTSetCanTrade | tmfMPTClearCanTrade | tmfMPTSetCanTransfer | tmfMPTClearCanTransfer |
+    tmfMPTSetCanClawback | tmfMPTClearCanClawback);
 
-inline constexpr FlagValue tmfMPTSetCanLock = 0x00000001;
-inline constexpr FlagValue tmfMPTClearCanLock = 0x00000002;
-inline constexpr FlagValue tmfMPTSetRequireAuth = 0x00000004;
-inline constexpr FlagValue tmfMPTClearRequireAuth = 0x00000008;
-inline constexpr FlagValue tmfMPTSetCanEscrow = 0x00000010;
-inline constexpr FlagValue tmfMPTClearCanEscrow = 0x00000020;
-inline constexpr FlagValue tmfMPTSetCanTrade = 0x00000040;
-inline constexpr FlagValue tmfMPTClearCanTrade = 0x00000080;
-inline constexpr FlagValue tmfMPTSetCanTransfer = 0x00000100;
-inline constexpr FlagValue tmfMPTClearCanTransfer = 0x00000200;
-inline constexpr FlagValue tmfMPTSetCanClawback = 0x00000400;
-inline constexpr FlagValue tmfMPTClearCanClawback = 0x00000800;
-inline constexpr FlagValue tmfMPTokenIssuanceSetMutableMask = ~(
-    tmfMPTSetCanLock | tmfMPTClearCanLock | tmfMPTSetRequireAuth | tmfMPTClearRequireAuth |
-    tmfMPTSetCanEscrow | tmfMPTClearCanEscrow | tmfMPTSetCanTrade | tmfMPTClearCanTrade |
-    tmfMPTSetCanTransfer | tmfMPTClearCanTransfer | tmfMPTSetCanClawback | tmfMPTClearCanClawback);
+// MPTokenIssuanceDestroy flags:
+constexpr std::uint32_t const tfMPTokenIssuanceDestroyMask  = ~tfUniversal;
 
-// Prior to fixRemoveNFTokenAutoTrustLine, transfer of an NFToken between accounts allowed a
-// TrustLine to be added to the issuer of that token without explicit permission from that issuer.
-// This was enabled by minting the NFToken with the tfTrustLine flag set.
+// Prior to fixRemoveNFTokenAutoTrustLine, transfer of an NFToken between
+// accounts allowed a TrustLine to be added to the issuer of that token
+// without explicit permission from that issuer.  This was enabled by
+// minting the NFToken with the tfTrustLine flag set.
 //
-// That capability could be used to attack the NFToken issuer.
-// It would be possible for two accounts to trade the NFToken back and forth building up any number
-// of TrustLines on the issuer, increasing the issuer's reserve without bound.
+// That capability could be used to attack the NFToken issuer.  It
+// would be possible for two accounts to trade the NFToken back and forth
+// building up any number of TrustLines on the issuer, increasing the
+// issuer's reserve without bound.
 //
-// The fixRemoveNFTokenAutoTrustLine amendment disables minting with the tfTrustLine flag as a way
-// to prevent the attack. But until the amendment passes we still need to keep the old behavior
-// available.
-inline constexpr FlagValue tfTrustLine = 0x00000004;  // needed for backwards compatibility
-inline constexpr FlagValue tfNFTokenMintMaskWithoutMutable =
+// The fixRemoveNFTokenAutoTrustLine amendment disables minting with the
+// tfTrustLine flag as a way to prevent the attack.  But until the
+// amendment passes we still need to keep the old behavior available.
+constexpr std::uint32_t const tfNFTokenMintMask =
     ~(tfUniversal | tfBurnable | tfOnlyXRP | tfTransferable);
 
-inline constexpr FlagValue tfNFTokenMintOldMask = ~(~tfNFTokenMintMaskWithoutMutable | tfTrustLine);
+constexpr std::uint32_t const tfNFTokenMintOldMask =
+    ~( ~tfNFTokenMintMask | tfTrustLine);
 
 // if featureDynamicNFT enabled then new flag allowing mutable URI available.
-inline constexpr FlagValue tfNFTokenMintOldMaskWithMutable = ~(~tfNFTokenMintOldMask | tfMutable);
+constexpr std::uint32_t const tfNFTokenMintOldMaskWithMutable =
+    ~( ~tfNFTokenMintOldMask | tfMutable);
 
-inline constexpr FlagValue tfWithdrawSubTx = tfLPToken | tfSingleAsset | tfTwoAsset |
-    tfOneAssetLPToken | tfLimitLPToken | tfWithdrawAll | tfOneAssetWithdrawAll;
-inline constexpr FlagValue tfDepositSubTx =
-    tfLPToken | tfSingleAsset | tfTwoAsset | tfOneAssetLPToken | tfLimitLPToken | tfTwoAssetIfEmpty;
+constexpr std::uint32_t const tfNFTokenMintMaskWithMutable =
+    ~( ~tfNFTokenMintMask | tfMutable);
 
-#pragma push_macro("ACCOUNTSET_FLAGS")
-#pragma push_macro("ACCOUNTSET_FLAG_TO_VALUE")
-#pragma push_macro("ACCOUNTSET_FLAG_TO_MAP")
+// NFTokenCreateOffer flags:
+constexpr std::uint32_t const tfSellNFToken                = 0x00000001;
+constexpr std::uint32_t const tfNFTokenCreateOfferMask =
+    ~(tfUniversal | tfSellNFToken);
 
-// AccountSet SetFlag/ClearFlag values
-#define ACCOUNTSET_FLAGS(ASF_FLAG)                \
-    ASF_FLAG(asfRequireDest, 1)                   \
-    ASF_FLAG(asfRequireAuth, 2)                   \
-    ASF_FLAG(asfDisallowXRP, 3)                   \
-    ASF_FLAG(asfDisableMaster, 4)                 \
-    ASF_FLAG(asfAccountTxnID, 5)                  \
-    ASF_FLAG(asfNoFreeze, 6)                      \
-    ASF_FLAG(asfGlobalFreeze, 7)                  \
-    ASF_FLAG(asfDefaultRipple, 8)                 \
-    ASF_FLAG(asfDepositAuth, 9)                   \
-    ASF_FLAG(asfAuthorizedNFTokenMinter, 10)      \
-    /*  11 is reserved for Hooks amendment */     \
-    /* ASF_FLAG(asfTshCollect, 11) */             \
-    ASF_FLAG(asfDisallowIncomingNFTokenOffer, 12) \
-    ASF_FLAG(asfDisallowIncomingCheck, 13)        \
-    ASF_FLAG(asfDisallowIncomingPayChan, 14)      \
-    ASF_FLAG(asfDisallowIncomingTrustline, 15)    \
-    ASF_FLAG(asfAllowTrustLineClawback, 16)       \
-    ASF_FLAG(asfAllowTrustLineLocking, 17)
+// NFTokenCancelOffer flags:
+constexpr std::uint32_t const tfNFTokenCancelOfferMask     = ~tfUniversal;
 
-#define ACCOUNTSET_FLAG_TO_VALUE(name, value) inline constexpr FlagValue name = value;
-#define ACCOUNTSET_FLAG_TO_MAP(name, value) {#name, value},
+// NFTokenAcceptOffer flags:
+constexpr std::uint32_t const tfNFTokenAcceptOfferMask     = ~tfUniversal;
 
-ACCOUNTSET_FLAGS(ACCOUNTSET_FLAG_TO_VALUE)
+// Clawback flags:
+constexpr std::uint32_t const tfClawbackMask               = ~tfUniversal;
 
-inline std::map<std::string, FlagValue> const&
-getAsfFlagMap()
-{
-    static std::map<std::string, FlagValue> const flags = {
-        ACCOUNTSET_FLAGS(ACCOUNTSET_FLAG_TO_MAP)};
-    return flags;
-}
+// AMM Flags:
+constexpr std::uint32_t tfLPToken                          = 0x00010000;
+constexpr std::uint32_t tfWithdrawAll                      = 0x00020000;
+constexpr std::uint32_t tfOneAssetWithdrawAll              = 0x00040000;
+constexpr std::uint32_t tfSingleAsset                      = 0x00080000;
+constexpr std::uint32_t tfTwoAsset                         = 0x00100000;
+constexpr std::uint32_t tfOneAssetLPToken                  = 0x00200000;
+constexpr std::uint32_t tfLimitLPToken                     = 0x00400000;
+constexpr std::uint32_t tfTwoAssetIfEmpty                  = 0x00800000;
+constexpr std::uint32_t tfWithdrawSubTx =
+    tfLPToken | tfSingleAsset | tfTwoAsset | tfOneAssetLPToken |
+    tfLimitLPToken | tfWithdrawAll | tfOneAssetWithdrawAll;
+constexpr std::uint32_t tfDepositSubTx =
+    tfLPToken | tfSingleAsset | tfTwoAsset | tfOneAssetLPToken |
+    tfLimitLPToken | tfTwoAssetIfEmpty;
+constexpr std::uint32_t tfWithdrawMask = ~(tfUniversal | tfWithdrawSubTx);
+constexpr std::uint32_t tfDepositMask = ~(tfUniversal | tfDepositSubTx);
 
-#undef ACCOUNTSET_FLAG_TO_VALUE
-#undef ACCOUNTSET_FLAG_TO_MAP
-#undef ACCOUNTSET_FLAGS
+// AMMClawback flags:
+constexpr std::uint32_t tfClawTwoAssets                = 0x00000001;
+constexpr std::uint32_t tfAMMClawbackMask = ~(tfUniversal | tfClawTwoAssets);
 
-#pragma pop_macro("ACCOUNTSET_FLAG_TO_VALUE")
-#pragma pop_macro("ACCOUNTSET_FLAG_TO_MAP")
-#pragma pop_macro("ACCOUNTSET_FLAGS")
+// BridgeModify flags:
+constexpr std::uint32_t tfClearAccountCreateAmount     = 0x00010000;
+constexpr std::uint32_t tfBridgeModifyMask = ~(tfUniversal | tfClearAccountCreateAmount);
+
+// VaultCreate flags:
+constexpr std::uint32_t const tfVaultPrivate               = 0x00010000;
+static_assert(tfVaultPrivate == lsfVaultPrivate);
+constexpr std::uint32_t const tfVaultShareNonTransferable  = 0x00020000;
+constexpr std::uint32_t const tfVaultCreateMask = ~(tfUniversal | tfVaultPrivate | tfVaultShareNonTransferable);
+
+// Batch Flags:
+constexpr std::uint32_t tfAllOrNothing                 = 0x00010000;
+constexpr std::uint32_t tfOnlyOne                      = 0x00020000;
+constexpr std::uint32_t tfUntilFailure                 = 0x00040000;
+constexpr std::uint32_t tfIndependent                  = 0x00080000;
+/**
+ * @note If nested Batch transactions are supported in the future, the tfInnerBatchTxn flag
+ *  will need to be removed from this mask to allow Batch transaction to be inside
+ *  the sfRawTransactions array.
+ */
+constexpr std::uint32_t const tfBatchMask =
+    ~(tfUniversal | tfAllOrNothing | tfOnlyOne | tfUntilFailure | tfIndependent) | tfInnerBatchTxn;
+
+// LoanSet and LoanPay flags:
+// LoanSet: True, indicates the loan supports overpayments
+// LoanPay: True, indicates any excess in this payment can be used
+// as an overpayment. False, no overpayments will be taken.
+constexpr std::uint32_t const tfLoanOverpayment = 0x00010000;
+// LoanPay exclusive flags:
+// tfLoanFullPayment: True, indicates that the payment is an early
+// full payment. It must pay the entire loan including close
+// interest and fees, or it will fail. False: Not a full payment.
+constexpr std::uint32_t const tfLoanFullPayment = 0x00020000;
+// tfLoanLatePayment: True, indicates that the payment is late,
+// and includes late interest and fees. If the loan is not late,
+// it will fail. False: not a late payment. If the current payment
+// is overdue, the transaction will fail.
+constexpr std::uint32_t const tfLoanLatePayment = 0x00040000;
+constexpr std::uint32_t const tfLoanSetMask = ~(tfUniversal |
+    tfLoanOverpayment);
+constexpr std::uint32_t const tfLoanPayMask = ~(tfUniversal |
+    tfLoanOverpayment | tfLoanFullPayment | tfLoanLatePayment);
+
+// LoanManage flags:
+constexpr std::uint32_t const tfLoanDefault = 0x00010000;
+constexpr std::uint32_t const tfLoanImpair = 0x00020000;
+constexpr std::uint32_t const tfLoanUnimpair = 0x00040000;
+constexpr std::uint32_t const tfLoanManageMask = ~(tfUniversal | tfLoanDefault | tfLoanImpair | tfLoanUnimpair);
+
+// clang-format on
 
 }  // namespace xrpl

include/xrpl/protocol/TxFormats.h

@@ -2,8 +2,6 @@
 
 #include <xrpl/protocol/KnownFormats.h>
 
-#include <vector>
-
 namespace xrpl {
 
 /** Transaction type identifiers.
@@ -75,9 +73,6 @@ private:
 public:
     static TxFormats const&
     getInstance();
-
-    static std::vector<SOElement> const&
-    getCommonFields();
 };
 
 }  // namespace xrpl

include/xrpl/protocol/detail/transactions.macro

@@ -22,7 +22,7 @@
 
 /** This transaction type executes a payment. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/payment/Payment.h>
+#   include <xrpl/tx/transactors/Payment.h>
 #endif
 TRANSACTION(ttPAYMENT, 0, Payment,
     Delegation::delegable,
@@ -42,7 +42,7 @@ TRANSACTION(ttPAYMENT, 0, Payment,
 
 /** This transaction type creates an escrow object. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/escrow/Escrow.h>
+#   include <xrpl/tx/transactors/Escrow.h>
 #endif
 TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate,
     Delegation::delegable,
@@ -73,7 +73,7 @@ TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish,
 
 /** This transaction type adjusts various account settings. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/account/SetAccount.h>
+#   include <xrpl/tx/transactors/SetAccount.h>
 #endif
 TRANSACTION(ttACCOUNT_SET, 3, AccountSet,
     Delegation::notDelegable,
@@ -94,7 +94,7 @@ TRANSACTION(ttACCOUNT_SET, 3, AccountSet,
 
 /** This transaction type cancels an existing escrow. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/escrow/Escrow.h>
+#   include <xrpl/tx/transactors/Escrow.h>
 #endif
 TRANSACTION(ttESCROW_CANCEL, 4, EscrowCancel,
     Delegation::delegable,
@@ -107,7 +107,7 @@ TRANSACTION(ttESCROW_CANCEL, 4, EscrowCancel,
 
 /** This transaction type sets or clears an account's "regular key". */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/account/SetRegularKey.h>
+#   include <xrpl/tx/transactors/SetRegularKey.h>
 #endif
 TRANSACTION(ttREGULAR_KEY_SET, 5, SetRegularKey,
     Delegation::notDelegable,
@@ -121,7 +121,7 @@ TRANSACTION(ttREGULAR_KEY_SET, 5, SetRegularKey,
 
 /** This transaction type creates an offer to trade one asset for another. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/dex/CreateOffer.h>
+#   include <xrpl/tx/transactors/Offer/CreateOffer.h>
 #endif
 TRANSACTION(ttOFFER_CREATE, 7, OfferCreate,
     Delegation::delegable,
@@ -137,7 +137,7 @@ TRANSACTION(ttOFFER_CREATE, 7, OfferCreate,
 
 /** This transaction type cancels existing offers to trade one asset for another. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/dex/CancelOffer.h>
+#   include <xrpl/tx/transactors/Offer/CancelOffer.h>
 #endif
 TRANSACTION(ttOFFER_CANCEL, 8, OfferCancel,
     Delegation::delegable,
@@ -151,7 +151,7 @@ TRANSACTION(ttOFFER_CANCEL, 8, OfferCancel,
 
 /** This transaction type creates a new set of tickets. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/system/CreateTicket.h>
+#   include <xrpl/tx/transactors/CreateTicket.h>
 #endif
 TRANSACTION(ttTICKET_CREATE, 10, TicketCreate,
     Delegation::delegable,
@@ -167,7 +167,7 @@ TRANSACTION(ttTICKET_CREATE, 10, TicketCreate,
 // The SignerEntries are optional because a SignerList is deleted by
 // setting the SignerQuorum to zero and omitting SignerEntries.
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/account/SetSignerList.h>
+#   include <xrpl/tx/transactors/SetSignerList.h>
 #endif
 TRANSACTION(ttSIGNER_LIST_SET, 12, SignerListSet,
     Delegation::notDelegable,
@@ -180,7 +180,7 @@ TRANSACTION(ttSIGNER_LIST_SET, 12, SignerListSet,
 
 /** This transaction type creates a new unidirectional XRP payment channel. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/payment_channel/PayChan.h>
+#   include <xrpl/tx/transactors/PayChan.h>
 #endif
 TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate,
     Delegation::delegable,
@@ -222,7 +222,7 @@ TRANSACTION(ttPAYCHAN_CLAIM, 15, PaymentChannelClaim,
 
 /** This transaction type creates a new check. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/check/CreateCheck.h>
+#   include <xrpl/tx/transactors/Check/CreateCheck.h>
 #endif
 TRANSACTION(ttCHECK_CREATE, 16, CheckCreate,
     Delegation::delegable,
@@ -238,7 +238,7 @@ TRANSACTION(ttCHECK_CREATE, 16, CheckCreate,
 
 /** This transaction type cashes an existing check. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/check/CashCheck.h>
+#   include <xrpl/tx/transactors/Check/CashCheck.h>
 #endif
 TRANSACTION(ttCHECK_CASH, 17, CheckCash,
     Delegation::delegable,
@@ -252,7 +252,7 @@ TRANSACTION(ttCHECK_CASH, 17, CheckCash,
 
 /** This transaction type cancels an existing check. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/check/CancelCheck.h>
+#   include <xrpl/tx/transactors/Check/CancelCheck.h>
 #endif
 TRANSACTION(ttCHECK_CANCEL, 18, CheckCancel,
     Delegation::delegable,
@@ -264,7 +264,7 @@ TRANSACTION(ttCHECK_CANCEL, 18, CheckCancel,
 
 /** This transaction type grants or revokes authorization to transfer funds. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/payment/DepositPreauth.h>
+#   include <xrpl/tx/transactors/DepositPreauth.h>
 #endif
 TRANSACTION(ttDEPOSIT_PREAUTH, 19, DepositPreauth,
     Delegation::delegable,
@@ -279,7 +279,7 @@ TRANSACTION(ttDEPOSIT_PREAUTH, 19, DepositPreauth,
 
 /** This transaction type modifies a trustline between two accounts. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/token/SetTrust.h>
+#   include <xrpl/tx/transactors/SetTrust.h>
 #endif
 TRANSACTION(ttTRUST_SET, 20, TrustSet,
     Delegation::delegable,
@@ -293,7 +293,7 @@ TRANSACTION(ttTRUST_SET, 20, TrustSet,
 
 /** This transaction type deletes an existing account. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/account/DeleteAccount.h>
+#   include <xrpl/tx/transactors/DeleteAccount.h>
 #endif
 TRANSACTION(ttACCOUNT_DELETE, 21, AccountDelete,
     Delegation::notDelegable,
@@ -309,7 +309,7 @@ TRANSACTION(ttACCOUNT_DELETE, 21, AccountDelete,
 
 /** This transaction mints a new NFT. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/nft/NFTokenMint.h>
+#   include <xrpl/tx/transactors/NFT/NFTokenMint.h>
 #endif
 TRANSACTION(ttNFTOKEN_MINT, 25, NFTokenMint,
     Delegation::delegable,
@@ -327,7 +327,7 @@ TRANSACTION(ttNFTOKEN_MINT, 25, NFTokenMint,
 
 /** This transaction burns (i.e. destroys) an existing NFT. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/nft/NFTokenBurn.h>
+#   include <xrpl/tx/transactors/NFT/NFTokenBurn.h>
 #endif
 TRANSACTION(ttNFTOKEN_BURN, 26, NFTokenBurn,
     Delegation::delegable,
@@ -340,7 +340,7 @@ TRANSACTION(ttNFTOKEN_BURN, 26, NFTokenBurn,
 
 /** This transaction creates a new offer to buy or sell an NFT. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/nft/NFTokenCreateOffer.h>
+#   include <xrpl/tx/transactors/NFT/NFTokenCreateOffer.h>
 #endif
 TRANSACTION(ttNFTOKEN_CREATE_OFFER, 27, NFTokenCreateOffer,
     Delegation::delegable,
@@ -356,7 +356,7 @@ TRANSACTION(ttNFTOKEN_CREATE_OFFER, 27, NFTokenCreateOffer,
 
 /** This transaction cancels an existing offer to buy or sell an existing NFT. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/nft/NFTokenCancelOffer.h>
+#   include <xrpl/tx/transactors/NFT/NFTokenCancelOffer.h>
 #endif
 TRANSACTION(ttNFTOKEN_CANCEL_OFFER, 28, NFTokenCancelOffer,
     Delegation::delegable,
@@ -368,7 +368,7 @@ TRANSACTION(ttNFTOKEN_CANCEL_OFFER, 28, NFTokenCancelOffer,
 
 /** This transaction accepts an existing offer to buy or sell an existing  NFT. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/nft/NFTokenAcceptOffer.h>
+#   include <xrpl/tx/transactors/NFT/NFTokenAcceptOffer.h>
 #endif
 TRANSACTION(ttNFTOKEN_ACCEPT_OFFER, 29, NFTokenAcceptOffer,
     Delegation::delegable,
@@ -382,7 +382,7 @@ TRANSACTION(ttNFTOKEN_ACCEPT_OFFER, 29, NFTokenAcceptOffer,
 
 /** This transaction claws back issued tokens. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/token/Clawback.h>
+#   include <xrpl/tx/transactors/Clawback.h>
 #endif
 TRANSACTION(ttCLAWBACK, 30, Clawback,
     Delegation::delegable,
@@ -395,7 +395,7 @@ TRANSACTION(ttCLAWBACK, 30, Clawback,
 
 /** This transaction claws back tokens from an AMM pool. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/dex/AMMClawback.h>
+#   include <xrpl/tx/transactors/AMM/AMMClawback.h>
 #endif
 TRANSACTION(ttAMM_CLAWBACK, 31, AMMClawback,
     Delegation::delegable,
@@ -410,7 +410,7 @@ TRANSACTION(ttAMM_CLAWBACK, 31, AMMClawback,
 
 /** This transaction type creates an AMM instance */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/dex/AMMCreate.h>
+#   include <xrpl/tx/transactors/AMM/AMMCreate.h>
 #endif
 TRANSACTION(ttAMM_CREATE, 35, AMMCreate,
     Delegation::delegable,
@@ -424,7 +424,7 @@ TRANSACTION(ttAMM_CREATE, 35, AMMCreate,
 
 /** This transaction type deposits into an AMM instance */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/dex/AMMDeposit.h>
+#   include <xrpl/tx/transactors/AMM/AMMDeposit.h>
 #endif
 TRANSACTION(ttAMM_DEPOSIT, 36, AMMDeposit,
     Delegation::delegable,
@@ -442,7 +442,7 @@ TRANSACTION(ttAMM_DEPOSIT, 36, AMMDeposit,
 
 /** This transaction type withdraws from an AMM instance */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/dex/AMMWithdraw.h>
+#   include <xrpl/tx/transactors/AMM/AMMWithdraw.h>
 #endif
 TRANSACTION(ttAMM_WITHDRAW, 37, AMMWithdraw,
     Delegation::delegable,
@@ -459,7 +459,7 @@ TRANSACTION(ttAMM_WITHDRAW, 37, AMMWithdraw,
 
 /** This transaction type votes for the trading fee */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/dex/AMMVote.h>
+#   include <xrpl/tx/transactors/AMM/AMMVote.h>
 #endif
 TRANSACTION(ttAMM_VOTE, 38, AMMVote,
     Delegation::delegable,
@@ -473,7 +473,7 @@ TRANSACTION(ttAMM_VOTE, 38, AMMVote,
 
 /** This transaction type bids for the auction slot */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/dex/AMMBid.h>
+#   include <xrpl/tx/transactors/AMM/AMMBid.h>
 #endif
 TRANSACTION(ttAMM_BID, 39, AMMBid,
     Delegation::delegable,
@@ -489,7 +489,7 @@ TRANSACTION(ttAMM_BID, 39, AMMBid,
 
 /** This transaction type deletes AMM in the empty state */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/dex/AMMDelete.h>
+#   include <xrpl/tx/transactors/AMM/AMMDelete.h>
 #endif
 TRANSACTION(ttAMM_DELETE, 40, AMMDelete,
     Delegation::delegable,
@@ -502,7 +502,7 @@ TRANSACTION(ttAMM_DELETE, 40, AMMDelete,
 
 /** This transactions creates a crosschain sequence number */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/bridge/XChainBridge.h>
+#   include <xrpl/tx/transactors/XChainBridge.h>
 #endif
 TRANSACTION(ttXCHAIN_CREATE_CLAIM_ID, 41, XChainCreateClaimID,
     Delegation::delegable,
@@ -617,7 +617,7 @@ TRANSACTION(ttXCHAIN_CREATE_BRIDGE, 48, XChainCreateBridge,
 
 /** This transaction type creates or updates a DID */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/did/DID.h>
+#   include <xrpl/tx/transactors/DID.h>
 #endif
 TRANSACTION(ttDID_SET, 49, DIDSet,
     Delegation::delegable,
@@ -638,7 +638,7 @@ TRANSACTION(ttDID_DELETE, 50, DIDDelete,
 
 /** This transaction type creates an Oracle instance */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/oracle/SetOracle.h>
+#   include <xrpl/tx/transactors/SetOracle.h>
 #endif
 TRANSACTION(ttORACLE_SET, 51, OracleSet,
     Delegation::delegable,
@@ -655,7 +655,7 @@ TRANSACTION(ttORACLE_SET, 51, OracleSet,
 
 /** This transaction type deletes an Oracle instance */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/oracle/DeleteOracle.h>
+#   include <xrpl/tx/transactors/DeleteOracle.h>
 #endif
 TRANSACTION(ttORACLE_DELETE, 52, OracleDelete,
     Delegation::delegable,
@@ -667,7 +667,7 @@ TRANSACTION(ttORACLE_DELETE, 52, OracleDelete,
 
 /** This transaction type fixes a problem in the ledger state */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/system/LedgerStateFix.h>
+#   include <xrpl/tx/transactors/LedgerStateFix.h>
 #endif
 TRANSACTION(ttLEDGER_STATE_FIX, 53, LedgerStateFix,
     Delegation::delegable,
@@ -680,7 +680,7 @@ TRANSACTION(ttLEDGER_STATE_FIX, 53, LedgerStateFix,
 
 /** This transaction type creates a MPTokensIssuance instance */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/token/MPTokenIssuanceCreate.h>
+#   include <xrpl/tx/transactors/MPT/MPTokenIssuanceCreate.h>
 #endif
 TRANSACTION(ttMPTOKEN_ISSUANCE_CREATE, 54, MPTokenIssuanceCreate,
     Delegation::delegable,
@@ -697,7 +697,7 @@ TRANSACTION(ttMPTOKEN_ISSUANCE_CREATE, 54, MPTokenIssuanceCreate,
 
 /** This transaction type destroys a MPTokensIssuance instance */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/token/MPTokenIssuanceDestroy.h>
+#   include <xrpl/tx/transactors/MPT/MPTokenIssuanceDestroy.h>
 #endif
 TRANSACTION(ttMPTOKEN_ISSUANCE_DESTROY, 55, MPTokenIssuanceDestroy,
     Delegation::delegable,
@@ -709,7 +709,7 @@ TRANSACTION(ttMPTOKEN_ISSUANCE_DESTROY, 55, MPTokenIssuanceDestroy,
 
 /** This transaction type sets flags on a MPTokensIssuance or MPToken instance */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/token/MPTokenIssuanceSet.h>
+#   include <xrpl/tx/transactors/MPT/MPTokenIssuanceSet.h>
 #endif
 TRANSACTION(ttMPTOKEN_ISSUANCE_SET, 56, MPTokenIssuanceSet,
     Delegation::delegable,
@@ -726,7 +726,7 @@ TRANSACTION(ttMPTOKEN_ISSUANCE_SET, 56, MPTokenIssuanceSet,
 
 /** This transaction type authorizes a MPToken instance */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/token/MPTokenAuthorize.h>
+#   include <xrpl/tx/transactors/MPT/MPTokenAuthorize.h>
 #endif
 TRANSACTION(ttMPTOKEN_AUTHORIZE, 57, MPTokenAuthorize,
     Delegation::delegable,
@@ -739,7 +739,7 @@ TRANSACTION(ttMPTOKEN_AUTHORIZE, 57, MPTokenAuthorize,
 
 /** This transaction type create an Credential instance */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/credentials/Credentials.h>
+#   include <xrpl/tx/transactors/Credentials.h>
 #endif
 TRANSACTION(ttCREDENTIAL_CREATE, 58, CredentialCreate,
     Delegation::delegable,
@@ -775,7 +775,7 @@ TRANSACTION(ttCREDENTIAL_DELETE, 60, CredentialDelete,
 
 /** This transaction type modify a NFToken */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/nft/NFTokenModify.h>
+#   include <xrpl/tx/transactors/NFT/NFTokenModify.h>
 #endif
 TRANSACTION(ttNFTOKEN_MODIFY, 61, NFTokenModify,
     Delegation::delegable,
@@ -789,7 +789,7 @@ TRANSACTION(ttNFTOKEN_MODIFY, 61, NFTokenModify,
 
 /** This transaction type creates or modifies a Permissioned Domain */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/permissioned_domain/PermissionedDomainSet.h>
+#   include <xrpl/tx/transactors/PermissionedDomain/PermissionedDomainSet.h>
 #endif
 TRANSACTION(ttPERMISSIONED_DOMAIN_SET, 62, PermissionedDomainSet,
     Delegation::delegable,
@@ -802,7 +802,7 @@ TRANSACTION(ttPERMISSIONED_DOMAIN_SET, 62, PermissionedDomainSet,
 
 /** This transaction type deletes a Permissioned Domain */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/permissioned_domain/PermissionedDomainDelete.h>
+#   include <xrpl/tx/transactors/PermissionedDomain/PermissionedDomainDelete.h>
 #endif
 TRANSACTION(ttPERMISSIONED_DOMAIN_DELETE, 63, PermissionedDomainDelete,
     Delegation::delegable,
@@ -814,7 +814,7 @@ TRANSACTION(ttPERMISSIONED_DOMAIN_DELETE, 63, PermissionedDomainDelete,
 
 /** This transaction type delegates authorized account specified permissions */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/delegate/DelegateSet.h>
+#   include <xrpl/tx/transactors/Delegate/DelegateSet.h>
 #endif
 TRANSACTION(ttDELEGATE_SET, 64, DelegateSet,
     Delegation::notDelegable,
@@ -827,7 +827,7 @@ TRANSACTION(ttDELEGATE_SET, 64, DelegateSet,
 
 /** This transaction creates a single asset vault. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/vault/VaultCreate.h>
+#   include <xrpl/tx/transactors/Vault/VaultCreate.h>
 #endif
 TRANSACTION(ttVAULT_CREATE, 65, VaultCreate,
     Delegation::delegable,
@@ -845,7 +845,7 @@ TRANSACTION(ttVAULT_CREATE, 65, VaultCreate,
 
 /** This transaction updates a single asset vault. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/vault/VaultSet.h>
+#   include <xrpl/tx/transactors/Vault/VaultSet.h>
 #endif
 TRANSACTION(ttVAULT_SET, 66, VaultSet,
     Delegation::delegable,
@@ -860,7 +860,7 @@ TRANSACTION(ttVAULT_SET, 66, VaultSet,
 
 /** This transaction deletes a single asset vault. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/vault/VaultDelete.h>
+#   include <xrpl/tx/transactors/Vault/VaultDelete.h>
 #endif
 TRANSACTION(ttVAULT_DELETE, 67, VaultDelete,
     Delegation::delegable,
@@ -872,7 +872,7 @@ TRANSACTION(ttVAULT_DELETE, 67, VaultDelete,
 
 /** This transaction trades assets for shares with a vault. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/vault/VaultDeposit.h>
+#   include <xrpl/tx/transactors/Vault/VaultDeposit.h>
 #endif
 TRANSACTION(ttVAULT_DEPOSIT, 68, VaultDeposit,
     Delegation::delegable,
@@ -885,7 +885,7 @@ TRANSACTION(ttVAULT_DEPOSIT, 68, VaultDeposit,
 
 /** This transaction trades shares for assets with a vault. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/vault/VaultWithdraw.h>
+#   include <xrpl/tx/transactors/Vault/VaultWithdraw.h>
 #endif
 TRANSACTION(ttVAULT_WITHDRAW, 69, VaultWithdraw,
     Delegation::delegable,
@@ -900,7 +900,7 @@ TRANSACTION(ttVAULT_WITHDRAW, 69, VaultWithdraw,
 
 /** This transaction claws back tokens from a vault. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/vault/VaultClawback.h>
+#   include <xrpl/tx/transactors/Vault/VaultClawback.h>
 #endif
 TRANSACTION(ttVAULT_CLAWBACK, 70, VaultClawback,
     Delegation::delegable,
@@ -914,7 +914,7 @@ TRANSACTION(ttVAULT_CLAWBACK, 70, VaultClawback,
 
 /** This transaction type batches together transactions. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/system/Batch.h>
+#   include <xrpl/tx/transactors/Batch.h>
 #endif
 TRANSACTION(ttBATCH, 71, Batch,
     Delegation::notDelegable,
@@ -929,7 +929,7 @@ TRANSACTION(ttBATCH, 71, Batch,
 
 /** This transaction creates and updates a Loan Broker */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/lending/LoanBrokerSet.h>
+#   include <xrpl/tx/transactors/Lending/LoanBrokerSet.h>
 #endif
 TRANSACTION(ttLOAN_BROKER_SET, 74, LoanBrokerSet,
     Delegation::delegable,
@@ -946,7 +946,7 @@ TRANSACTION(ttLOAN_BROKER_SET, 74, LoanBrokerSet,
 
 /** This transaction deletes a Loan Broker */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/lending/LoanBrokerDelete.h>
+#   include <xrpl/tx/transactors/Lending/LoanBrokerDelete.h>
 #endif
 TRANSACTION(ttLOAN_BROKER_DELETE, 75, LoanBrokerDelete,
     Delegation::delegable,
@@ -957,7 +957,7 @@ TRANSACTION(ttLOAN_BROKER_DELETE, 75, LoanBrokerDelete,
 
 /** This transaction deposits First Loss Capital into a Loan Broker */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/lending/LoanBrokerCoverDeposit.h>
+#   include <xrpl/tx/transactors/Lending/LoanBrokerCoverDeposit.h>
 #endif
 TRANSACTION(ttLOAN_BROKER_COVER_DEPOSIT, 76, LoanBrokerCoverDeposit,
     Delegation::delegable,
@@ -969,7 +969,7 @@ TRANSACTION(ttLOAN_BROKER_COVER_DEPOSIT, 76, LoanBrokerCoverDeposit,
 
 /** This transaction withdraws First Loss Capital from a Loan Broker */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/lending/LoanBrokerCoverWithdraw.h>
+#   include <xrpl/tx/transactors/Lending/LoanBrokerCoverWithdraw.h>
 #endif
 TRANSACTION(ttLOAN_BROKER_COVER_WITHDRAW, 77, LoanBrokerCoverWithdraw,
     Delegation::delegable,
@@ -984,7 +984,7 @@ TRANSACTION(ttLOAN_BROKER_COVER_WITHDRAW, 77, LoanBrokerCoverWithdraw,
 /** This transaction claws back First Loss Capital from a Loan Broker to
     the issuer of the capital */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/lending/LoanBrokerCoverClawback.h>
+#   include <xrpl/tx/transactors/Lending/LoanBrokerCoverClawback.h>
 #endif
 TRANSACTION(ttLOAN_BROKER_COVER_CLAWBACK, 78, LoanBrokerCoverClawback,
     Delegation::delegable,
@@ -996,7 +996,7 @@ TRANSACTION(ttLOAN_BROKER_COVER_CLAWBACK, 78, LoanBrokerCoverClawback,
 
 /** This transaction creates a Loan */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/lending/LoanSet.h>
+#   include <xrpl/tx/transactors/Lending/LoanSet.h>
 #endif
 TRANSACTION(ttLOAN_SET, 80, LoanSet,
     Delegation::delegable,
@@ -1023,7 +1023,7 @@ TRANSACTION(ttLOAN_SET, 80, LoanSet,
 
 /** This transaction deletes an existing Loan */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/lending/LoanDelete.h>
+#   include <xrpl/tx/transactors/Lending/LoanDelete.h>
 #endif
 TRANSACTION(ttLOAN_DELETE, 81, LoanDelete,
     Delegation::delegable,
@@ -1034,7 +1034,7 @@ TRANSACTION(ttLOAN_DELETE, 81, LoanDelete,
 
 /** This transaction is used to change the delinquency status of an existing Loan */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/lending/LoanManage.h>
+#   include <xrpl/tx/transactors/Lending/LoanManage.h>
 #endif
 TRANSACTION(ttLOAN_MANAGE, 82, LoanManage,
     Delegation::delegable,
@@ -1048,7 +1048,7 @@ TRANSACTION(ttLOAN_MANAGE, 82, LoanManage,
 
 /** The Borrower uses this transaction to make a Payment on the Loan. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/lending/LoanPay.h>
+#   include <xrpl/tx/transactors/Lending/LoanPay.h>
 #endif
 TRANSACTION(ttLOAN_PAY, 84, LoanPay,
     Delegation::delegable,
@@ -1063,7 +1063,7 @@ TRANSACTION(ttLOAN_PAY, 84, LoanPay,
     For details, see: https://xrpl.org/amendments.html
  */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/system/Change.h>
+#   include <xrpl/tx/transactors/Change.h>
 #endif
 TRANSACTION(ttAMENDMENT, 100, EnableAmendment,
     Delegation::notDelegable,

include/xrpl/protocol/jss.h

@@ -25,7 +25,6 @@ namespace jss {
 JSS(AL_size);              // out: GetCounts
 JSS(AL_hit_rate);          // out: GetCounts
 JSS(AcceptedCredentials);  // out: AccountObjects
-JSS(ACCOUNT_SET_FLAGS);    // out: RPC server_definitions
 JSS(Account);              // in: TransactionSign; field.
 JSS(AMMID);                // field
 JSS(Amount);               // in: TransactionSign; field.
@@ -188,7 +187,6 @@ JSS(closed_ledger);           // out: NetworkOPs
 JSS(cluster);                 // out: PeerImp
 JSS(code);                    // out: errors
 JSS(command);                 // in: RPCHandler
-JSS(common);                  // out: RPC server_definitions
 JSS(complete);                // out: NetworkOPs, InboundLedger
 JSS(complete_ledgers);        // out: NetworkOPs, PeerImp
 JSS(consensus);               // out: NetworkOPs, LedgerConsensus
@@ -358,8 +356,6 @@ JSS(ledger_min);              // in, out: AccountTx*
 JSS(ledger_time);             // out: NetworkOPs
 JSS(LEDGER_ENTRY_TYPES);      // out: RPC server_definitions
                               // matches definitions.json format
-JSS(LEDGER_ENTRY_FLAGS);      // out: RPC server_definitions
-JSS(LEDGER_ENTRY_FORMATS);    // out: RPC server_definitions
 JSS(levels);                  // LogLevels
 JSS(limit);                   // in/out: AccountTx*, AccountOffers,
                               //         AccountLines, AccountObjects
@@ -461,7 +457,6 @@ JSS(open);                    // out: handlers/Ledger
 JSS(open_ledger_cost);        // out: SubmitTransaction
 JSS(open_ledger_fee);         // out: TxQ
 JSS(open_ledger_level);       // out: TxQ
-JSS(optionality);             // out: server_definitions
 JSS(oracles);                 // in: get_aggregate_price
 JSS(oracle_document_id);      // in: get_aggregate_price
 JSS(owner);                   // in: LedgerEntry, out: NetworkOPs
@@ -621,8 +616,6 @@ JSS(TRANSACTION_RESULTS);     // out: RPC server_definitions
                               // matches definitions.json format
 JSS(TRANSACTION_TYPES);       // out: RPC server_definitions
                               // matches definitions.json format
-JSS(TRANSACTION_FLAGS);       // out: RPC server_definitions
-JSS(TRANSACTION_FORMATS);     // out: RPC server_definitions
 JSS(TYPES);                   // out: RPC server_definitions
                               // matches definitions.json format
 JSS(transfer_rate);           // out: nft_info (clio)

include/xrpl/shamap/SHAMap.h

@@ -16,6 +16,7 @@
 
 #include <set>
 #include <stack>
+#include <tuple>
 #include <vector>
 
 namespace xrpl {
@@ -253,7 +254,7 @@ public:
     bool
     getNodeFat(
         SHAMapNodeID const& wanted,
-        std::vector<std::pair<SHAMapNodeID, Blob>>& data,
+        std::vector<std::tuple<SHAMapNodeID, Blob, bool>>& data,
         bool fatLeaves,
         std::uint32_t depth) const;
 
@@ -280,10 +281,45 @@ public:
     void
     serializeRoot(Serializer& s) const;
 
+    /** Add a root node to the SHAMap during synchronization.
+     *
+     * This function is used when receiving the root node of a SHAMap from a peer during ledger
+     * synchronization. The node must already have been deserialized.
+     *
+     * @param hash The expected hash of the root node.
+     * @param rootNode A deserialized root node to add.
+     * @param filter Optional sync filter to track received nodes.
+     * @return Status indicating whether the node was useful, duplicate, or invalid.
+     *
+     * @note This function expects the rootNode to be a valid, deserialized SHAMapTreeNode. The
+     *       caller is responsible for deserialization and basic validation before calling this
+     *       function.
+     */
     SHAMapAddNode
-    addRootNode(SHAMapHash const& hash, Slice const& rootNode, SHAMapSyncFilter* filter);
+    addRootNode(
+        SHAMapHash const& hash,
+        intr_ptr::SharedPtr<SHAMapTreeNode> rootNode,
+        SHAMapSyncFilter const* filter);
+
+    /** Add a known node at a specific position in the SHAMap during synchronization.
+     *
+     * This function is used when receiving nodes from peers during ledger synchronization. The node
+     * is inserted at the position specified by nodeID. The node must already have been
+     * deserialized.
+     *
+     * @param nodeID The position in the tree where this node belongs.
+     * @param treeNode A deserialized tree node to add.
+     * @param filter Optional sync filter to track received nodes.
+     * @return Status indicating whether the node was useful, duplicate, or invalid.
+     *
+     * @note This function expects that the caller has already validated that the nodeID is
+     * consistent with the node's content.
+     */
     SHAMapAddNode
-    addKnownNode(SHAMapNodeID const& nodeID, Slice const& rawNode, SHAMapSyncFilter* filter);
+    addKnownNode(
+        SHAMapNodeID const& nodeID,
+        intr_ptr::SharedPtr<SHAMapTreeNode> treeNode,
+        SHAMapSyncFilter const* filter);
 
     // status functions
     void
@@ -344,11 +380,11 @@ private:
     intr_ptr::SharedPtr<SHAMapTreeNode>
     fetchNodeNT(SHAMapHash const& hash) const;
     intr_ptr::SharedPtr<SHAMapTreeNode>
-    fetchNodeNT(SHAMapHash const& hash, SHAMapSyncFilter* filter) const;
+    fetchNodeNT(SHAMapHash const& hash, SHAMapSyncFilter const* filter) const;
     intr_ptr::SharedPtr<SHAMapTreeNode>
     fetchNode(SHAMapHash const& hash) const;
     intr_ptr::SharedPtr<SHAMapTreeNode>
-    checkFilter(SHAMapHash const& hash, SHAMapSyncFilter* filter) const;
+    checkFilter(SHAMapHash const& hash, SHAMapSyncFilter const* filter) const;
 
     /** Update hashes up to the root */
     void
@@ -420,7 +456,7 @@ private:
     descendAsync(
         SHAMapInnerNode* parent,
         int branch,
-        SHAMapSyncFilter* filter,
+        SHAMapSyncFilter const* filter,
         bool& pending,
         descendCallback&&) const;
 
@@ -429,7 +465,7 @@ private:
         SHAMapInnerNode* parent,
         SHAMapNodeID const& parentID,
         int branch,
-        SHAMapSyncFilter* filter) const;
+        SHAMapSyncFilter const* filter) const;
 
     // Non-storing
     // Does not hook the returned node to its parent

include/xrpl/tx/paths/detail/StrandFlow.h

@@ -10,8 +10,8 @@
 #include <xrpl/tx/paths/detail/FlatSets.h>
 #include <xrpl/tx/paths/detail/FlowDebugInfo.h>
 #include <xrpl/tx/paths/detail/Steps.h>
-#include <xrpl/tx/transactors/dex/AMMContext.h>
-#include <xrpl/tx/transactors/dex/AMMHelpers.h>
+#include <xrpl/tx/transactors/AMM/AMMContext.h>
+#include <xrpl/tx/transactors/AMM/AMMHelpers.h>
 
 #include <boost/container/flat_set.hpp>
 

include/xrpl/tx/transactors/Clawback.h

@@ -13,6 +13,9 @@ public:
     {
     }
 
+    static std::uint32_t
+    getFlagsMask(PreflightContext const& ctx);
+
     static NotTEC
     preflight(PreflightContext const& ctx);
 

include/xrpl/tx/transactors/Lending/LoanSet.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <xrpl/tx/Transactor.h>
-#include <xrpl/tx/transactors/lending/LendingHelpers.h>
+#include <xrpl/tx/transactors/Lending/LendingHelpers.h>
 
 namespace xrpl {
 

include/xrpl/tx/transactors/MPT/MPTokenIssuanceDestroy.h

@@ -13,6 +13,9 @@ public:
     {
     }
 
+    static std::uint32_t
+    getFlagsMask(PreflightContext const& ctx);
+
     static NotTEC
     preflight(PreflightContext const& ctx);
 

include/xrpl/tx/transactors/NFT/NFTokenAcceptOffer.h

@@ -26,6 +26,9 @@ public:
     {
     }
 
+    static std::uint32_t
+    getFlagsMask(PreflightContext const& ctx);
+
     static NotTEC
     preflight(PreflightContext const& ctx);
 

include/xrpl/tx/transactors/NFT/NFTokenCancelOffer.h

@@ -13,6 +13,9 @@ public:
     {
     }
 
+    static std::uint32_t
+    getFlagsMask(PreflightContext const& ctx);
+
     static NotTEC
     preflight(PreflightContext const& ctx);
 

include/xrpl/tx/transactors/NFT/NFTokenMint.h

@@ -2,7 +2,7 @@
 
 #include <xrpl/protocol/nft.h>
 #include <xrpl/tx/Transactor.h>
-#include <xrpl/tx/transactors/nft/NFTokenUtils.h>
+#include <xrpl/tx/transactors/NFT/NFTokenUtils.h>
 
 namespace xrpl {
 

src/libxrpl/protocol/LedgerFormats.cpp

@@ -3,23 +3,19 @@
 #include <xrpl/protocol/SOTemplate.h>
 #include <xrpl/protocol/jss.h>
 
-#include <vector>
+#include <initializer_list>
 
 namespace xrpl {
 
-std::vector<SOElement> const&
-LedgerFormats::getCommonFields()
+LedgerFormats::LedgerFormats()
 {
-    static auto const commonFields = std::vector<SOElement>{
+    // Fields shared by all ledger formats:
+    static std::initializer_list<SOElement> const commonFields{
         {sfLedgerIndex, soeOPTIONAL},
         {sfLedgerEntryType, soeREQUIRED},
         {sfFlags, soeREQUIRED},
     };
-    return commonFields;
-}
 
-LedgerFormats::LedgerFormats()
-{
 #pragma push_macro("UNWRAP")
 #undef UNWRAP
 #pragma push_macro("LEDGER_ENTRY")
@@ -27,7 +23,7 @@ LedgerFormats::LedgerFormats()
 
 #define UNWRAP(...) __VA_ARGS__
 #define LEDGER_ENTRY(tag, value, name, rpcName, fields) \
-    add(jss::name, tag, UNWRAP fields, getCommonFields());
+    add(jss::name, tag, UNWRAP fields, commonFields);
 
 #include <xrpl/protocol/detail/ledger_entries.macro>
 

src/libxrpl/protocol/SOTemplate.cpp

@@ -2,32 +2,23 @@
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/SOTemplate.h>
 
-#include <algorithm>
 #include <cstddef>
 #include <initializer_list>
-#include <iterator>
 #include <stdexcept>
-#include <vector>
 
 namespace xrpl {
 
 SOTemplate::SOTemplate(
     std::initializer_list<SOElement> uniqueFields,
     std::initializer_list<SOElement> commonFields)
-    : SOTemplate(std::vector(uniqueFields), std::vector(commonFields))
-{
-}
-
-SOTemplate::SOTemplate(std::vector<SOElement> uniqueFields, std::vector<SOElement> commonFields)
     : indices_(SField::getNumFields() + 1, -1)  // Unmapped indices == -1
 {
     // Add all SOElements.
-    //
-    elements_ = std::move(uniqueFields);
-    std::ranges::move(commonFields, std::back_inserter(elements_));
+    elements_.reserve(uniqueFields.size() + commonFields.size());
+    elements_.assign(uniqueFields);
+    elements_.insert(elements_.end(), commonFields);
 
     // Validate and index elements_.
-    //
     for (std::size_t i = 0; i < elements_.size(); ++i)
     {
         SField const& sField{elements_[i].sField()};

src/libxrpl/protocol/TxFormats.cpp

@@ -3,14 +3,14 @@
 #include <xrpl/protocol/TxFormats.h>
 #include <xrpl/protocol/jss.h>
 
-#include <vector>
+#include <initializer_list>
 
 namespace xrpl {
 
-std::vector<SOElement> const&
-TxFormats::getCommonFields()
+TxFormats::TxFormats()
 {
-    static auto const commonFields = std::vector<SOElement>{
+    // Fields shared by all txFormats:
+    static std::initializer_list<SOElement> const commonFields{
         {sfTransactionType, soeREQUIRED},
         {sfFlags, soeOPTIONAL},
         {sfSourceTag, soeOPTIONAL},
@@ -29,11 +29,7 @@ TxFormats::getCommonFields()
         {sfNetworkID, soeOPTIONAL},
         {sfDelegate, soeOPTIONAL},
     };
-    return commonFields;
-}
 
-TxFormats::TxFormats()
-{
 #pragma push_macro("UNWRAP")
 #undef UNWRAP
 #pragma push_macro("TRANSACTION")
@@ -41,7 +37,7 @@ TxFormats::TxFormats()
 
 #define UNWRAP(...) __VA_ARGS__
 #define TRANSACTION(tag, value, name, delegable, amendment, privileges, fields) \
-    add(jss::name, tag, UNWRAP fields, getCommonFields());
+    add(jss::name, tag, UNWRAP fields, commonFields);
 
 #include <xrpl/protocol/detail/transactions.macro>
 

src/libxrpl/shamap/SHAMap.cpp

@@ -178,7 +178,7 @@ SHAMap::finishFetch(SHAMapHash const& hash, std::shared_ptr<NodeObject> const& o
 
 // See if a sync filter has a node
 intr_ptr::SharedPtr<SHAMapTreeNode>
-SHAMap::checkFilter(SHAMapHash const& hash, SHAMapSyncFilter* filter) const
+SHAMap::checkFilter(SHAMapHash const& hash, SHAMapSyncFilter const* filter) const
 {
     if (auto nodeData = filter->getNode(hash))
     {
@@ -204,7 +204,7 @@ SHAMap::checkFilter(SHAMapHash const& hash, SHAMapSyncFilter* filter) const
 // Get a node without throwing
 // Used on maps where missing nodes are expected
 intr_ptr::SharedPtr<SHAMapTreeNode>
-SHAMap::fetchNodeNT(SHAMapHash const& hash, SHAMapSyncFilter* filter) const
+SHAMap::fetchNodeNT(SHAMapHash const& hash, SHAMapSyncFilter const* filter) const
 {
     auto node = cacheLookup(hash);
     if (node)
@@ -317,7 +317,7 @@ SHAMap::descend(
     SHAMapInnerNode* parent,
     SHAMapNodeID const& parentID,
     int branch,
-    SHAMapSyncFilter* filter) const
+    SHAMapSyncFilter const* filter) const
 {
     XRPL_ASSERT(parent->isInner(), "xrpl::SHAMap::descend : valid parent input");
     XRPL_ASSERT(
@@ -346,7 +346,7 @@ SHAMapTreeNode*
 SHAMap::descendAsync(
     SHAMapInnerNode* parent,
     int branch,
-    SHAMapSyncFilter* filter,
+    SHAMapSyncFilter const* filter,
     bool& pending,
     descendCallback&& callback) const
 {

src/libxrpl/shamap/SHAMapNodeID.cpp

@@ -118,7 +118,9 @@ selectBranch(SHAMapNodeID const& id, uint256 const& hash)
 SHAMapNodeID
 SHAMapNodeID::createID(int depth, uint256 const& key)
 {
-    XRPL_ASSERT((depth >= 0) && (depth < 65), "xrpl::SHAMapNodeID::createID : valid branch input");
+    XRPL_ASSERT(
+        depth >= 0 && depth <= SHAMap::leafDepth,
+        "xrpl::SHAMapNodeID::createID : valid branch input");
     return SHAMapNodeID(depth, key & depthMask(depth));
 }
 

src/libxrpl/shamap/SHAMapSync.cpp

@@ -386,7 +386,7 @@ SHAMap::getMissingNodes(int max, SHAMapSyncFilter* filter)
 bool
 SHAMap::getNodeFat(
     SHAMapNodeID const& wanted,
-    std::vector<std::pair<SHAMapNodeID, Blob>>& data,
+    std::vector<std::tuple<SHAMapNodeID, Blob, bool>>& data,
     bool fatLeaves,
     std::uint32_t depth) const
 {
@@ -432,7 +432,7 @@ SHAMap::getNodeFat(
         // Add this node to the reply
         s.erase();
         node->serializeForWire(s);
-        data.emplace_back(std::make_pair(nodeID, s.getData()));
+        data.emplace_back(std::make_tuple(nodeID, s.getData(), node->isLeaf()));
 
         if (node->isInner())
         {
@@ -462,7 +462,8 @@ SHAMap::getNodeFat(
                             // Just include this node
                             s.erase();
                             childNode->serializeForWire(s);
-                            data.emplace_back(std::make_pair(childID, s.getData()));
+                            data.emplace_back(
+                                std::make_tuple(childID, s.getData(), childNode->isLeaf()));
                         }
                     }
                 }
@@ -480,8 +481,18 @@ SHAMap::serializeRoot(Serializer& s) const
 }
 
 SHAMapAddNode
-SHAMap::addRootNode(SHAMapHash const& hash, Slice const& rootNode, SHAMapSyncFilter* filter)
+SHAMap::addRootNode(
+    SHAMapHash const& hash,
+    intr_ptr::SharedPtr<SHAMapTreeNode> rootNode,
+    SHAMapSyncFilter const* filter)
 {
+    XRPL_ASSERT(rootNode, "xrpl::SHAMap::addRootNode : non-null root node");
+    if (!rootNode)
+    {
+        JLOG(journal_.error()) << "Null node received";
+        return SHAMapAddNode::invalid();
+    }
+
     // we already have a root_ node
     if (root_->getHash().isNonZero())
     {
@@ -491,14 +502,16 @@ SHAMap::addRootNode(SHAMapHash const& hash, Slice const& rootNode, SHAMapSyncFil
     }
 
     XRPL_ASSERT(cowid_ >= 1, "xrpl::SHAMap::addRootNode : valid cowid");
-    auto node = SHAMapTreeNode::makeFromWire(rootNode);
-    if (!node || node->getHash() != hash)
+    if (rootNode->getHash() != hash)
+    {
+        JLOG(journal_.warn()) << "Corrupt node received";
         return SHAMapAddNode::invalid();
+    }
 
     if (backed_)
-        canonicalize(hash, node);
+        canonicalize(hash, rootNode);
 
-    root_ = node;
+    root_ = std::move(rootNode);
 
     if (root_->isLeaf())
         clearSynching();
@@ -515,9 +528,18 @@ SHAMap::addRootNode(SHAMapHash const& hash, Slice const& rootNode, SHAMapSyncFil
 }
 
 SHAMapAddNode
-SHAMap::addKnownNode(SHAMapNodeID const& node, Slice const& rawNode, SHAMapSyncFilter* filter)
+SHAMap::addKnownNode(
+    SHAMapNodeID const& nodeID,
+    intr_ptr::SharedPtr<SHAMapTreeNode> treeNode,
+    SHAMapSyncFilter const* filter)
 {
-    XRPL_ASSERT(!node.isRoot(), "xrpl::SHAMap::addKnownNode : valid node input");
+    XRPL_ASSERT(!nodeID.isRoot(), "xrpl::SHAMap::addKnownNode : valid node input");
+    XRPL_ASSERT(treeNode, "xrpl::SHAMap::addKnownNode : non-null tree node");
+    if (!treeNode)
+    {
+        JLOG(journal_.error()) << "Null node received";
+        return SHAMapAddNode::invalid();
+    }
 
     if (!isSynching())
     {
@@ -531,14 +553,14 @@ SHAMap::addKnownNode(SHAMapNodeID const& node, Slice const& rawNode, SHAMapSyncF
 
     while (currNode->isInner() &&
            !static_cast<SHAMapInnerNode*>(currNode)->isFullBelow(generation) &&
-           (currNodeID.getDepth() < node.getDepth()))
+           (currNodeID.getDepth() < nodeID.getDepth()))
     {
-        int const branch = selectBranch(currNodeID, node.getNodeID());
+        int const branch = selectBranch(currNodeID, nodeID.getNodeID());
         XRPL_ASSERT(branch >= 0, "xrpl::SHAMap::addKnownNode : valid branch");
         auto inner = static_cast<SHAMapInnerNode*>(currNode);
         if (inner->isEmptyBranch(branch))
         {
-            JLOG(journal_.warn()) << "Add known node for empty branch" << node;
+            JLOG(journal_.warn()) << "Add known node for empty branch" << nodeID;
             return SHAMapAddNode::invalid();
         }
 
@@ -554,67 +576,44 @@ SHAMap::addKnownNode(SHAMapNodeID const& node, Slice const& rawNode, SHAMapSyncF
         if (currNode != nullptr)
             continue;
 
-        auto newNode = SHAMapTreeNode::makeFromWire(rawNode);
-
-        if (!newNode || childHash != newNode->getHash())
+        if (childHash != treeNode->getHash())
         {
             JLOG(journal_.warn()) << "Corrupt node received";
             return SHAMapAddNode::invalid();
         }
 
-        // In rare cases, a node can still be corrupt even after hash
-        // validation. For leaf nodes, we perform an additional check to
-        // ensure the node's position in the tree is consistent with its
-        // content to prevent inconsistencies that could
-        // propagate further down the line.
-        if (newNode->isLeaf())
-        {
-            auto const& actualKey =
-                static_cast<SHAMapLeafNode const*>(newNode.get())->peekItem()->key();
-
-            // Validate that this leaf belongs at the target position
-            auto const expectedNodeID = SHAMapNodeID::createID(node.getDepth(), actualKey);
-            if (expectedNodeID.getNodeID() != node.getNodeID())
-            {
-                JLOG(journal_.debug())
-                    << "Leaf node position mismatch: "
-                    << "expected=" << expectedNodeID.getNodeID() << ", actual=" << node.getNodeID();
-                return SHAMapAddNode::invalid();
-            }
-        }
-
         // Inner nodes must be at a level strictly less than 64
         // but leaf nodes (while notionally at level 64) can be
         // at any depth up to and including 64:
         if ((currNodeID.getDepth() > leafDepth) ||
-            (newNode->isInner() && currNodeID.getDepth() == leafDepth))
+            (treeNode->isInner() && currNodeID.getDepth() == leafDepth))
         {
             // Map is provably invalid
             state_ = SHAMapState::Invalid;
             return SHAMapAddNode::useful();
         }
 
-        if (currNodeID != node)
+        if (currNodeID != nodeID)
         {
             // Either this node is broken or we didn't request it (yet)
-            JLOG(journal_.warn()) << "unable to hook node " << node;
+            JLOG(journal_.warn()) << "unable to hook node " << nodeID;
             JLOG(journal_.info()) << " stuck at " << currNodeID;
-            JLOG(journal_.info()) << "got depth=" << node.getDepth()
+            JLOG(journal_.info()) << "got depth=" << nodeID.getDepth()
                                   << ", walked to= " << currNodeID.getDepth();
             return SHAMapAddNode::useful();
         }
 
         if (backed_)
-            canonicalize(childHash, newNode);
+            canonicalize(childHash, treeNode);
 
-        newNode = prevNode->canonicalizeChild(branch, std::move(newNode));
+        treeNode = prevNode->canonicalizeChild(branch, std::move(treeNode));
 
         if (filter)
         {
             Serializer s;
-            newNode->serializeWithPrefix(s);
+            treeNode->serializeWithPrefix(s);
             filter->gotNode(
-                false, childHash, ledgerSeq_, std::move(s.modData()), newNode->getType());
+                false, childHash, ledgerSeq_, std::move(s.modData()), treeNode->getType());
         }
 
         return SHAMapAddNode::useful();

src/libxrpl/tx/Transactor.cpp

@@ -14,8 +14,8 @@
 #include <xrpl/tx/SignerEntries.h>
 #include <xrpl/tx/Transactor.h>
 #include <xrpl/tx/apply.h>
-#include <xrpl/tx/transactors/delegate/DelegateUtils.h>
-#include <xrpl/tx/transactors/nft/NFTokenUtils.h>
+#include <xrpl/tx/transactors/Delegate/DelegateUtils.h>
+#include <xrpl/tx/transactors/NFT/NFTokenUtils.h>
 
 namespace xrpl {
 

src/libxrpl/tx/invariants/AMMInvariant.cpp

@@ -3,8 +3,8 @@
 #include <xrpl/basics/Log.h>
 #include <xrpl/beast/utility/instrumentation.h>
 #include <xrpl/protocol/TxFormats.h>
-#include <xrpl/tx/transactors/dex/AMMHelpers.h>
-#include <xrpl/tx/transactors/dex/AMMUtils.h>
+#include <xrpl/tx/transactors/AMM/AMMHelpers.h>
+#include <xrpl/tx/transactors/AMM/AMMUtils.h>
 
 namespace xrpl {
 

src/libxrpl/tx/invariants/NFTInvariant.cpp

@@ -6,7 +6,7 @@
 #include <xrpl/protocol/TxFormats.h>
 #include <xrpl/protocol/nftPageMask.h>
 #include <xrpl/tx/invariants/InvariantCheckPrivilege.h>
-#include <xrpl/tx/transactors/nft/NFTokenUtils.h>
+#include <xrpl/tx/transactors/NFT/NFTokenUtils.h>
 
 namespace xrpl {
 

src/libxrpl/tx/paths/Flow.cpp

@@ -6,7 +6,7 @@
 #include <xrpl/tx/paths/detail/AmountSpec.h>
 #include <xrpl/tx/paths/detail/Steps.h>
 #include <xrpl/tx/paths/detail/StrandFlow.h>
-#include <xrpl/tx/transactors/dex/AMMContext.h>
+#include <xrpl/tx/transactors/AMM/AMMContext.h>
 
 namespace xrpl {
 

src/libxrpl/tx/paths/OfferStream.cpp

@@ -3,7 +3,7 @@
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/LedgerFormats.h>
 #include <xrpl/tx/paths/OfferStream.h>
-#include <xrpl/tx/transactors/dex/PermissionedDEXHelpers.h>
+#include <xrpl/tx/transactors/PermissionedDEXHelpers.h>
 
 namespace xrpl {
 

src/libxrpl/tx/transactors/AMM/AMMBid.cpp

@@ -4,9 +4,9 @@
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/dex/AMMBid.h>
-#include <xrpl/tx/transactors/dex/AMMHelpers.h>
-#include <xrpl/tx/transactors/dex/AMMUtils.h>
+#include <xrpl/tx/transactors/AMM/AMMBid.h>
+#include <xrpl/tx/transactors/AMM/AMMHelpers.h>
+#include <xrpl/tx/transactors/AMM/AMMUtils.h>
 
 namespace xrpl {
 

src/libxrpl/tx/transactors/AMM/AMMClawback.cpp

@@ -4,10 +4,10 @@
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/TxFlags.h>
 #include <xrpl/protocol/st.h>
-#include <xrpl/tx/transactors/dex/AMMClawback.h>
-#include <xrpl/tx/transactors/dex/AMMHelpers.h>
-#include <xrpl/tx/transactors/dex/AMMUtils.h>
-#include <xrpl/tx/transactors/dex/AMMWithdraw.h>
+#include <xrpl/tx/transactors/AMM/AMMClawback.h>
+#include <xrpl/tx/transactors/AMM/AMMHelpers.h>
+#include <xrpl/tx/transactors/AMM/AMMUtils.h>
+#include <xrpl/tx/transactors/AMM/AMMWithdraw.h>
 
 #include <tuple>
 

src/libxrpl/tx/transactors/AMM/AMMCreate.cpp

@@ -5,9 +5,9 @@
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/STIssue.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/dex/AMMCreate.h>
-#include <xrpl/tx/transactors/dex/AMMHelpers.h>
-#include <xrpl/tx/transactors/dex/AMMUtils.h>
+#include <xrpl/tx/transactors/AMM/AMMCreate.h>
+#include <xrpl/tx/transactors/AMM/AMMHelpers.h>
+#include <xrpl/tx/transactors/AMM/AMMUtils.h>
 
 namespace xrpl {
 

src/libxrpl/tx/transactors/AMM/AMMDelete.cpp

@@ -2,8 +2,8 @@
 #include <xrpl/protocol/AMMCore.h>
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/dex/AMMDelete.h>
-#include <xrpl/tx/transactors/dex/AMMUtils.h>
+#include <xrpl/tx/transactors/AMM/AMMDelete.h>
+#include <xrpl/tx/transactors/AMM/AMMUtils.h>
 
 namespace xrpl {
 

src/libxrpl/tx/transactors/AMM/AMMDeposit.cpp

@@ -3,9 +3,9 @@
 #include <xrpl/protocol/AMMCore.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/dex/AMMDeposit.h>
-#include <xrpl/tx/transactors/dex/AMMHelpers.h>
-#include <xrpl/tx/transactors/dex/AMMUtils.h>
+#include <xrpl/tx/transactors/AMM/AMMDeposit.h>
+#include <xrpl/tx/transactors/AMM/AMMHelpers.h>
+#include <xrpl/tx/transactors/AMM/AMMUtils.h>
 
 namespace xrpl {
 
@@ -19,7 +19,7 @@ std::uint32_t
 AMMDeposit::getFlagsMask(PreflightContext const& ctx)
 
 {
-    return tfAMMDepositMask;
+    return tfDepositMask;
 }
 
 NotTEC

src/libxrpl/tx/transactors/AMM/AMMHelpers.cpp

@@ -1,4 +1,4 @@
-#include <xrpl/tx/transactors/dex/AMMHelpers.h>
+#include <xrpl/tx/transactors/AMM/AMMHelpers.h>
 
 namespace xrpl {
 

src/libxrpl/tx/transactors/AMM/AMMUtils.cpp

@@ -2,8 +2,8 @@
 #include <xrpl/ledger/Sandbox.h>
 #include <xrpl/protocol/AMMCore.h>
 #include <xrpl/protocol/STObject.h>
-#include <xrpl/tx/transactors/dex/AMMHelpers.h>
-#include <xrpl/tx/transactors/dex/AMMUtils.h>
+#include <xrpl/tx/transactors/AMM/AMMHelpers.h>
+#include <xrpl/tx/transactors/AMM/AMMUtils.h>
 
 namespace xrpl {
 

src/libxrpl/tx/transactors/AMM/AMMVote.cpp

@@ -2,8 +2,8 @@
 #include <xrpl/protocol/AMMCore.h>
 #include <xrpl/protocol/Feature.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/dex/AMMUtils.h>
-#include <xrpl/tx/transactors/dex/AMMVote.h>
+#include <xrpl/tx/transactors/AMM/AMMUtils.h>
+#include <xrpl/tx/transactors/AMM/AMMVote.h>
 
 namespace xrpl {
 

src/libxrpl/tx/transactors/AMM/AMMWithdraw.cpp

@@ -2,9 +2,9 @@
 #include <xrpl/ledger/Sandbox.h>
 #include <xrpl/protocol/AMMCore.h>
 #include <xrpl/protocol/TxFlags.h>
-#include <xrpl/tx/transactors/dex/AMMHelpers.h>
-#include <xrpl/tx/transactors/dex/AMMUtils.h>
-#include <xrpl/tx/transactors/dex/AMMWithdraw.h>
+#include <xrpl/tx/transactors/AMM/AMMHelpers.h>
+#include <xrpl/tx/transactors/AMM/AMMUtils.h>
+#include <xrpl/tx/transactors/AMM/AMMWithdraw.h>
 
 namespace xrpl {
 
@@ -17,7 +17,7 @@ AMMWithdraw::checkExtraFeatures(PreflightContext const& ctx)
 std::uint32_t
 AMMWithdraw::getFlagsMask(PreflightContext const& ctx)
 {
-    return tfAMMWithdrawMask;
+    return tfWithdrawMask;
 }
 
 NotTEC