Merge remote-tracking branch 'XRPLF/develop' into ximinez/number-maxint-range

* XRPLF/develop: (81 commits)
  ci: Only publish docs in public repos (6687)
  chore: Enable remaining clang-tidy `performance` checks (6648)
  refactor: Address PR comments after the modularisation PRs (6389)
  chore: Fix clang-tidy header filter (6686)
  ci: [DEPENDABOT] bump actions/deploy-pages from 4.0.5 to 5.0.0 (6684)
  ci: [DEPENDABOT] bump codecov/codecov-action from 5.5.3 to 6.0.0 (6685)
  fix: Guard Coro::resume() against completed coroutines (6608)
  refactor: Split LoanInvariant into LoanBrokerInvariant and LoanInvariant (6674)
  ci: Don't publish docs on release branches (6673)
  refactor: Make function naming in ServiceRegistry consistent (6390)
  chore: Shorten job names to stay within Linux 15-char thread limit (6669)
  fix: Improve loan invariant message (6668)
  ci: Upload artifacts only in public repositories (6670)
  ci: Add conflicting-pr workflow (6656)
  chore: Add more AI tools to .gitignore (6658)
  chore: Show warning message if user may need to connect to VPN (6619)
  feat: Add placeholder amendment for assorted bug fixes (6652)
  chore: Update sqlite3->3.51.0, protobuf->6.33.5, openssl->3.6.1, grpc->1.78.1 (6653)
  refactor: Modularise ledger (6536)
  chore: Use unpatched version of soci (6649)
  ...

include/xrpl/basics/contract.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <xrpl/basics/sanitizers.h>
 #include <xrpl/beast/type_name.h>
 
 #include <exception>
@@ -23,16 +24,28 @@ LogThrow(std::string const& title);
     When called from within a catch block, it will pass
     control to the next matching exception handler, if any.
     Otherwise, std::terminate will be called.
+
+    ASAN can't handle sudden jumps in control flow very well. This
+    function is marked as XRPL_NO_SANITIZE_ADDRESS to prevent it from
+    triggering false positives, since it throws.
 */
-[[noreturn]] inline void
+[[noreturn]] XRPL_NO_SANITIZE_ADDRESS inline void
 Rethrow()
 {
     LogThrow("Re-throwing exception");
     throw;
 }
 
+/*
+    Logs and throws an exception of type E.
+
+    ASAN can't handle sudden jumps in control flow very well. This
+    function is marked as XRPL_NO_SANITIZE_ADDRESS to prevent it from
+    triggering false positives, since it throws.
+*/
+
 template <class E, class... Args>
-[[noreturn]] inline void
+[[noreturn]] XRPL_NO_SANITIZE_ADDRESS inline void
 Throw(Args&&... args)
 {
     static_assert(

include/xrpl/basics/safe_cast.h

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <xrpl/beast/utility/instrumentation.h>
+
 #include <type_traits>
 
 namespace xrpl {
@@ -70,4 +72,31 @@ unsafe_cast(Src s) noexcept
     return unsafe_cast<Dest>(static_cast<std::underlying_type_t<Src>>(s));
 }
 
+template <class Dest, class Src>
+    requires std::is_pointer_v<Dest>
+inline Dest
+safe_downcast(Src* s) noexcept
+{
+#ifdef NDEBUG
+    return static_cast<Dest>(s);  // NOLINT(cppcoreguidelines-pro-type-static-cast-downcast)
+#else
+    auto* result = dynamic_cast<Dest>(s);
+    XRPL_ASSERT(result != nullptr, "xrpl::safe_downcast : pointer downcast is valid");
+    return result;
+#endif
+}
+
+template <class Dest, class Src>
+    requires std::is_lvalue_reference_v<Dest>
+inline Dest
+safe_downcast(Src& s) noexcept
+{
+#ifndef NDEBUG
+    XRPL_ASSERT(
+        dynamic_cast<std::add_pointer_t<std::remove_reference_t<Dest>>>(&s) != nullptr,
+        "xrpl::safe_downcast : reference downcast is valid");
+#endif
+    return static_cast<Dest>(s);  // NOLINT(cppcoreguidelines-pro-type-static-cast-downcast)
+}
+
 }  // namespace xrpl

include/xrpl/basics/sanitizers.h

@@ -0,0 +1,13 @@
+#pragma once
+
+// Helper to disable ASan/HwASan for specific functions
+/*
+ ASAN flags some false positives with sudden jumps in control flow, like
+ exceptions, or when encountering coroutine stack switches. This macro can be used to disable ASAN
+ intrumentation for specific functions.
+*/
+#if defined(__GNUC__) || defined(__clang__)
+#define XRPL_NO_SANITIZE_ADDRESS __attribute__((no_sanitize("address", "hwaddress")))
+#else
+#define XRPL_NO_SANITIZE_ADDRESS
+#endif

include/xrpl/beast/core/List.h

@@ -43,8 +43,8 @@ private:
     template <typename>
     friend class ListIterator;
 
-    ListNode* m_next;
-    ListNode* m_prev;
+    ListNode* m_next = nullptr;
+    ListNode* m_prev = nullptr;
 };
 
 //------------------------------------------------------------------------------
@@ -567,7 +567,7 @@ private:
     }
 
 private:
-    size_type m_size;
+    size_type m_size = 0u;
     Node m_head;
     Node m_tail;
 };

include/xrpl/beast/utility/instrumentation.h

@@ -15,7 +15,7 @@
 #define ALWAYS_OR_UNREACHABLE(cond, message) assert((message) && (cond))
 #define SOMETIMES(cond, message, ...)
 #define REACHABLE(message, ...)
-#define UNREACHABLE(message, ...) assert((message) && false)
+#define UNREACHABLE(message, ...) assert((message) && false)  // NOLINT(misc-static-assert)
 #endif
 
 #define XRPL_ASSERT ALWAYS_OR_UNREACHABLE

include/xrpl/core/Coro.ipp

@@ -1,7 +1,5 @@
 #pragma once
 
-#include <xrpl/basics/ByteUtilities.h>
-
 namespace xrpl {
 
 template <class F>
@@ -11,16 +9,18 @@ JobQueue::Coro::Coro(Coro_create_t, JobQueue& jq, JobType type, std::string cons
     , name_(name)
     , running_(false)
     , coro_(
+          // Stack size of 1MB wasn't sufficient for deep calls. ASAN tests flagged the issue. Hence
+          // increasing the size to 1.5MB.
+          boost::context::protected_fixedsize_stack(1536 * 1024),
           [this, fn = std::forward<F>(f)](
-              boost::coroutines::asymmetric_coroutine<void>::push_type& do_yield) {
+              boost::coroutines2::asymmetric_coroutine<void>::push_type& do_yield) {
               yield_ = &do_yield;
               yield();
               fn(shared_from_this());
 #ifndef NDEBUG
               finished_ = true;
 #endif
-          },
-          boost::coroutines::attributes(megabytes(1)))
+          })
 {
 }
 
@@ -70,14 +70,24 @@ JobQueue::Coro::resume()
         running_ = true;
     }
     {
-        std::lock_guard lock(jq_.m_mutex);
+        std::lock_guard lk(jq_.m_mutex);
         --jq_.nSuspend_;
     }
     auto saved = detail::getLocalValues().release();
     detail::getLocalValues().reset(&lvs_);
     std::lock_guard lock(mutex_);
-    XRPL_ASSERT(static_cast<bool>(coro_), "xrpl::JobQueue::Coro::resume : is runnable");
-    coro_();
+    // A late resume() can arrive after the coroutine has already completed.
+    // This is an expected (if rare) outcome of the race condition documented
+    // in JobQueue.h:354-377 where post() schedules a resume job before the
+    // coroutine yields — the mutex serializes access, but by the time this
+    // resume() acquires the lock the coroutine may have already run to
+    // completion. Calling operator() on a completed boost::coroutine2 is
+    // undefined behavior, so we must check and skip invoking the coroutine
+    // body if it has already completed.
+    if (coro_)
+    {
+        coro_();
+    }
     detail::getLocalValues().release();
     detail::getLocalValues().reset(saved);
     std::lock_guard lk(mutex_run_);

include/xrpl/core/JobQueue.h

@@ -7,7 +7,8 @@
 #include <xrpl/core/detail/Workers.h>
 #include <xrpl/json/json_value.h>
 
-#include <boost/coroutine/all.hpp>
+#include <boost/context/protected_fixedsize_stack.hpp>
+#include <boost/coroutine2/all.hpp>
 
 #include <set>
 
@@ -48,8 +49,8 @@ public:
         std::mutex mutex_;
         std::mutex mutex_run_;
         std::condition_variable cv_;
-        boost::coroutines::asymmetric_coroutine<void>::pull_type coro_;
-        boost::coroutines::asymmetric_coroutine<void>::push_type* yield_;
+        boost::coroutines2::coroutine<void>::pull_type coro_;
+        boost::coroutines2::coroutine<void>::push_type* yield_;
 #ifndef NDEBUG
         bool finished_ = false;
 #endif
@@ -98,8 +99,8 @@ public:
             Effects:
                The coroutine continues execution from where it last left off
                  using this same thread.
-            Undefined behavior if called after the coroutine has completed
-              with a return (as opposed to a yield()).
+               If the coroutine has already completed, returns immediately
+                 (handles the documented post-before-yield race condition).
             Undefined behavior if resume() or post() called consecutively
               without a corresponding yield.
         */
@@ -315,7 +316,7 @@ private:
     // Returns the limit of running jobs for the given job type.
     // For jobs with no limit, we return the largest int. Hopefully that
     // will be enough.
-    int
+    static int
     getJobLimit(JobType type);
 };
 
@@ -356,8 +357,10 @@ private:
     If the post() job were to be executed before yield(), undefined behavior
     would occur. The lock ensures that coro_ is not called again until we exit
     the coroutine. At which point a scheduled resume() job waiting on the lock
-    would gain entry, harmlessly call coro_ and immediately return as we have
-    already completed the coroutine.
+    would gain entry. resume() checks if the coroutine has already completed
+    (coro_ converts to false) and, if so, skips invoking operator() since
+    calling operator() on a completed boost::coroutine2 pull_type is undefined
+    behavior.
 
     The race condition occurs as follows:
 

include/xrpl/core/ServiceRegistry.h

@@ -3,7 +3,6 @@
 #include <xrpl/basics/Blob.h>
 #include <xrpl/basics/SHAMapHash.h>
 #include <xrpl/basics/TaggedCache.h>
-#include <xrpl/ledger/CachedSLEs.h>
 
 #include <boost/asio.hpp>
 
@@ -23,6 +22,20 @@ class PerfLog;
 // This is temporary until we migrate all code to use ServiceRegistry.
 class Application;
 
+template <
+    class Key,
+    class T,
+    bool IsKeyCache,
+    class SharedWeakUnionPointer,
+    class SharedPointerType,
+    class Hash,
+    class KeyEqual,
+    class Mutex>
+class TaggedCache;
+class STLedgerEntry;
+using SLE = STLedgerEntry;
+using CachedSLEs = TaggedCache<uint256, SLE const>;
+
 // Forward declarations
 class AcceptedLedger;
 class AmendmentTable;
@@ -45,7 +58,7 @@ class NetworkIDService;
 class OpenLedger;
 class OrderBookDB;
 class Overlay;
-class PathRequests;
+class PathRequestManager;
 class PeerReservationTable;
 class PendingSaves;
 class RelationalDatabase;
@@ -89,7 +102,7 @@ public:
     getNodeFamily() = 0;
 
     virtual TimeKeeper&
-    timeKeeper() = 0;
+    getTimeKeeper() = 0;
 
     virtual JobQueue&
     getJobQueue() = 0;
@@ -98,7 +111,7 @@ public:
     getTempNodeCache() = 0;
 
     virtual CachedSLEs&
-    cachedSLEs() = 0;
+    getCachedSLEs() = 0;
 
     virtual NetworkIDService&
     getNetworkIDService() = 0;
@@ -120,26 +133,26 @@ public:
     getValidations() = 0;
 
     virtual ValidatorList&
-    validators() = 0;
+    getValidators() = 0;
 
     virtual ValidatorSite&
-    validatorSites() = 0;
+    getValidatorSites() = 0;
 
     virtual ManifestCache&
-    validatorManifests() = 0;
+    getValidatorManifests() = 0;
 
     virtual ManifestCache&
-    publisherManifests() = 0;
+    getPublisherManifests() = 0;
 
     // Network services
     virtual Overlay&
-    overlay() = 0;
+    getOverlay() = 0;
 
     virtual Cluster&
-    cluster() = 0;
+    getCluster() = 0;
 
     virtual PeerReservationTable&
-    peerReservations() = 0;
+    getPeerReservations() = 0;
 
     virtual Resource::Manager&
     getResourceManager() = 0;
@@ -174,13 +187,13 @@ public:
     getLedgerReplayer() = 0;
 
     virtual PendingSaves&
-    pendingSaves() = 0;
+    getPendingSaves() = 0;
 
     virtual OpenLedger&
-    openLedger() = 0;
+    getOpenLedger() = 0;
 
     virtual OpenLedger const&
-    openLedger() const = 0;
+    getOpenLedger() const = 0;
 
     // Transaction and operation services
     virtual NetworkOPs&
@@ -195,8 +208,8 @@ public:
     virtual TxQ&
     getTxQ() = 0;
 
-    virtual PathRequests&
-    getPathRequests() = 0;
+    virtual PathRequestManager&
+    getPathRequestManager() = 0;
 
     // Server services
     virtual ServerHandler&
@@ -210,16 +223,16 @@ public:
     isStopping() const = 0;
 
     virtual beast::Journal
-    journal(std::string const& name) = 0;
+    getJournal(std::string const& name) = 0;
 
     virtual boost::asio::io_context&
     getIOContext() = 0;
 
     virtual Logs&
-    logs() = 0;
+    getLogs() = 0;
 
     virtual std::optional<uint256> const&
-    trapTxID() const = 0;
+    getTrapTxID() const = 0;
 
     /** Retrieve the "wallet database" */
     virtual DatabaseCon&
@@ -228,7 +241,7 @@ public:
     // Temporary: Get the underlying Application for functions that haven't
     // been migrated yet. This should be removed once all code is migrated.
     virtual Application&
-    app() = 0;
+    getApp() = 0;
 };
 
 }  // namespace xrpl

include/xrpl/core/StartUpType.h

@@ -5,7 +5,7 @@
 
 namespace xrpl {
 
-enum class StartUpType { FRESH, NORMAL, LOAD, LOAD_FILE, REPLAY, NETWORK };
+enum class StartUpType { Fresh, Normal, Load, LoadFile, Replay, Network };
 
 inline std::ostream&
 operator<<(std::ostream& os, StartUpType const& type)

include/xrpl/json/json_value.h

@@ -421,7 +421,7 @@ private:
         ObjectValues* map_{nullptr};
     } value_;
     ValueType type_ : 8;
-    int allocated_ : 1;  // Notes: if declared as bool, bitfield is useless.
+    int allocated_ : 1 {};  // Notes: if declared as bool, bitfield is useless.
 };
 
 inline Value

include/xrpl/json/json_writer.h

@@ -108,7 +108,7 @@ private:
     std::string indentString_;
     int rightMargin_;
     int indentSize_;
-    bool addChildValues_;
+    bool addChildValues_{};
 };
 
 /** \brief Writes a Value in <a HREF="http://www.json.org">JSON</a> format in a
@@ -175,7 +175,7 @@ private:
     std::string indentString_;
     int rightMargin_;
     std::string indentation_;
-    bool addChildValues_;
+    bool addChildValues_{};
 };
 
 std::string

include/xrpl/ledger/CanonicalTXSet.h

@@ -0,0 +1,157 @@
+#pragma once
+
+#include <xrpl/basics/CountedObject.h>
+#include <xrpl/protocol/RippleLedgerHash.h>
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/SeqProxy.h>
+
+namespace xrpl {
+
+/** Holds transactions which were deferred to the next pass of consensus.
+
+    "Canonical" refers to the order in which transactions are applied.
+
+    - Puts transactions from the same account in SeqProxy order
+
+*/
+// VFALCO TODO rename to SortedTxSet
+class CanonicalTXSet : public CountedObject<CanonicalTXSet>
+{
+private:
+    class Key
+    {
+    public:
+        Key(uint256 const& account, SeqProxy seqProx, uint256 const& id)
+            : account_(account), txId_(id), seqProxy_(seqProx)
+        {
+        }
+
+        friend bool
+        operator<(Key const& lhs, Key const& rhs);
+
+        inline friend bool
+        operator>(Key const& lhs, Key const& rhs)
+        {
+            return rhs < lhs;
+        }
+
+        inline friend bool
+        operator<=(Key const& lhs, Key const& rhs)
+        {
+            return !(lhs > rhs);
+        }
+
+        inline friend bool
+        operator>=(Key const& lhs, Key const& rhs)
+        {
+            return !(lhs < rhs);
+        }
+
+        inline friend bool
+        operator==(Key const& lhs, Key const& rhs)
+        {
+            return lhs.txId_ == rhs.txId_;
+        }
+
+        inline friend bool
+        operator!=(Key const& lhs, Key const& rhs)
+        {
+            return !(lhs == rhs);
+        }
+
+        uint256 const&
+        getAccount() const
+        {
+            return account_;
+        }
+
+        uint256 const&
+        getTXID() const
+        {
+            return txId_;
+        }
+
+    private:
+        uint256 account_;
+        uint256 txId_;
+        SeqProxy seqProxy_;
+    };
+
+    friend bool
+    operator<(Key const& lhs, Key const& rhs);
+
+    // Calculate the salted key for the given account
+    uint256
+    accountKey(AccountID const& account);
+
+public:
+    using const_iterator = std::map<Key, std::shared_ptr<STTx const>>::const_iterator;
+
+public:
+    explicit CanonicalTXSet(LedgerHash const& saltHash) : salt_(saltHash)
+    {
+    }
+
+    void
+    insert(std::shared_ptr<STTx const> const& txn);
+
+    // Pops the next transaction on account that follows seqProx in the
+    // sort order.  Normally called when a transaction is successfully
+    // applied to the open ledger so the next transaction can be resubmitted
+    // without waiting for ledger close.
+    //
+    // The return value is often null, when an account has no more
+    // transactions.
+    std::shared_ptr<STTx const>
+    popAcctTransaction(std::shared_ptr<STTx const> const& tx);
+
+    void
+    reset(LedgerHash const& salt)
+    {
+        salt_ = salt;
+        map_.clear();
+    }
+
+    const_iterator
+    erase(const_iterator const& it)
+    {
+        return map_.erase(it);
+    }
+
+    const_iterator
+    begin() const
+    {
+        return map_.begin();
+    }
+
+    const_iterator
+    end() const
+    {
+        return map_.end();
+    }
+
+    size_t
+    size() const
+    {
+        return map_.size();
+    }
+    bool
+    empty() const
+    {
+        return map_.empty();
+    }
+
+    uint256 const&
+    key() const
+    {
+        return salt_;
+    }
+
+private:
+    std::map<Key, std::shared_ptr<STTx const>> map_;
+
+    // Used to salt the accounts so people can't mine for low account numbers
+    uint256 salt_;
+};
+
+}  // namespace xrpl

include/xrpl/ledger/Credit.h

@@ -1,43 +0,0 @@
-#pragma once
-
-#include <xrpl/ledger/View.h>
-#include <xrpl/protocol/IOUAmount.h>
-#include <xrpl/protocol/STAmount.h>
-
-namespace xrpl {
-
-/** Calculate the maximum amount of IOUs that an account can hold
-    @param ledger the ledger to check against.
-    @param account the account of interest.
-    @param issuer the issuer of the IOU.
-    @param currency the IOU to check.
-    @return The maximum amount that can be held.
-*/
-/** @{ */
-STAmount
-creditLimit(
-    ReadView const& view,
-    AccountID const& account,
-    AccountID const& issuer,
-    Currency const& currency);
-
-IOUAmount
-creditLimit2(ReadView const& v, AccountID const& acc, AccountID const& iss, Currency const& cur);
-/** @} */
-
-/** Returns the amount of IOUs issued by issuer that are held by an account
-    @param ledger the ledger to check against.
-    @param account the account of interest.
-    @param issuer the issuer of the IOU.
-    @param currency the IOU to check.
-*/
-/** @{ */
-STAmount
-creditBalance(
-    ReadView const& view,
-    AccountID const& account,
-    AccountID const& issuer,
-    Currency const& currency);
-/** @} */
-
-}  // namespace xrpl

include/xrpl/ledger/Ledger.h

@@ -0,0 +1,428 @@
+#pragma once
+
+#include <xrpl/basics/CountedObject.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/CachedView.h>
+#include <xrpl/ledger/View.h>
+#include <xrpl/protocol/Fees.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/Rules.h>
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/Serializer.h>
+#include <xrpl/protocol/TxMeta.h>
+#include <xrpl/shamap/SHAMap.h>
+
+namespace xrpl {
+
+class ServiceRegistry;
+class Job;
+class TransactionMaster;
+
+class SqliteStatement;
+
+struct create_genesis_t
+{
+    explicit create_genesis_t() = default;
+};
+extern create_genesis_t const create_genesis;
+
+/** Holds a ledger.
+
+    The ledger is composed of two SHAMaps. The state map holds all of the
+    ledger entries such as account roots and order books. The tx map holds
+    all of the transactions and associated metadata that made it into that
+    particular ledger. Most of the operations on a ledger are concerned
+    with the state map.
+
+    This can hold just the header, a partial set of data, or the entire set
+    of data. It all depends on what is in the corresponding SHAMap entry.
+    Various functions are provided to populate or depopulate the caches that
+    the object holds references to.
+
+    Ledgers are constructed as either mutable or immutable.
+
+    1) If you are the sole owner of a mutable ledger, you can do whatever you
+    want with no need for locks.
+
+    2) If you have an immutable ledger, you cannot ever change it, so no need
+    for locks.
+
+    3) Mutable ledgers cannot be shared.
+
+    @note Presented to clients as ReadView
+    @note Calls virtuals in the constructor, so marked as final
+*/
+class Ledger final : public std::enable_shared_from_this<Ledger>,
+                     public DigestAwareReadView,
+                     public TxsRawView,
+                     public CountedObject<Ledger>
+{
+public:
+    Ledger(Ledger const&) = delete;
+    Ledger&
+    operator=(Ledger const&) = delete;
+
+    Ledger(Ledger&&) = delete;
+    Ledger&
+    operator=(Ledger&&) = delete;
+
+    /** Create the Genesis ledger.
+
+        The Genesis ledger contains a single account whose
+        AccountID is generated with a Generator using the seed
+        computed from the string "masterpassphrase" and ordinal
+        zero.
+
+        The account has an XRP balance equal to the total amount
+        of XRP in the system. No more XRP than the amount which
+        starts in this account can ever exist, with amounts
+        used to pay fees being destroyed.
+
+        Amendments specified are enabled in the genesis ledger
+    */
+    Ledger(
+        create_genesis_t,
+        Rules const& rules,
+        Fees const& fees,
+        std::vector<uint256> const& amendments,
+        Family& family);
+
+    Ledger(LedgerHeader const& info, Rules const& rules, Family& family);
+
+    /** Used for ledgers loaded from JSON files
+
+        @param acquire If true, acquires the ledger if not found locally
+
+        @note The fees parameter provides default values, but setup() may
+              override them from the ledger state if fee-related SLEs exist.
+    */
+    Ledger(
+        LedgerHeader const& info,
+        bool& loaded,
+        bool acquire,
+        Rules const& rules,
+        Fees const& fees,
+        Family& family,
+        beast::Journal j);
+
+    /** Create a new ledger following a previous ledger
+
+        The ledger will have the sequence number that
+        follows previous, and have
+        parentCloseTime == previous.closeTime.
+    */
+    Ledger(Ledger const& previous, NetClock::time_point closeTime);
+
+    // used for database ledgers
+    Ledger(
+        std::uint32_t ledgerSeq,
+        NetClock::time_point closeTime,
+        Rules const& rules,
+        Fees const& fees,
+        Family& family);
+
+    ~Ledger() = default;
+
+    //
+    // ReadView
+    //
+
+    bool
+    open() const override
+    {
+        return false;
+    }
+
+    LedgerHeader const&
+    header() const override
+    {
+        return header_;
+    }
+
+    void
+    setLedgerInfo(LedgerHeader const& info)
+    {
+        header_ = info;
+    }
+
+    Fees const&
+    fees() const override
+    {
+        return fees_;
+    }
+
+    Rules const&
+    rules() const override
+    {
+        return rules_;
+    }
+
+    bool
+    exists(Keylet const& k) const override;
+
+    bool
+    exists(uint256 const& key) const;
+
+    std::optional<uint256>
+    succ(uint256 const& key, std::optional<uint256> const& last = std::nullopt) const override;
+
+    std::shared_ptr<SLE const>
+    read(Keylet const& k) const override;
+
+    std::unique_ptr<sles_type::iter_base>
+    slesBegin() const override;
+
+    std::unique_ptr<sles_type::iter_base>
+    slesEnd() const override;
+
+    std::unique_ptr<sles_type::iter_base>
+    slesUpperBound(uint256 const& key) const override;
+
+    std::unique_ptr<txs_type::iter_base>
+    txsBegin() const override;
+
+    std::unique_ptr<txs_type::iter_base>
+    txsEnd() const override;
+
+    bool
+    txExists(uint256 const& key) const override;
+
+    tx_type
+    txRead(key_type const& key) const override;
+
+    //
+    // DigestAwareReadView
+    //
+
+    std::optional<digest_type>
+    digest(key_type const& key) const override;
+
+    //
+    // RawView
+    //
+
+    void
+    rawErase(std::shared_ptr<SLE> const& sle) override;
+
+    void
+    rawInsert(std::shared_ptr<SLE> const& sle) override;
+
+    void
+    rawErase(uint256 const& key);
+
+    void
+    rawReplace(std::shared_ptr<SLE> const& sle) override;
+
+    void
+    rawDestroyXRP(XRPAmount const& fee) override
+    {
+        header_.drops -= fee;
+    }
+
+    //
+    // TxsRawView
+    //
+
+    void
+    rawTxInsert(
+        uint256 const& key,
+        std::shared_ptr<Serializer const> const& txn,
+        std::shared_ptr<Serializer const> const& metaData) override;
+
+    // Insert the transaction, and return the hash of the SHAMap leaf node
+    // holding the transaction. The hash can be used to fetch the transaction
+    // directly, instead of traversing the SHAMap
+    // @param key transaction ID
+    // @param txn transaction
+    // @param metaData transaction metadata
+    // @return hash of SHAMap leaf node that holds the transaction
+    uint256
+    rawTxInsertWithHash(
+        uint256 const& key,
+        std::shared_ptr<Serializer const> const& txn,
+        std::shared_ptr<Serializer const> const& metaData);
+
+    //--------------------------------------------------------------------------
+
+    void
+    setValidated() const
+    {
+        header_.validated = true;
+    }
+
+    void
+    setAccepted(
+        NetClock::time_point closeTime,
+        NetClock::duration closeResolution,
+        bool correctCloseTime);
+
+    void
+    setImmutable(bool rehash = true);
+
+    bool
+    isImmutable() const
+    {
+        return mImmutable;
+    }
+
+    /*  Mark this ledger as "should be full".
+
+        "Full" is metadata property of the ledger, it indicates
+        that the local server wants all the corresponding nodes
+        in durable storage.
+
+        This is marked `const` because it reflects metadata
+        and not data that is in common with other nodes on the
+        network.
+    */
+    void
+    setFull() const
+    {
+        txMap_.setFull();
+        txMap_.setLedgerSeq(header_.seq);
+        stateMap_.setFull();
+        stateMap_.setLedgerSeq(header_.seq);
+    }
+
+    void
+    setTotalDrops(std::uint64_t totDrops)
+    {
+        header_.drops = totDrops;
+    }
+
+    SHAMap const&
+    stateMap() const
+    {
+        return stateMap_;
+    }
+
+    SHAMap&
+    stateMap()
+    {
+        return stateMap_;
+    }
+
+    SHAMap const&
+    txMap() const
+    {
+        return txMap_;
+    }
+
+    SHAMap&
+    txMap()
+    {
+        return txMap_;
+    }
+
+    // returns false on error
+    bool
+    addSLE(SLE const& sle);
+
+    //--------------------------------------------------------------------------
+
+    void
+    updateSkipList();
+
+    bool
+    walkLedger(beast::Journal j, bool parallel = false) const;
+
+    bool
+    isSensible() const;
+
+    void
+    invariants() const;
+    void
+    unshare() const;
+
+    /**
+     * get Negative UNL validators' master public keys
+     *
+     * @return the public keys
+     */
+    hash_set<PublicKey>
+    negativeUNL() const;
+
+    /**
+     * get the to be disabled validator's master public key if any
+     *
+     * @return the public key if any
+     */
+    std::optional<PublicKey>
+    validatorToDisable() const;
+
+    /**
+     * get the to be re-enabled validator's master public key if any
+     *
+     * @return the public key if any
+     */
+    std::optional<PublicKey>
+    validatorToReEnable() const;
+
+    /**
+     * update the Negative UNL ledger component.
+     * @note must be called at and only at flag ledgers
+     *       must be called before applying UNLModify Tx
+     */
+    void
+    updateNegativeUNL();
+
+    /** Returns true if the ledger is a flag ledger */
+    bool
+    isFlagLedger() const;
+
+    /** Returns true if the ledger directly precedes a flag ledger */
+    bool
+    isVotingLedger() const;
+
+    std::shared_ptr<SLE>
+    peek(Keylet const& k) const;
+
+private:
+    class sles_iter_impl;
+    class txs_iter_impl;
+
+    bool
+    setup();
+
+    /** @brief Deserialize a SHAMapItem containing a single STTx.
+     *
+     * @param item The SHAMapItem to deserialize.
+     * @return A shared pointer to the deserialized transaction.
+     * @throw May throw on deserialization error.
+     */
+    static std::shared_ptr<STTx const>
+    deserializeTx(SHAMapItem const& item);
+
+    /** @brief Deserialize a SHAMapItem containing STTx + STObject metadata.
+     *
+     * The SHAMapItem must contain two variable length serialization objects.
+     *
+     * @param item The SHAMapItem to deserialize.
+     * @return A pair containing shared pointers to the deserialized transaction
+     *         and metadata.
+     * @throw May throw on deserialization error.
+     */
+    static std::pair<std::shared_ptr<STTx const>, std::shared_ptr<STObject const>>
+    deserializeTxPlusMeta(SHAMapItem const& item);
+
+    bool mImmutable;
+
+    // A SHAMap containing the transactions associated with this ledger.
+    SHAMap mutable txMap_;
+
+    // A SHAMap containing the state objects for this ledger.
+    SHAMap mutable stateMap_;
+
+    // Protects fee variables
+    std::mutex mutable mutex_;
+
+    Fees fees_;
+    Rules rules_;
+    LedgerHeader header_;
+    beast::Journal j_;
+};
+
+/** A ledger wrapped in a CachedView. */
+using CachedLedger = CachedView<Ledger>;
+
+}  // namespace xrpl

include/xrpl/ledger/LedgerTiming.h

@@ -0,0 +1,146 @@
+#pragma once
+
+#include <xrpl/basics/chrono.h>
+#include <xrpl/beast/utility/Journal.h>
+
+#include <chrono>
+
+namespace xrpl {
+
+/**  Possible ledger close time resolutions.
+
+    Values should not be duplicated.
+    @see getNextLedgerTimeResolution
+*/
+std::chrono::seconds constexpr ledgerPossibleTimeResolutions[] = {
+    std::chrono::seconds{10},
+    std::chrono::seconds{20},
+    std::chrono::seconds{30},
+    std::chrono::seconds{60},
+    std::chrono::seconds{90},
+    std::chrono::seconds{120}};
+
+//! Initial resolution of ledger close time.
+auto constexpr ledgerDefaultTimeResolution = ledgerPossibleTimeResolutions[2];
+
+//! Close time resolution in genesis ledger
+auto constexpr ledgerGenesisTimeResolution = ledgerPossibleTimeResolutions[0];
+
+//! How often we increase the close time resolution (in numbers of ledgers)
+auto constexpr increaseLedgerTimeResolutionEvery = 8;
+
+//! How often we decrease the close time resolution (in numbers of ledgers)
+auto constexpr decreaseLedgerTimeResolutionEvery = 1;
+
+/** Calculates the close time resolution for the specified ledger.
+
+    The Ripple protocol uses binning to represent time intervals using only one
+    timestamp. This allows servers to derive a common time for the next ledger,
+    without the need for perfectly synchronized clocks.
+    The time resolution (i.e. the size of the intervals) is adjusted dynamically
+    based on what happened in the last ledger, to try to avoid disagreements.
+
+    @param previousResolution the resolution used for the prior ledger
+    @param previousAgree whether consensus agreed on the close time of the prior
+    ledger
+    @param ledgerSeq the sequence number of the new ledger
+
+    @pre previousResolution must be a valid bin
+         from @ref ledgerPossibleTimeResolutions
+
+    @tparam Rep Type representing number of ticks in std::chrono::duration
+    @tparam Period An std::ratio representing tick period in
+                   std::chrono::duration
+    @tparam Seq Unsigned integer-like type corresponding to the ledger sequence
+                number. It should be comparable to 0 and support modular
+                division. Built-in and tagged_integers are supported.
+*/
+template <class Rep, class Period, class Seq>
+std::chrono::duration<Rep, Period>
+getNextLedgerTimeResolution(
+    std::chrono::duration<Rep, Period> previousResolution,
+    bool previousAgree,
+    Seq ledgerSeq)
+{
+    XRPL_ASSERT(ledgerSeq != Seq{0}, "ripple:getNextLedgerTimeResolution : valid ledger sequence");
+
+    using namespace std::chrono;
+    // Find the current resolution:
+    auto iter = std::find(
+        std::begin(ledgerPossibleTimeResolutions),
+        std::end(ledgerPossibleTimeResolutions),
+        previousResolution);
+    XRPL_ASSERT(
+        iter != std::end(ledgerPossibleTimeResolutions),
+        "ripple:getNextLedgerTimeResolution : found time resolution");
+
+    // This should never happen, but just as a precaution
+    if (iter == std::end(ledgerPossibleTimeResolutions))
+        return previousResolution;
+
+    // If we did not previously agree, we try to decrease the resolution to
+    // improve the chance that we will agree now.
+    if (!previousAgree && (ledgerSeq % Seq{decreaseLedgerTimeResolutionEvery} == Seq{0}))
+    {
+        if (++iter != std::end(ledgerPossibleTimeResolutions))
+            return *iter;
+    }
+
+    // If we previously agreed, we try to increase the resolution to determine
+    // if we can continue to agree.
+    if (previousAgree && (ledgerSeq % Seq{increaseLedgerTimeResolutionEvery} == Seq{0}))
+    {
+        if (iter-- != std::begin(ledgerPossibleTimeResolutions))
+            return *iter;
+    }
+
+    return previousResolution;
+}
+
+/** Calculates the close time for a ledger, given a close time resolution.
+
+    @param closeTime The time to be rounded
+    @param closeResolution The resolution
+    @return @b closeTime rounded to the nearest multiple of @b closeResolution.
+    Rounds up if @b closeTime is midway between multiples of @b closeResolution.
+*/
+template <class Clock, class Duration, class Rep, class Period>
+std::chrono::time_point<Clock, Duration>
+roundCloseTime(
+    std::chrono::time_point<Clock, Duration> closeTime,
+    std::chrono::duration<Rep, Period> closeResolution)
+{
+    using time_point = decltype(closeTime);
+    if (closeTime == time_point{})
+        return closeTime;
+
+    closeTime += (closeResolution / 2);
+    return closeTime - (closeTime.time_since_epoch() % closeResolution);
+}
+
+/** Calculate the effective ledger close time
+
+    After adjusting the ledger close time based on the current resolution, also
+    ensure it is sufficiently separated from the prior close time.
+
+    @param closeTime The raw ledger close time
+    @param resolution The current close time resolution
+    @param priorCloseTime The close time of the prior ledger
+*/
+template <class Clock, class Duration, class Rep, class Period>
+std::chrono::time_point<Clock, Duration>
+effCloseTime(
+    std::chrono::time_point<Clock, Duration> closeTime,
+    std::chrono::duration<Rep, Period> resolution,
+    std::chrono::time_point<Clock, Duration> priorCloseTime)
+{
+    using namespace std::chrono_literals;
+    using time_point = decltype(closeTime);
+
+    if (closeTime == time_point{})
+        return closeTime;
+
+    return std::max<time_point>(roundCloseTime(closeTime, resolution), (priorCloseTime + 1s));
+}
+
+}  // namespace xrpl

include/xrpl/ledger/OrderBookDB.h

@@ -76,16 +76,33 @@ public:
         @return true if a book from this issue to XRP exists
     */
     virtual bool
-    isBookToXRP(Issue const& issue, std::optional<Domain> domain = std::nullopt) = 0;
+    isBookToXRP(Issue const& issue, std::optional<Domain> const& domain = std::nullopt) = 0;
 
+    /**
+     * Process a transaction for order book tracking.
+     * @param ledger The ledger the transaction was applied to
+     * @param alTx The transaction to process
+     * @param jvObj The JSON object of the transaction
+     */
     virtual void
     processTxn(
         std::shared_ptr<ReadView const> const& ledger,
         AcceptedLedgerTx const& alTx,
         MultiApiJson const& jvObj) = 0;
 
+    /**
+     * Get the book listeners for a book.
+     * @param book The book to get the listeners for
+     * @return The book listeners for the book
+     */
     virtual BookListeners::pointer
     getBookListeners(Book const&) = 0;
+
+    /**
+     * Create a new book listeners for a book.
+     * @param book The book to create the listeners for
+     * @return The new book listeners for the book
+     */
     virtual BookListeners::pointer
     makeBookListeners(Book const&) = 0;
 };

include/xrpl/ledger/PendingSaves.h

@@ -0,0 +1,126 @@
+#pragma once
+
+#include <xrpl/protocol/Protocol.h>
+
+#include <condition_variable>
+#include <map>
+#include <mutex>
+
+namespace xrpl {
+
+/** Keeps track of which ledgers haven't been fully saved.
+
+    During the ledger building process this collection will keep
+    track of those ledgers that are being built but have not yet
+    been completely written.
+*/
+class PendingSaves
+{
+private:
+    std::mutex mutable mutex_;
+    std::map<LedgerIndex, bool> map_;
+    std::condition_variable await_;
+
+public:
+    /** Start working on a ledger
+
+        This is called prior to updating the SQLite indexes.
+
+        @return 'true' if work should be done
+    */
+    bool
+    startWork(LedgerIndex seq)
+    {
+        std::lock_guard lock(mutex_);
+
+        auto it = map_.find(seq);
+
+        if ((it == map_.end()) || it->second)
+        {
+            // Work done or another thread is doing it
+            return false;
+        }
+
+        it->second = true;
+        return true;
+    }
+
+    /** Finish working on a ledger
+
+        This is called after updating the SQLite indexes.
+        The tracking of the work in progress is removed and
+        threads awaiting completion are notified.
+    */
+    void
+    finishWork(LedgerIndex seq)
+    {
+        std::lock_guard lock(mutex_);
+
+        map_.erase(seq);
+        await_.notify_all();
+    }
+
+    /** Return `true` if a ledger is in the progress of being saved. */
+    bool
+    pending(LedgerIndex seq)
+    {
+        std::lock_guard lock(mutex_);
+        return map_.find(seq) != map_.end();
+    }
+
+    /** Check if a ledger should be dispatched
+
+        Called to determine whether work should be done or
+        dispatched. If work is already in progress and the
+        call is synchronous, wait for work to be completed.
+
+        @return 'true' if work should be done or dispatched
+    */
+    bool
+    shouldWork(LedgerIndex seq, bool isSynchronous)
+    {
+        std::unique_lock<std::mutex> lock(mutex_);
+        do
+        {
+            auto it = map_.find(seq);
+
+            if (it == map_.end())
+            {
+                map_.emplace(seq, false);
+                return true;
+            }
+
+            if (!isSynchronous)
+            {
+                // Already dispatched
+                return false;
+            }
+
+            if (!it->second)
+            {
+                // Scheduled, but not dispatched
+                return true;
+            }
+
+            // Already in progress, just need to wait
+            await_.wait(lock);
+
+        } while (true);
+    }
+
+    /** Get a snapshot of the pending saves
+
+        Each entry in the returned map corresponds to a ledger
+        that is in progress or dispatched. The boolean indicates
+        whether work is currently in progress.
+    */
+    std::map<LedgerIndex, bool>
+    getSnapshot() const
+    {
+        std::lock_guard lock(mutex_);
+
+        return map_;
+    }
+};
+
+}  // namespace xrpl

include/xrpl/ledger/View.h

@@ -2,26 +2,23 @@
 
 #include <xrpl/beast/utility/Journal.h>
 #include <xrpl/ledger/ApplyView.h>
-#include <xrpl/ledger/OpenView.h>
 #include <xrpl/ledger/ReadView.h>
-#include <xrpl/protocol/Asset.h>
-#include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/MPTIssue.h>
 #include <xrpl/protocol/Protocol.h>
-#include <xrpl/protocol/Rate.h>
 #include <xrpl/protocol/STLedgerEntry.h>
-#include <xrpl/protocol/STObject.h>
-#include <xrpl/protocol/Serializer.h>
+#include <xrpl/protocol/STTx.h>
 #include <xrpl/protocol/TER.h>
 
+#include <cstdint>
 #include <functional>
-#include <initializer_list>
 #include <map>
+#include <memory>
+#include <optional>
+#include <set>
 #include <utility>
 
 namespace xrpl {
 
-enum class WaiveTransferFee : bool { No = false, Yes };
 enum class SkipEntry : bool { No = false, Yes };
 
 //------------------------------------------------------------------------------
@@ -54,24 +51,6 @@ enum class SkipEntry : bool { No = false, Yes };
 [[nodiscard]] bool
 hasExpired(ReadView const& view, std::optional<std::uint32_t> const& exp);
 
-/** Controls the treatment of frozen account balances */
-enum FreezeHandling { fhIGNORE_FREEZE, fhZERO_IF_FROZEN };
-
-/** Controls the treatment of unauthorized MPT balances */
-enum AuthHandling { ahIGNORE_AUTH, ahZERO_IF_UNAUTHORIZED };
-
-/** Controls whether to include the account's full spendable balance */
-enum SpendableHandling { shSIMPLE_BALANCE, shFULL_BALANCE };
-
-[[nodiscard]] bool
-isGlobalFrozen(ReadView const& view, AccountID const& issuer);
-
-[[nodiscard]] bool
-isGlobalFrozen(ReadView const& view, MPTIssue const& mptIssue);
-
-[[nodiscard]] bool
-isGlobalFrozen(ReadView const& view, Asset const& asset);
-
 // Note, depth parameter is used to limit the recursion depth
 [[nodiscard]] bool
 isVaultPseudoAccountFrozen(
@@ -80,175 +59,6 @@ isVaultPseudoAccountFrozen(
     MPTIssue const& mptShare,
     int depth);
 
-[[nodiscard]] bool
-isIndividualFrozen(
-    ReadView const& view,
-    AccountID const& account,
-    Currency const& currency,
-    AccountID const& issuer);
-
-[[nodiscard]] inline bool
-isIndividualFrozen(ReadView const& view, AccountID const& account, Issue const& issue)
-{
-    return isIndividualFrozen(view, account, issue.currency, issue.account);
-}
-
-[[nodiscard]] bool
-isIndividualFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptIssue);
-
-[[nodiscard]] inline bool
-isIndividualFrozen(ReadView const& view, AccountID const& account, Asset const& asset)
-{
-    return std::visit(
-        [&](auto const& issue) { return isIndividualFrozen(view, account, issue); }, asset.value());
-}
-
-[[nodiscard]] bool
-isFrozen(
-    ReadView const& view,
-    AccountID const& account,
-    Currency const& currency,
-    AccountID const& issuer);
-
-[[nodiscard]] inline bool
-isFrozen(ReadView const& view, AccountID const& account, Issue const& issue, int = 0 /*ignored*/)
-{
-    return isFrozen(view, account, issue.currency, issue.account);
-}
-
-[[nodiscard]] bool
-isFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptIssue, int depth = 0);
-
-/**
- *   isFrozen check is recursive for MPT shares in a vault, descending to
- *   assets in the vault, up to maxAssetCheckDepth recursion depth. This is
- *   purely defensive, as we currently do not allow such vaults to be created.
- */
-[[nodiscard]] inline bool
-isFrozen(ReadView const& view, AccountID const& account, Asset const& asset, int depth = 0)
-{
-    return std::visit(
-        [&](auto const& issue) { return isFrozen(view, account, issue, depth); }, asset.value());
-}
-
-[[nodiscard]] inline TER
-checkFrozen(ReadView const& view, AccountID const& account, Issue const& issue)
-{
-    return isFrozen(view, account, issue) ? (TER)tecFROZEN : (TER)tesSUCCESS;
-}
-
-[[nodiscard]] inline TER
-checkFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptIssue)
-{
-    return isFrozen(view, account, mptIssue) ? (TER)tecLOCKED : (TER)tesSUCCESS;
-}
-
-[[nodiscard]] inline TER
-checkFrozen(ReadView const& view, AccountID const& account, Asset const& asset)
-{
-    return std::visit(
-        [&](auto const& issue) { return checkFrozen(view, account, issue); }, asset.value());
-}
-
-[[nodiscard]] bool
-isAnyFrozen(
-    ReadView const& view,
-    std::initializer_list<AccountID> const& accounts,
-    MPTIssue const& mptIssue,
-    int depth = 0);
-
-[[nodiscard]] inline bool
-isAnyFrozen(
-    ReadView const& view,
-    std::initializer_list<AccountID> const& accounts,
-    Issue const& issue)
-{
-    for (auto const& account : accounts)
-    {
-        if (isFrozen(view, account, issue.currency, issue.account))
-            return true;
-    }
-    return false;
-}
-
-[[nodiscard]] inline bool
-isAnyFrozen(
-    ReadView const& view,
-    std::initializer_list<AccountID> const& accounts,
-    Asset const& asset,
-    int depth = 0)
-{
-    return std::visit(
-        [&]<ValidIssueType TIss>(TIss const& issue) {
-            if constexpr (std::is_same_v<TIss, Issue>)
-                return isAnyFrozen(view, accounts, issue);
-            else
-                return isAnyFrozen(view, accounts, issue, depth);
-        },
-        asset.value());
-}
-
-[[nodiscard]] bool
-isDeepFrozen(
-    ReadView const& view,
-    AccountID const& account,
-    Currency const& currency,
-    AccountID const& issuer);
-
-[[nodiscard]] inline bool
-isDeepFrozen(
-    ReadView const& view,
-    AccountID const& account,
-    Issue const& issue,
-    int = 0 /*ignored*/)
-{
-    return isDeepFrozen(view, account, issue.currency, issue.account);
-}
-
-[[nodiscard]] inline bool
-isDeepFrozen(
-    ReadView const& view,
-    AccountID const& account,
-    MPTIssue const& mptIssue,
-    int depth = 0)
-{
-    // Unlike IOUs, frozen / locked MPTs are not allowed to send or receive
-    // funds, so checking "deep frozen" is the same as checking "frozen".
-    return isFrozen(view, account, mptIssue, depth);
-}
-
-/**
- *   isFrozen check is recursive for MPT shares in a vault, descending to
- *   assets in the vault, up to maxAssetCheckDepth recursion depth. This is
- *   purely defensive, as we currently do not allow such vaults to be created.
- */
-[[nodiscard]] inline bool
-isDeepFrozen(ReadView const& view, AccountID const& account, Asset const& asset, int depth = 0)
-{
-    return std::visit(
-        [&](auto const& issue) { return isDeepFrozen(view, account, issue, depth); },
-        asset.value());
-}
-
-[[nodiscard]] inline TER
-checkDeepFrozen(ReadView const& view, AccountID const& account, Issue const& issue)
-{
-    return isDeepFrozen(view, account, issue) ? (TER)tecFROZEN : (TER)tesSUCCESS;
-}
-
-[[nodiscard]] inline TER
-checkDeepFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptIssue)
-{
-    return isDeepFrozen(view, account, mptIssue) ? (TER)tecLOCKED : (TER)tesSUCCESS;
-}
-
-[[nodiscard]] inline TER
-checkDeepFrozen(ReadView const& view, AccountID const& account, Asset const& asset)
-{
-    return std::visit(
-        [&](auto const& issue) { return checkDeepFrozen(view, account, issue); }, asset.value());
-}
-
 [[nodiscard]] bool
 isLPTokenFrozen(
     ReadView const& view,
@@ -256,159 +66,6 @@ isLPTokenFrozen(
     Issue const& asset,
     Issue const& asset2);
 
-// Returns the amount an account can spend.
-//
-// If shSIMPLE_BALANCE is specified, this is the amount the account can spend
-// without going into debt.
-//
-// If shFULL_BALANCE is specified, this is the amount the account can spend
-// total. Specifically:
-// * The account can go into debt if using a trust line, and the other side has
-// a non-zero limit.
-// * If the account is the asset issuer the limit is defined by the asset /
-//   issuance.
-//
-// <-- saAmount: amount of currency held by account. May be negative.
-[[nodiscard]] STAmount
-accountHolds(
-    ReadView const& view,
-    AccountID const& account,
-    Currency const& currency,
-    AccountID const& issuer,
-    FreezeHandling zeroIfFrozen,
-    beast::Journal j,
-    SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
-
-[[nodiscard]] STAmount
-accountHolds(
-    ReadView const& view,
-    AccountID const& account,
-    Issue const& issue,
-    FreezeHandling zeroIfFrozen,
-    beast::Journal j,
-    SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
-
-[[nodiscard]] STAmount
-accountHolds(
-    ReadView const& view,
-    AccountID const& account,
-    MPTIssue const& mptIssue,
-    FreezeHandling zeroIfFrozen,
-    AuthHandling zeroIfUnauthorized,
-    beast::Journal j,
-    SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
-
-[[nodiscard]] STAmount
-accountHolds(
-    ReadView const& view,
-    AccountID const& account,
-    Asset const& asset,
-    FreezeHandling zeroIfFrozen,
-    AuthHandling zeroIfUnauthorized,
-    beast::Journal j,
-    SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
-
-// Returns the amount an account can spend of the currency type saDefault, or
-// returns saDefault if this account is the issuer of the currency in
-// question. Should be used in favor of accountHolds when questioning how much
-// an account can spend while also allowing currency issuers to spend
-// unlimited amounts of their own currency (since they can always issue more).
-[[nodiscard]] STAmount
-accountFunds(
-    ReadView const& view,
-    AccountID const& id,
-    STAmount const& saDefault,
-    FreezeHandling freezeHandling,
-    beast::Journal j);
-
-// Return the account's liquid (not reserved) XRP.  Generally prefer
-// calling accountHolds() over this interface.  However, this interface
-// allows the caller to temporarily adjust the owner count should that be
-// necessary.
-//
-// @param ownerCountAdj positive to add to count, negative to reduce count.
-[[nodiscard]] XRPAmount
-xrpLiquid(ReadView const& view, AccountID const& id, std::int32_t ownerCountAdj, beast::Journal j);
-
-/** Iterate all items in the given directory. */
-void
-forEachItem(
-    ReadView const& view,
-    Keylet const& root,
-    std::function<void(std::shared_ptr<SLE const> const&)> const& f);
-
-/** Iterate all items after an item in the given directory.
-    @param after The key of the item to start after
-    @param hint The directory page containing `after`
-    @param limit The maximum number of items to return
-    @return `false` if the iteration failed
-*/
-bool
-forEachItemAfter(
-    ReadView const& view,
-    Keylet const& root,
-    uint256 const& after,
-    std::uint64_t const hint,
-    unsigned int limit,
-    std::function<bool(std::shared_ptr<SLE const> const&)> const& f);
-
-/** Iterate all items in an account's owner directory. */
-inline void
-forEachItem(
-    ReadView const& view,
-    AccountID const& id,
-    std::function<void(std::shared_ptr<SLE const> const&)> const& f)
-{
-    return forEachItem(view, keylet::ownerDir(id), f);
-}
-
-/** Iterate all items after an item in an owner directory.
-    @param after The key of the item to start after
-    @param hint The directory page containing `after`
-    @param limit The maximum number of items to return
-    @return `false` if the iteration failed
-*/
-inline bool
-forEachItemAfter(
-    ReadView const& view,
-    AccountID const& id,
-    uint256 const& after,
-    std::uint64_t const hint,
-    unsigned int limit,
-    std::function<bool(std::shared_ptr<SLE const> const&)> const& f)
-{
-    return forEachItemAfter(view, keylet::ownerDir(id), after, hint, limit, f);
-}
-
-/** Returns IOU issuer transfer fee as Rate. Rate specifies
- * the fee as fractions of 1 billion. For example, 1% transfer rate
- * is represented as 1,010,000,000.
- * @param issuer The IOU issuer
- */
-[[nodiscard]] Rate
-transferRate(ReadView const& view, AccountID const& issuer);
-
-/** Returns MPT transfer fee as Rate. Rate specifies
- * the fee as fractions of 1 billion. For example, 1% transfer rate
- * is represented as 1,010,000,000.
- * @param issuanceID MPTokenIssuanceID of MPTTokenIssuance object
- */
-[[nodiscard]] Rate
-transferRate(ReadView const& view, MPTID const& issuanceID);
-
-/** Returns the transfer fee as Rate based on the type of token
- * @param view The ledger view
- * @param amount The amount to transfer
- */
-[[nodiscard]] Rate
-transferRate(ReadView const& view, STAmount const& amount);
-
-/** Returns `true` if the directory is empty
-    @param key The key of the directory
-*/
-[[nodiscard]] bool
-dirIsEmpty(ReadView const& view, Keylet const& k);
-
 // Return the list of enabled amendments
 [[nodiscard]] std::set<uint256>
 getEnabledAmendments(ReadView const& view);
@@ -474,81 +131,6 @@ areCompatible(
 //
 //------------------------------------------------------------------------------
 
-/** Adjust the owner count up or down. */
-void
-adjustOwnerCount(
-    ApplyView& view,
-    std::shared_ptr<SLE> const& sle,
-    std::int32_t amount,
-    beast::Journal j);
-
-/** @{ */
-/** Returns the first entry in the directory, advancing the index
-
-    @deprecated These are legacy function that are considered deprecated
-                and will soon be replaced with an iterator-based model
-                that is easier to use. You should not use them in new code.
-
-    @param view The view against which to operate
-    @param root The root (i.e. first page) of the directory to iterate
-    @param page The current page
-    @param index The index inside the current page
-    @param entry The entry at the current index
-
-    @return true if the directory isn't empty; false otherwise
- */
-bool
-cdirFirst(
-    ReadView const& view,
-    uint256 const& root,
-    std::shared_ptr<SLE const>& page,
-    unsigned int& index,
-    uint256& entry);
-
-bool
-dirFirst(
-    ApplyView& view,
-    uint256 const& root,
-    std::shared_ptr<SLE>& page,
-    unsigned int& index,
-    uint256& entry);
-/** @} */
-
-/** @{ */
-/** Returns the next entry in the directory, advancing the index
-
-    @deprecated These are legacy function that are considered deprecated
-                and will soon be replaced with an iterator-based model
-                that is easier to use. You should not use them in new code.
-
-    @param view The view against which to operate
-    @param root The root (i.e. first page) of the directory to iterate
-    @param page The current page
-    @param index The index inside the current page
-    @param entry The entry at the current index
-
-    @return true if the directory isn't empty; false otherwise
- */
-bool
-cdirNext(
-    ReadView const& view,
-    uint256 const& root,
-    std::shared_ptr<SLE const>& page,
-    unsigned int& index,
-    uint256& entry);
-
-bool
-dirNext(
-    ApplyView& view,
-    uint256 const& root,
-    std::shared_ptr<SLE>& page,
-    unsigned int& index,
-    uint256& entry);
-/** @} */
-
-[[nodiscard]] std::function<void(SLE::ref)>
-describeOwnerDir(AccountID const& account);
-
 [[nodiscard]] TER
 dirLink(
     ApplyView& view,
@@ -556,63 +138,6 @@ dirLink(
     std::shared_ptr<SLE>& object,
     SF_UINT64 const& node = sfOwnerNode);
 
-AccountID
-pseudoAccountAddress(ReadView const& view, uint256 const& pseudoOwnerKey);
-
-/**
- *
- * Create pseudo-account, storing pseudoOwnerKey into ownerField.
- *
- * The list of valid ownerField is maintained in View.cpp and the caller to
- * this function must perform necessary amendment check(s) before using a
- * field. The amendment check is **not** performed in createPseudoAccount.
- */
-[[nodiscard]] Expected<std::shared_ptr<SLE>, TER>
-createPseudoAccount(ApplyView& view, uint256 const& pseudoOwnerKey, SField const& ownerField);
-
-// Returns true if and only if sleAcct is a pseudo-account or specific
-// pseudo-accounts in pseudoFieldFilter.
-//
-// Returns false if sleAcct is
-// * NOT a pseudo-account OR
-// * NOT a ltACCOUNT_ROOT OR
-// * null pointer
-[[nodiscard]] bool
-isPseudoAccount(
-    std::shared_ptr<SLE const> sleAcct,
-    std::set<SField const*> const& pseudoFieldFilter = {});
-
-// Returns the list of fields that define an ACCOUNT_ROOT as a pseudo-account if
-// set
-// Pseudo-account designator fields MUST be maintained by including the
-// SField::sMD_PseudoAccount flag in the SField definition. (Don't forget to
-// "| SField::sMD_Default"!) The fields do NOT need to be amendment-gated,
-// since a non-active amendment will not set any field, by definition.
-// Specific properties of a pseudo-account are NOT checked here, that's what
-// InvariantCheck is for.
-[[nodiscard]] std::vector<SField const*> const&
-getPseudoAccountFields();
-
-[[nodiscard]] inline bool
-isPseudoAccount(
-    ReadView const& view,
-    AccountID const& accountId,
-    std::set<SField const*> const& pseudoFieldFilter = {})
-{
-    return isPseudoAccount(view.read(keylet::account(accountId)), pseudoFieldFilter);
-}
-
-[[nodiscard]] TER
-canAddHolding(ReadView const& view, Asset const& asset);
-
-/** Validates that the destination SLE and tag are valid
-
-   - Checks that the SLE is not null.
-   - If the SLE requires a destination tag, checks that there is a tag.
-*/
-[[nodiscard]] TER
-checkDestinationAndTag(SLE::const_ref toSle, bool hasDestinationTag);
-
 /** Checks that can withdraw funds from an object to itself or a destination.
  *
  * The receiver may be either the submitting account (sfAccount) or a different
@@ -686,351 +211,6 @@ doWithdraw(
     STAmount const& amount,
     beast::Journal j);
 
-/// Any transactors that call addEmptyHolding() in doApply must call
-/// canAddHolding() in preflight with the same View and Asset
-[[nodiscard]] TER
-addEmptyHolding(
-    ApplyView& view,
-    AccountID const& accountID,
-    XRPAmount priorBalance,
-    Issue const& issue,
-    beast::Journal journal);
-
-[[nodiscard]] TER
-addEmptyHolding(
-    ApplyView& view,
-    AccountID const& accountID,
-    XRPAmount priorBalance,
-    MPTIssue const& mptIssue,
-    beast::Journal journal);
-
-[[nodiscard]] inline TER
-addEmptyHolding(
-    ApplyView& view,
-    AccountID const& accountID,
-    XRPAmount priorBalance,
-    Asset const& asset,
-    beast::Journal journal)
-{
-    return std::visit(
-        [&]<ValidIssueType TIss>(TIss const& issue) -> TER {
-            return addEmptyHolding(view, accountID, priorBalance, issue, journal);
-        },
-        asset.value());
-}
-
-[[nodiscard]] TER
-authorizeMPToken(
-    ApplyView& view,
-    XRPAmount const& priorBalance,
-    MPTID const& mptIssuanceID,
-    AccountID const& account,
-    beast::Journal journal,
-    std::uint32_t flags = 0,
-    std::optional<AccountID> holderID = std::nullopt);
-
-// VFALCO NOTE Both STAmount parameters should just
-//             be "Amount", a unit-less number.
-//
-/** Create a trust line
-
-    This can set an initial balance.
-*/
-[[nodiscard]] TER
-trustCreate(
-    ApplyView& view,
-    bool const bSrcHigh,
-    AccountID const& uSrcAccountID,
-    AccountID const& uDstAccountID,
-    uint256 const& uIndex,      // --> ripple state entry
-    SLE::ref sleAccount,        // --> the account being set.
-    bool const bAuth,           // --> authorize account.
-    bool const bNoRipple,       // --> others cannot ripple through
-    bool const bFreeze,         // --> funds cannot leave
-    bool bDeepFreeze,           // --> can neither receive nor send funds
-    STAmount const& saBalance,  // --> balance of account being set.
-                                // Issuer should be noAccount()
-    STAmount const& saLimit,    // --> limit for account being set.
-                                // Issuer should be the account being set.
-    std::uint32_t uSrcQualityIn,
-    std::uint32_t uSrcQualityOut,
-    beast::Journal j);
-
-[[nodiscard]] TER
-removeEmptyHolding(
-    ApplyView& view,
-    AccountID const& accountID,
-    Issue const& issue,
-    beast::Journal journal);
-
-[[nodiscard]] TER
-removeEmptyHolding(
-    ApplyView& view,
-    AccountID const& accountID,
-    MPTIssue const& mptIssue,
-    beast::Journal journal);
-
-[[nodiscard]] inline TER
-removeEmptyHolding(
-    ApplyView& view,
-    AccountID const& accountID,
-    Asset const& asset,
-    beast::Journal journal)
-{
-    return std::visit(
-        [&]<ValidIssueType TIss>(TIss const& issue) -> TER {
-            return removeEmptyHolding(view, accountID, issue, journal);
-        },
-        asset.value());
-}
-
-[[nodiscard]] TER
-trustDelete(
-    ApplyView& view,
-    std::shared_ptr<SLE> const& sleRippleState,
-    AccountID const& uLowAccountID,
-    AccountID const& uHighAccountID,
-    beast::Journal j);
-
-/** Delete an offer.
-
-    Requirements:
-        The passed `sle` be obtained from a prior
-        call to view.peek()
-*/
-// [[nodiscard]] // nodiscard commented out so Flow, BookTip and others compile.
-TER
-offerDelete(ApplyView& view, std::shared_ptr<SLE> const& sle, beast::Journal j);
-
-//------------------------------------------------------------------------------
-
-//
-// Money Transfers
-//
-
-// Direct send w/o fees:
-// - Redeeming IOUs and/or sending sender's own IOUs.
-// - Create trust line of needed.
-// --> bCheckIssuer : normally require issuer to be involved.
-// [[nodiscard]] // nodiscard commented out so DirectStep.cpp compiles.
-
-/** Calls static rippleCreditIOU if saAmount represents Issue.
- * Calls static rippleCreditMPT if saAmount represents MPTIssue.
- */
-TER
-rippleCredit(
-    ApplyView& view,
-    AccountID const& uSenderID,
-    AccountID const& uReceiverID,
-    STAmount const& saAmount,
-    bool bCheckIssuer,
-    beast::Journal j);
-
-TER
-rippleLockEscrowMPT(
-    ApplyView& view,
-    AccountID const& uGrantorID,
-    STAmount const& saAmount,
-    beast::Journal j);
-
-TER
-rippleUnlockEscrowMPT(
-    ApplyView& view,
-    AccountID const& uGrantorID,
-    AccountID const& uGranteeID,
-    STAmount const& netAmount,
-    STAmount const& grossAmount,
-    beast::Journal j);
-
-/** Calls static accountSendIOU if saAmount represents Issue.
- * Calls static accountSendMPT if saAmount represents MPTIssue.
- */
-[[nodiscard]] TER
-accountSend(
-    ApplyView& view,
-    AccountID const& from,
-    AccountID const& to,
-    STAmount const& saAmount,
-    beast::Journal j,
-    WaiveTransferFee waiveFee = WaiveTransferFee::No);
-
-using MultiplePaymentDestinations = std::vector<std::pair<AccountID, Number>>;
-/** Like accountSend, except one account is sending multiple payments (with the
- *  same asset!) simultaneously
- *
- * Calls static accountSendMultiIOU if saAmount represents Issue.
- * Calls static accountSendMultiMPT if saAmount represents MPTIssue.
- */
-[[nodiscard]] TER
-accountSendMulti(
-    ApplyView& view,
-    AccountID const& senderID,
-    Asset const& asset,
-    MultiplePaymentDestinations const& receivers,
-    beast::Journal j,
-    WaiveTransferFee waiveFee = WaiveTransferFee::No);
-
-[[nodiscard]] TER
-issueIOU(
-    ApplyView& view,
-    AccountID const& account,
-    STAmount const& amount,
-    Issue const& issue,
-    beast::Journal j);
-
-[[nodiscard]] TER
-redeemIOU(
-    ApplyView& view,
-    AccountID const& account,
-    STAmount const& amount,
-    Issue const& issue,
-    beast::Journal j);
-
-[[nodiscard]] TER
-transferXRP(
-    ApplyView& view,
-    AccountID const& from,
-    AccountID const& to,
-    STAmount const& amount,
-    beast::Journal j);
-
-/* Check if MPToken (for MPT) or trust line (for IOU) exists:
- * - StrongAuth - before checking if authorization is required
- * - WeakAuth
- *    for MPT - after checking lsfMPTRequireAuth flag
- *    for IOU - do not check if trust line exists
- * - Legacy
- *    for MPT - before checking lsfMPTRequireAuth flag i.e. same as StrongAuth
- *    for IOU - do not check if trust line exists i.e. same as WeakAuth
- */
-enum class AuthType { StrongAuth, WeakAuth, Legacy };
-
-/** Check if the account lacks required authorization.
- *
- * Return tecNO_AUTH or tecNO_LINE if it does
- * and tesSUCCESS otherwise.
- *
- * If StrongAuth then return tecNO_LINE if the RippleState doesn't exist. Return
- * tecNO_AUTH if lsfRequireAuth is set on the issuer's AccountRoot, and the
- * RippleState does exist, and the RippleState is not authorized.
- *
- * If WeakAuth then return tecNO_AUTH if lsfRequireAuth is set, and the
- * RippleState exists, and is not authorized. Return tecNO_LINE if
- * lsfRequireAuth is set and the RippleState doesn't exist. Consequently, if
- * WeakAuth and lsfRequireAuth is *not* set, this function will return
- * tesSUCCESS even if RippleState does *not* exist.
- *
- * The default "Legacy" auth type is equivalent to WeakAuth.
- */
-[[nodiscard]] TER
-requireAuth(
-    ReadView const& view,
-    Issue const& issue,
-    AccountID const& account,
-    AuthType authType = AuthType::Legacy);
-
-/** Check if the account lacks required authorization.
- *
- * This will also check for expired credentials. If it is called directly
- * from preclaim, the user should convert result tecEXPIRED to tesSUCCESS and
- * proceed to also check permissions with enforceMPTokenAuthorization inside
- * doApply. This will ensure that any expired credentials are deleted.
- *
- * requireAuth check is recursive for MPT shares in a vault, descending to
- * assets in the vault, up to maxAssetCheckDepth recursion depth. This is
- * purely defensive, as we currently do not allow such vaults to be created.
- *
- * If StrongAuth then return tecNO_AUTH if MPToken doesn't exist or
- * lsfMPTRequireAuth is set and MPToken is not authorized. Vault and LoanBroker
- * pseudo-accounts are implicitly authorized.
- *
- * If WeakAuth then return tecNO_AUTH if lsfMPTRequireAuth is set and MPToken
- * doesn't exist or is not authorized (explicitly or via credentials, if
- * DomainID is set in MPTokenIssuance). Consequently, if WeakAuth and
- * lsfMPTRequireAuth is *not* set, this function will return true even if
- * MPToken does *not* exist.
- *
- * The default "Legacy" auth type is equivalent to StrongAuth.
- */
-[[nodiscard]] TER
-requireAuth(
-    ReadView const& view,
-    MPTIssue const& mptIssue,
-    AccountID const& account,
-    AuthType authType = AuthType::Legacy,
-    int depth = 0);
-
-[[nodiscard]] TER inline requireAuth(
-    ReadView const& view,
-    Asset const& asset,
-    AccountID const& account,
-    AuthType authType = AuthType::Legacy)
-{
-    return std::visit(
-        [&]<ValidIssueType TIss>(TIss const& issue_) {
-            return requireAuth(view, issue_, account, authType);
-        },
-        asset.value());
-}
-
-/** Enforce account has MPToken to match its authorization.
- *
- *   Called from doApply - it will check for expired (and delete if found any)
- *   credentials matching DomainID set in MPTokenIssuance. Must be called if
- *   requireAuth(...MPTIssue...) returned tesSUCCESS or tecEXPIRED in preclaim,
- *   which implies that preclaim should replace `tecEXPIRED` with `tesSUCCESS`
- *   in order for the transactor to proceed to doApply.
- *
- *   This function will create MPToken (if needed) on the basis of any
- *   non-expired credentials and will delete any expired credentials, indirectly
- *   via verifyValidDomain, as per DomainID (if set in MPTokenIssuance).
- *
- *   The caller does NOT need to ensure that DomainID is actually set - this
- *   function handles gracefully both cases when DomainID is set and when not.
- *
- *   The caller does NOT need to look for existing MPToken to match
- *   mptIssue/account - this function checks lsfMPTAuthorized of an existing
- *   MPToken iff DomainID is not set.
- *
- *   Do not use for accounts which hold implied permission e.g. object owners or
- *   if MPTokenIssuance does not require authorization. In both cases use
- *   MPTokenAuthorize::authorize if MPToken does not yet exist.
- */
-[[nodiscard]] TER
-enforceMPTokenAuthorization(
-    ApplyView& view,
-    MPTID const& mptIssuanceID,
-    AccountID const& account,
-    XRPAmount const& priorBalance,
-    beast::Journal j);
-
-/** Check if the destination account is allowed
- *  to receive MPT. Return tecNO_AUTH if it doesn't
- *  and tesSUCCESS otherwise.
- */
-[[nodiscard]] TER
-canTransfer(
-    ReadView const& view,
-    MPTIssue const& mptIssue,
-    AccountID const& from,
-    AccountID const& to);
-
-[[nodiscard]] TER
-canTransfer(ReadView const& view, Issue const& issue, AccountID const& from, AccountID const& to);
-
-[[nodiscard]] TER inline canTransfer(
-    ReadView const& view,
-    Asset const& asset,
-    AccountID const& from,
-    AccountID const& to)
-{
-    return std::visit(
-        [&]<ValidIssueType TIss>(TIss const& issue) -> TER {
-            return canTransfer(view, issue, from, to);
-        },
-        asset.value());
-}
-
 /** Deleter function prototype. Returns the status of the entry deletion
  * (if should not be skipped) and if the entry should be skipped. The status
  * is always tesSUCCESS if the entry should be skipped.
@@ -1052,57 +232,6 @@ cleanupOnAccountDelete(
     beast::Journal j,
     std::optional<std::uint16_t> maxNodesToDelete = std::nullopt);
 
-/** Delete trustline to AMM. The passed `sle` must be obtained from a prior
- * call to view.peek(). Fail if neither side of the trustline is AMM or
- * if ammAccountID is seated and is not one of the trustline's side.
- */
-[[nodiscard]] TER
-deleteAMMTrustLine(
-    ApplyView& view,
-    std::shared_ptr<SLE> sleState,
-    std::optional<AccountID> const& ammAccountID,
-    beast::Journal j);
-
-// From the perspective of a vault, return the number of shares to give the
-// depositor when they deposit a fixed amount of assets. Since shares are MPT
-// this number is integral and always truncated in this calculation.
-[[nodiscard]] std::optional<STAmount>
-assetsToSharesDeposit(
-    std::shared_ptr<SLE const> const& vault,
-    std::shared_ptr<SLE const> const& issuance,
-    STAmount const& assets);
-
-// From the perspective of a vault, return the number of assets to take from
-// depositor when they receive a fixed amount of shares. Note, since shares are
-// MPT, they are always an integral number.
-[[nodiscard]] std::optional<STAmount>
-sharesToAssetsDeposit(
-    std::shared_ptr<SLE const> const& vault,
-    std::shared_ptr<SLE const> const& issuance,
-    STAmount const& shares);
-
-enum class TruncateShares : bool { no = false, yes = true };
-
-// From the perspective of a vault, return the number of shares to demand from
-// the depositor when they ask to withdraw a fixed amount of assets. Since
-// shares are MPT this number is integral, and it will be rounded to nearest
-// unless explicitly requested to be truncated instead.
-[[nodiscard]] std::optional<STAmount>
-assetsToSharesWithdraw(
-    std::shared_ptr<SLE const> const& vault,
-    std::shared_ptr<SLE const> const& issuance,
-    STAmount const& assets,
-    TruncateShares truncate = TruncateShares::no);
-
-// From the perspective of a vault, return the number of assets to give the
-// depositor when they redeem a fixed amount of shares. Note, since shares are
-// MPT, they are always an integral number.
-[[nodiscard]] std::optional<STAmount>
-sharesToAssetsWithdraw(
-    std::shared_ptr<SLE const> const& vault,
-    std::shared_ptr<SLE const> const& issuance,
-    STAmount const& shares);
-
 /** Has the specified time passed?
 
     @param now  the current time

include/xrpl/ledger/helpers/AccountRootHelpers.h

@@ -0,0 +1,112 @@
+#pragma once
+
+#include <xrpl/basics/Expected.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/Rate.h>
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/TER.h>
+
+#include <memory>
+#include <set>
+#include <vector>
+
+namespace xrpl {
+
+/** Check if the issuer has the global freeze flag set.
+    @param issuer The account to check
+    @return true if the account has global freeze set
+*/
+[[nodiscard]] bool
+isGlobalFrozen(ReadView const& view, AccountID const& issuer);
+
+// Calculate liquid XRP balance for an account.
+// This function may be used to calculate the amount of XRP that
+// the holder is able to freely spend. It subtracts reserve requirements.
+//
+// ownerCountAdj adjusts the owner count in case the caller calculates
+// before ledger entries are added or removed. Positive to add, negative
+// to subtract.
+//
+// @param ownerCountAdj positive to add to count, negative to reduce count.
+[[nodiscard]] XRPAmount
+xrpLiquid(ReadView const& view, AccountID const& id, std::int32_t ownerCountAdj, beast::Journal j);
+
+/** Adjust the owner count up or down. */
+void
+adjustOwnerCount(
+    ApplyView& view,
+    std::shared_ptr<SLE> const& sle,
+    std::int32_t amount,
+    beast::Journal j);
+
+/** Returns IOU issuer transfer fee as Rate. Rate specifies
+ * the fee as fractions of 1 billion. For example, 1% transfer rate
+ * is represented as 1,010,000,000.
+ * @param issuer The IOU issuer
+ */
+[[nodiscard]] Rate
+transferRate(ReadView const& view, AccountID const& issuer);
+
+/** Generate a pseudo-account address from a pseudo owner key.
+    @param pseudoOwnerKey The key to generate the address from
+    @return The generated account ID
+*/
+AccountID
+pseudoAccountAddress(ReadView const& view, uint256 const& pseudoOwnerKey);
+
+/** Returns the list of fields that define an ACCOUNT_ROOT as a pseudo-account
+    if set.
+
+    The list is constructed during initialization and is const after that.
+    Pseudo-account designator fields MUST be maintained by including the
+    SField::sMD_PseudoAccount flag in the SField definition.
+*/
+[[nodiscard]] std::vector<SField const*> const&
+getPseudoAccountFields();
+
+/** Returns true if and only if sleAcct is a pseudo-account or specific
+    pseudo-accounts in pseudoFieldFilter.
+
+    Returns false if sleAcct is:
+    - NOT a pseudo-account OR
+    - NOT a ltACCOUNT_ROOT OR
+    - null pointer
+*/
+[[nodiscard]] bool
+isPseudoAccount(
+    std::shared_ptr<SLE const> sleAcct,
+    std::set<SField const*> const& pseudoFieldFilter = {});
+
+/** Convenience overload that reads the account from the view. */
+[[nodiscard]] inline bool
+isPseudoAccount(
+    ReadView const& view,
+    AccountID const& accountId,
+    std::set<SField const*> const& pseudoFieldFilter = {})
+{
+    return isPseudoAccount(view.read(keylet::account(accountId)), pseudoFieldFilter);
+}
+
+/**
+ * Create pseudo-account, storing pseudoOwnerKey into ownerField.
+ *
+ * The list of valid ownerField is maintained in AccountRootHelpers.cpp and
+ * the caller to this function must perform necessary amendment check(s)
+ * before using a field. The amendment check is **not** performed in
+ * createPseudoAccount.
+ */
+[[nodiscard]] Expected<std::shared_ptr<SLE>, TER>
+createPseudoAccount(ApplyView& view, uint256 const& pseudoOwnerKey, SField const& ownerField);
+
+/** Checks the destination and tag.
+
+   - Checks that the SLE is not null.
+   - If the SLE requires a destination tag, checks that there is a tag.
+*/
+[[nodiscard]] TER
+checkDestinationAndTag(SLE::const_ref toSle, bool hasDestinationTag);
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/CredentialHelpers.h

@@ -49,7 +49,7 @@ validDomain(ReadView const& view, uint256 domainID, AccountID const& subject);
 // This function is only called when we about to return tecNO_PERMISSION
 // because all the checks for the DepositPreauth authorization failed.
 TER
-authorizedDepositPreauth(ApplyView const& view, STVector256 const& ctx, AccountID const& dst);
+authorizedDepositPreauth(ReadView const& view, STVector256 const& ctx, AccountID const& dst);
 
 // Sort credentials array, return empty set if there are duplicates
 std::set<std::pair<AccountID, Slice>>
@@ -74,7 +74,7 @@ verifyDepositPreauth(
     ApplyView& view,
     AccountID const& src,
     AccountID const& dst,
-    std::shared_ptr<SLE> const& sleDst,
+    std::shared_ptr<SLE const> const& sleDst,
     beast::Journal j);
 
 }  // namespace xrpl

include/xrpl/ledger/helpers/DirectoryHelpers.h

@@ -0,0 +1,223 @@
+#pragma once
+
+#include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/TER.h>
+
+#include <functional>
+#include <memory>
+#include <type_traits>
+
+namespace xrpl {
+
+namespace detail {
+
+template <
+    class V,
+    class N,
+    class = std::enable_if_t<
+        std::is_same_v<std::remove_cv_t<N>, SLE> && std::is_base_of_v<ReadView, V>>>
+bool
+internalDirNext(
+    V& view,
+    uint256 const& root,
+    std::shared_ptr<N>& page,
+    unsigned int& index,
+    uint256& entry)
+{
+    auto const& svIndexes = page->getFieldV256(sfIndexes);
+    XRPL_ASSERT(index <= svIndexes.size(), "xrpl::detail::internalDirNext : index inside range");
+
+    if (index >= svIndexes.size())
+    {
+        auto const next = page->getFieldU64(sfIndexNext);
+
+        if (!next)
+        {
+            entry.zero();
+            return false;
+        }
+
+        if constexpr (std::is_const_v<N>)
+        {
+            page = view.read(keylet::page(root, next));
+        }
+        else
+        {
+            page = view.peek(keylet::page(root, next));
+        }
+
+        XRPL_ASSERT(page, "xrpl::detail::internalDirNext : non-null root");
+
+        if (!page)
+            return false;
+
+        index = 0;
+
+        return internalDirNext(view, root, page, index, entry);
+    }
+
+    entry = svIndexes[index++];
+    return true;
+}
+
+template <
+    class V,
+    class N,
+    class = std::enable_if_t<
+        std::is_same_v<std::remove_cv_t<N>, SLE> && std::is_base_of_v<ReadView, V>>>
+bool
+internalDirFirst(
+    V& view,
+    uint256 const& root,
+    std::shared_ptr<N>& page,
+    unsigned int& index,
+    uint256& entry)
+{
+    if constexpr (std::is_const_v<N>)
+    {
+        page = view.read(keylet::page(root));
+    }
+    else
+    {
+        page = view.peek(keylet::page(root));
+    }
+
+    if (!page)
+        return false;
+
+    index = 0;
+
+    return internalDirNext(view, root, page, index, entry);
+}
+
+}  // namespace detail
+
+/** @{ */
+/** Returns the first entry in the directory, advancing the index
+
+    @deprecated These are legacy function that are considered deprecated
+                and will soon be replaced with an iterator-based model
+                that is easier to use. You should not use them in new code.
+
+    @param view The view against which to operate
+    @param root The root (i.e. first page) of the directory to iterate
+    @param page The current page
+    @param index The index inside the current page
+    @param entry The entry at the current index
+
+    @return true if the directory isn't empty; false otherwise
+ */
+bool
+cdirFirst(
+    ReadView const& view,
+    uint256 const& root,
+    std::shared_ptr<SLE const>& page,
+    unsigned int& index,
+    uint256& entry);
+
+bool
+dirFirst(
+    ApplyView& view,
+    uint256 const& root,
+    std::shared_ptr<SLE>& page,
+    unsigned int& index,
+    uint256& entry);
+/** @} */
+
+/** @{ */
+/** Returns the next entry in the directory, advancing the index
+
+    @deprecated These are legacy function that are considered deprecated
+                and will soon be replaced with an iterator-based model
+                that is easier to use. You should not use them in new code.
+
+    @param view The view against which to operate
+    @param root The root (i.e. first page) of the directory to iterate
+    @param page The current page
+    @param index The index inside the current page
+    @param entry The entry at the current index
+
+    @return true if the directory isn't empty; false otherwise
+ */
+bool
+cdirNext(
+    ReadView const& view,
+    uint256 const& root,
+    std::shared_ptr<SLE const>& page,
+    unsigned int& index,
+    uint256& entry);
+
+bool
+dirNext(
+    ApplyView& view,
+    uint256 const& root,
+    std::shared_ptr<SLE>& page,
+    unsigned int& index,
+    uint256& entry);
+/** @} */
+
+/** Iterate all items in the given directory. */
+void
+forEachItem(
+    ReadView const& view,
+    Keylet const& root,
+    std::function<void(std::shared_ptr<SLE const> const&)> const& f);
+
+/** Iterate all items after an item in the given directory.
+    @param after The key of the item to start after
+    @param hint The directory page containing `after`
+    @param limit The maximum number of items to return
+    @return `false` if the iteration failed
+*/
+bool
+forEachItemAfter(
+    ReadView const& view,
+    Keylet const& root,
+    uint256 const& after,
+    std::uint64_t const hint,
+    unsigned int limit,
+    std::function<bool(std::shared_ptr<SLE const> const&)> const& f);
+
+/** Iterate all items in an account's owner directory. */
+inline void
+forEachItem(
+    ReadView const& view,
+    AccountID const& id,
+    std::function<void(std::shared_ptr<SLE const> const&)> const& f)
+{
+    return forEachItem(view, keylet::ownerDir(id), f);
+}
+
+/** Iterate all items after an item in an owner directory.
+    @param after The key of the item to start after
+    @param hint The directory page containing `after`
+    @param limit The maximum number of items to return
+    @return `false` if the iteration failed
+*/
+inline bool
+forEachItemAfter(
+    ReadView const& view,
+    AccountID const& id,
+    uint256 const& after,
+    std::uint64_t const hint,
+    unsigned int limit,
+    std::function<bool(std::shared_ptr<SLE const> const&)> const& f)
+{
+    return forEachItemAfter(view, keylet::ownerDir(id), after, hint, limit, f);
+}
+
+/** Returns `true` if the directory is empty
+    @param key The key of the directory
+*/
+[[nodiscard]] bool
+dirIsEmpty(ReadView const& view, Keylet const& k);
+
+/** Returns a function that sets the owner on a directory SLE */
+[[nodiscard]] std::function<void(SLE::ref)>
+describeOwnerDir(AccountID const& account);
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/MPTokenHelpers.h

@@ -0,0 +1,160 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/TokenHelpers.h>
+#include <xrpl/protocol/MPTIssue.h>
+#include <xrpl/protocol/Rate.h>
+#include <xrpl/protocol/STAmount.h>
+#include <xrpl/protocol/TER.h>
+
+#include <initializer_list>
+#include <optional>
+
+namespace xrpl {
+
+//------------------------------------------------------------------------------
+//
+// Freeze checking (MPT-specific)
+//
+//------------------------------------------------------------------------------
+
+[[nodiscard]] bool
+isGlobalFrozen(ReadView const& view, MPTIssue const& mptIssue);
+
+[[nodiscard]] bool
+isIndividualFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptIssue);
+
+[[nodiscard]] bool
+isFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptIssue, int depth = 0);
+
+[[nodiscard]] bool
+isAnyFrozen(
+    ReadView const& view,
+    std::initializer_list<AccountID> const& accounts,
+    MPTIssue const& mptIssue,
+    int depth = 0);
+
+//------------------------------------------------------------------------------
+//
+// Transfer rate (MPT-specific)
+//
+//------------------------------------------------------------------------------
+
+/** Returns MPT transfer fee as Rate. Rate specifies
+ * the fee as fractions of 1 billion. For example, 1% transfer rate
+ * is represented as 1,010,000,000.
+ * @param issuanceID MPTokenIssuanceID of MPTTokenIssuance object
+ */
+[[nodiscard]] Rate
+transferRate(ReadView const& view, MPTID const& issuanceID);
+
+//------------------------------------------------------------------------------
+//
+// Holding checks (MPT-specific)
+//
+//------------------------------------------------------------------------------
+
+[[nodiscard]] TER
+canAddHolding(ReadView const& view, MPTIssue const& mptIssue);
+
+//------------------------------------------------------------------------------
+//
+// Authorization (MPT-specific)
+//
+//------------------------------------------------------------------------------
+
+[[nodiscard]] TER
+authorizeMPToken(
+    ApplyView& view,
+    XRPAmount const& priorBalance,
+    MPTID const& mptIssuanceID,
+    AccountID const& account,
+    beast::Journal journal,
+    std::uint32_t flags = 0,
+    std::optional<AccountID> holderID = std::nullopt);
+
+/** Check if the account lacks required authorization for MPT.
+ *
+ * requireAuth check is recursive for MPT shares in a vault, descending to
+ * assets in the vault, up to maxAssetCheckDepth recursion depth. This is
+ * purely defensive, as we currently do not allow such vaults to be created.
+ */
+[[nodiscard]] TER
+requireAuth(
+    ReadView const& view,
+    MPTIssue const& mptIssue,
+    AccountID const& account,
+    AuthType authType = AuthType::Legacy,
+    int depth = 0);
+
+/** Enforce account has MPToken to match its authorization.
+ *
+ *   Called from doApply - it will check for expired (and delete if found any)
+ *   credentials matching DomainID set in MPTokenIssuance. Must be called if
+ *   requireAuth(...MPTIssue...) returned tesSUCCESS or tecEXPIRED in preclaim.
+ */
+[[nodiscard]] TER
+enforceMPTokenAuthorization(
+    ApplyView& view,
+    MPTID const& mptIssuanceID,
+    AccountID const& account,
+    XRPAmount const& priorBalance,
+    beast::Journal j);
+
+/** Check if the destination account is allowed
+ *  to receive MPT. Return tecNO_AUTH if it doesn't
+ *  and tesSUCCESS otherwise.
+ */
+[[nodiscard]] TER
+canTransfer(
+    ReadView const& view,
+    MPTIssue const& mptIssue,
+    AccountID const& from,
+    AccountID const& to);
+
+//------------------------------------------------------------------------------
+//
+// Empty holding operations (MPT-specific)
+//
+//------------------------------------------------------------------------------
+
+[[nodiscard]] TER
+addEmptyHolding(
+    ApplyView& view,
+    AccountID const& accountID,
+    XRPAmount priorBalance,
+    MPTIssue const& mptIssue,
+    beast::Journal journal);
+
+[[nodiscard]] TER
+removeEmptyHolding(
+    ApplyView& view,
+    AccountID const& accountID,
+    MPTIssue const& mptIssue,
+    beast::Journal journal);
+
+//------------------------------------------------------------------------------
+//
+// Escrow operations (MPT-specific)
+//
+//------------------------------------------------------------------------------
+
+TER
+rippleLockEscrowMPT(
+    ApplyView& view,
+    AccountID const& uGrantorID,
+    STAmount const& saAmount,
+    beast::Journal j);
+
+TER
+rippleUnlockEscrowMPT(
+    ApplyView& view,
+    AccountID const& uGrantorID,
+    AccountID const& uGranteeID,
+    STAmount const& netAmount,
+    STAmount const& grossAmount,
+    beast::Journal j);
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/OfferHelpers.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/TER.h>
+
+#include <memory>
+
+namespace xrpl {
+
+/** Delete an offer.
+
+    Requirements:
+        The offer must exist.
+        The caller must have already checked permissions.
+
+    @param view The ApplyView to modify.
+    @param sle The offer to delete.
+    @param j Journal for logging.
+
+    @return tesSUCCESS on success, otherwise an error code.
+*/
+// [[nodiscard]] // nodiscard commented out so Flow, BookTip and others compile.
+TER
+offerDelete(ApplyView& view, std::shared_ptr<SLE> const& sle, beast::Journal j);
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/RippleStateHelpers.h

@@ -0,0 +1,255 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/ledger/helpers/TokenHelpers.h>
+#include <xrpl/protocol/IOUAmount.h>
+#include <xrpl/protocol/Issue.h>
+#include <xrpl/protocol/STAmount.h>
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/TER.h>
+
+//------------------------------------------------------------------------------
+//
+// RippleState (Trustline) helpers
+//
+//------------------------------------------------------------------------------
+
+namespace xrpl {
+
+//------------------------------------------------------------------------------
+//
+// Credit functions (from Credit.h)
+//
+//------------------------------------------------------------------------------
+
+/** Calculate the maximum amount of IOUs that an account can hold
+    @param view the ledger to check against.
+    @param account the account of interest.
+    @param issuer the issuer of the IOU.
+    @param currency the IOU to check.
+    @return The maximum amount that can be held.
+*/
+/** @{ */
+STAmount
+creditLimit(
+    ReadView const& view,
+    AccountID const& account,
+    AccountID const& issuer,
+    Currency const& currency);
+
+IOUAmount
+creditLimit2(ReadView const& v, AccountID const& acc, AccountID const& iss, Currency const& cur);
+/** @} */
+
+/** Returns the amount of IOUs issued by issuer that are held by an account
+    @param view the ledger to check against.
+    @param account the account of interest.
+    @param issuer the issuer of the IOU.
+    @param currency the IOU to check.
+*/
+/** @{ */
+STAmount
+creditBalance(
+    ReadView const& view,
+    AccountID const& account,
+    AccountID const& issuer,
+    Currency const& currency);
+/** @} */
+
+//------------------------------------------------------------------------------
+//
+// Freeze checking (IOU-specific)
+//
+//------------------------------------------------------------------------------
+
+[[nodiscard]] bool
+isIndividualFrozen(
+    ReadView const& view,
+    AccountID const& account,
+    Currency const& currency,
+    AccountID const& issuer);
+
+[[nodiscard]] inline bool
+isIndividualFrozen(ReadView const& view, AccountID const& account, Issue const& issue)
+{
+    return isIndividualFrozen(view, account, issue.currency, issue.account);
+}
+
+[[nodiscard]] bool
+isFrozen(
+    ReadView const& view,
+    AccountID const& account,
+    Currency const& currency,
+    AccountID const& issuer);
+
+[[nodiscard]] inline bool
+isFrozen(ReadView const& view, AccountID const& account, Issue const& issue)
+{
+    return isFrozen(view, account, issue.currency, issue.account);
+}
+
+// Overload with depth parameter for uniformity with MPTIssue version.
+// The depth parameter is ignored for IOUs since they don't have vault recursion.
+[[nodiscard]] inline bool
+isFrozen(ReadView const& view, AccountID const& account, Issue const& issue, int /*depth*/)
+{
+    return isFrozen(view, account, issue);
+}
+
+[[nodiscard]] bool
+isDeepFrozen(
+    ReadView const& view,
+    AccountID const& account,
+    Currency const& currency,
+    AccountID const& issuer);
+
+[[nodiscard]] inline bool
+isDeepFrozen(
+    ReadView const& view,
+    AccountID const& account,
+    Issue const& issue,
+    int = 0 /*ignored*/)
+{
+    return isDeepFrozen(view, account, issue.currency, issue.account);
+}
+
+[[nodiscard]] inline TER
+checkDeepFrozen(ReadView const& view, AccountID const& account, Issue const& issue)
+{
+    return isDeepFrozen(view, account, issue) ? (TER)tecFROZEN : (TER)tesSUCCESS;
+}
+
+//------------------------------------------------------------------------------
+//
+// Trust line operations
+//
+//------------------------------------------------------------------------------
+
+/** Create a trust line
+
+    This can set an initial balance.
+*/
+[[nodiscard]] TER
+trustCreate(
+    ApplyView& view,
+    bool const bSrcHigh,
+    AccountID const& uSrcAccountID,
+    AccountID const& uDstAccountID,
+    uint256 const& uIndex,      // --> ripple state entry
+    SLE::ref sleAccount,        // --> the account being set.
+    bool const bAuth,           // --> authorize account.
+    bool const bNoRipple,       // --> others cannot ripple through
+    bool const bFreeze,         // --> funds cannot leave
+    bool bDeepFreeze,           // --> can neither receive nor send funds
+    STAmount const& saBalance,  // --> balance of account being set.
+                                // Issuer should be noAccount()
+    STAmount const& saLimit,    // --> limit for account being set.
+                                // Issuer should be the account being set.
+    std::uint32_t uQualityIn,
+    std::uint32_t uQualityOut,
+    beast::Journal j);
+
+[[nodiscard]] TER
+trustDelete(
+    ApplyView& view,
+    std::shared_ptr<SLE> const& sleRippleState,
+    AccountID const& uLowAccountID,
+    AccountID const& uHighAccountID,
+    beast::Journal j);
+
+//------------------------------------------------------------------------------
+//
+// IOU issuance/redemption
+//
+//------------------------------------------------------------------------------
+
+[[nodiscard]] TER
+issueIOU(
+    ApplyView& view,
+    AccountID const& account,
+    STAmount const& amount,
+    Issue const& issue,
+    beast::Journal j);
+
+[[nodiscard]] TER
+redeemIOU(
+    ApplyView& view,
+    AccountID const& account,
+    STAmount const& amount,
+    Issue const& issue,
+    beast::Journal j);
+
+//------------------------------------------------------------------------------
+//
+// Authorization and transfer checks (IOU-specific)
+//
+//------------------------------------------------------------------------------
+
+/** Check if the account lacks required authorization.
+ *
+ * Return tecNO_AUTH or tecNO_LINE if it does
+ * and tesSUCCESS otherwise.
+ *
+ * If StrongAuth then return tecNO_LINE if the RippleState doesn't exist. Return
+ * tecNO_AUTH if lsfRequireAuth is set on the issuer's AccountRoot, and the
+ * RippleState does exist, and the RippleState is not authorized.
+ *
+ * If WeakAuth then return tecNO_AUTH if lsfRequireAuth is set, and the
+ * RippleState exists, and is not authorized. Return tecNO_LINE if
+ * lsfRequireAuth is set and the RippleState doesn't exist. Consequently, if
+ * WeakAuth and lsfRequireAuth is *not* set, this function will return
+ * tesSUCCESS even if RippleState does *not* exist.
+ *
+ * The default "Legacy" auth type is equivalent to WeakAuth.
+ */
+[[nodiscard]] TER
+requireAuth(
+    ReadView const& view,
+    Issue const& issue,
+    AccountID const& account,
+    AuthType authType = AuthType::Legacy);
+
+/** Check if the destination account is allowed
+ *  to receive IOU. Return terNO_RIPPLE if rippling is
+ *  disabled on both sides and tesSUCCESS otherwise.
+ */
+[[nodiscard]] TER
+canTransfer(ReadView const& view, Issue const& issue, AccountID const& from, AccountID const& to);
+
+//------------------------------------------------------------------------------
+//
+// Empty holding operations (IOU-specific)
+//
+//------------------------------------------------------------------------------
+
+/// Any transactors that call addEmptyHolding() in doApply must call
+/// canAddHolding() in preflight with the same View and Asset
+[[nodiscard]] TER
+addEmptyHolding(
+    ApplyView& view,
+    AccountID const& accountID,
+    XRPAmount priorBalance,
+    Issue const& issue,
+    beast::Journal journal);
+
+[[nodiscard]] TER
+removeEmptyHolding(
+    ApplyView& view,
+    AccountID const& accountID,
+    Issue const& issue,
+    beast::Journal journal);
+
+/** Delete trustline to AMM. The passed `sle` must be obtained from a prior
+ * call to view.peek(). Fail if neither side of the trustline is AMM or
+ * if ammAccountID is seated and is not one of the trustline's side.
+ */
+[[nodiscard]] TER
+deleteAMMTrustLine(
+    ApplyView& view,
+    std::shared_ptr<SLE> sleState,
+    std::optional<AccountID> const& ammAccountID,
+    beast::Journal j);
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/TokenHelpers.h

@@ -0,0 +1,286 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
+#include <xrpl/protocol/Asset.h>
+#include <xrpl/protocol/MPTIssue.h>
+#include <xrpl/protocol/Rate.h>
+#include <xrpl/protocol/STAmount.h>
+#include <xrpl/protocol/TER.h>
+
+#include <initializer_list>
+#include <vector>
+
+namespace xrpl {
+
+//------------------------------------------------------------------------------
+//
+// Enums for token handling
+//
+//------------------------------------------------------------------------------
+
+/** Controls the treatment of frozen account balances */
+enum FreezeHandling { fhIGNORE_FREEZE, fhZERO_IF_FROZEN };
+
+/** Controls the treatment of unauthorized MPT balances */
+enum AuthHandling { ahIGNORE_AUTH, ahZERO_IF_UNAUTHORIZED };
+
+/** Controls whether to include the account's full spendable balance */
+enum SpendableHandling { shSIMPLE_BALANCE, shFULL_BALANCE };
+
+enum class WaiveTransferFee : bool { No = false, Yes };
+
+/* Check if MPToken (for MPT) or trust line (for IOU) exists:
+ * - StrongAuth - before checking if authorization is required
+ * - WeakAuth
+ *    for MPT - after checking lsfMPTRequireAuth flag
+ *    for IOU - do not check if trust line exists
+ * - Legacy
+ *    for MPT - before checking lsfMPTRequireAuth flag i.e. same as StrongAuth
+ *    for IOU - do not check if trust line exists i.e. same as WeakAuth
+ */
+enum class AuthType { StrongAuth, WeakAuth, Legacy };
+
+//------------------------------------------------------------------------------
+//
+// Freeze checking (Asset-based dispatchers)
+//
+//------------------------------------------------------------------------------
+
+[[nodiscard]] bool
+isGlobalFrozen(ReadView const& view, Asset const& asset);
+
+[[nodiscard]] bool
+isIndividualFrozen(ReadView const& view, AccountID const& account, Asset const& asset);
+
+/**
+ *   isFrozen check is recursive for MPT shares in a vault, descending to
+ *   assets in the vault, up to maxAssetCheckDepth recursion depth. This is
+ *   purely defensive, as we currently do not allow such vaults to be created.
+ */
+[[nodiscard]] bool
+isFrozen(ReadView const& view, AccountID const& account, Asset const& asset, int depth = 0);
+
+[[nodiscard]] TER
+checkFrozen(ReadView const& view, AccountID const& account, Issue const& issue);
+
+[[nodiscard]] TER
+checkFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptIssue);
+
+[[nodiscard]] TER
+checkFrozen(ReadView const& view, AccountID const& account, Asset const& asset);
+
+[[nodiscard]] bool
+isAnyFrozen(
+    ReadView const& view,
+    std::initializer_list<AccountID> const& accounts,
+    Issue const& issue);
+
+[[nodiscard]] bool
+isAnyFrozen(
+    ReadView const& view,
+    std::initializer_list<AccountID> const& accounts,
+    Asset const& asset,
+    int depth = 0);
+
+[[nodiscard]] bool
+isDeepFrozen(
+    ReadView const& view,
+    AccountID const& account,
+    MPTIssue const& mptIssue,
+    int depth = 0);
+
+/**
+ *   isFrozen check is recursive for MPT shares in a vault, descending to
+ *   assets in the vault, up to maxAssetCheckDepth recursion depth. This is
+ *   purely defensive, as we currently do not allow such vaults to be created.
+ */
+[[nodiscard]] bool
+isDeepFrozen(ReadView const& view, AccountID const& account, Asset const& asset, int depth = 0);
+
+[[nodiscard]] TER
+checkDeepFrozen(ReadView const& view, AccountID const& account, MPTIssue const& mptIssue);
+
+[[nodiscard]] TER
+checkDeepFrozen(ReadView const& view, AccountID const& account, Asset const& asset);
+
+//------------------------------------------------------------------------------
+//
+// Account balance functions (Asset-based dispatchers)
+//
+//------------------------------------------------------------------------------
+
+// Returns the amount an account can spend.
+//
+// If shSIMPLE_BALANCE is specified, this is the amount the account can spend
+// without going into debt.
+//
+// If shFULL_BALANCE is specified, this is the amount the account can spend
+// total. Specifically:
+// * The account can go into debt if using a trust line, and the other side has
+// a non-zero limit.
+// * If the account is the asset issuer the limit is defined by the asset /
+//   issuance.
+//
+// <-- saAmount: amount of currency held by account. May be negative.
+[[nodiscard]] STAmount
+accountHolds(
+    ReadView const& view,
+    AccountID const& account,
+    Currency const& currency,
+    AccountID const& issuer,
+    FreezeHandling zeroIfFrozen,
+    beast::Journal j,
+    SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
+
+[[nodiscard]] STAmount
+accountHolds(
+    ReadView const& view,
+    AccountID const& account,
+    Issue const& issue,
+    FreezeHandling zeroIfFrozen,
+    beast::Journal j,
+    SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
+
+[[nodiscard]] STAmount
+accountHolds(
+    ReadView const& view,
+    AccountID const& account,
+    MPTIssue const& mptIssue,
+    FreezeHandling zeroIfFrozen,
+    AuthHandling zeroIfUnauthorized,
+    beast::Journal j,
+    SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
+
+[[nodiscard]] STAmount
+accountHolds(
+    ReadView const& view,
+    AccountID const& account,
+    Asset const& asset,
+    FreezeHandling zeroIfFrozen,
+    AuthHandling zeroIfUnauthorized,
+    beast::Journal j,
+    SpendableHandling includeFullBalance = shSIMPLE_BALANCE);
+
+// Returns the amount an account can spend of the currency type saDefault, or
+// returns saDefault if this account is the issuer of the currency in
+// question. Should be used in favor of accountHolds when questioning how much
+// an account can spend while also allowing currency issuers to spend
+// unlimited amounts of their own currency (since they can always issue more).
+[[nodiscard]] STAmount
+accountFunds(
+    ReadView const& view,
+    AccountID const& id,
+    STAmount const& saDefault,
+    FreezeHandling freezeHandling,
+    beast::Journal j);
+
+/** Returns the transfer fee as Rate based on the type of token
+ * @param view The ledger view
+ * @param amount The amount to transfer
+ */
+[[nodiscard]] Rate
+transferRate(ReadView const& view, STAmount const& amount);
+
+//------------------------------------------------------------------------------
+//
+// Holding operations (Asset-based dispatchers)
+//
+//------------------------------------------------------------------------------
+
+[[nodiscard]] TER
+canAddHolding(ReadView const& view, Asset const& asset);
+
+[[nodiscard]] TER
+addEmptyHolding(
+    ApplyView& view,
+    AccountID const& accountID,
+    XRPAmount priorBalance,
+    Asset const& asset,
+    beast::Journal journal);
+
+[[nodiscard]] TER
+removeEmptyHolding(
+    ApplyView& view,
+    AccountID const& accountID,
+    Asset const& asset,
+    beast::Journal journal);
+
+//------------------------------------------------------------------------------
+//
+// Authorization and transfer checks (Asset-based dispatchers)
+//
+//------------------------------------------------------------------------------
+
+[[nodiscard]] TER
+requireAuth(
+    ReadView const& view,
+    Asset const& asset,
+    AccountID const& account,
+    AuthType authType = AuthType::Legacy);
+
+[[nodiscard]] TER
+canTransfer(ReadView const& view, Asset const& asset, AccountID const& from, AccountID const& to);
+
+//------------------------------------------------------------------------------
+//
+// Money Transfers (Asset-based dispatchers)
+//
+//------------------------------------------------------------------------------
+
+// Direct send w/o fees:
+// - Redeeming IOUs and/or sending sender's own IOUs.
+// - Create trust line of needed.
+// --> bCheckIssuer : normally require issuer to be involved.
+// [[nodiscard]] // nodiscard commented out so DirectStep.cpp compiles.
+
+/** Calls static rippleCreditIOU if saAmount represents Issue.
+ * Calls static rippleCreditMPT if saAmount represents MPTIssue.
+ */
+TER
+rippleCredit(
+    ApplyView& view,
+    AccountID const& uSenderID,
+    AccountID const& uReceiverID,
+    STAmount const& saAmount,
+    bool bCheckIssuer,
+    beast::Journal j);
+
+/** Calls static accountSendIOU if saAmount represents Issue.
+ * Calls static accountSendMPT if saAmount represents MPTIssue.
+ */
+[[nodiscard]] TER
+accountSend(
+    ApplyView& view,
+    AccountID const& from,
+    AccountID const& to,
+    STAmount const& saAmount,
+    beast::Journal j,
+    WaiveTransferFee waiveFee = WaiveTransferFee::No);
+
+using MultiplePaymentDestinations = std::vector<std::pair<AccountID, Number>>;
+/** Like accountSend, except one account is sending multiple payments (with the
+ *  same asset!) simultaneously
+ *
+ * Calls static accountSendMultiIOU if saAmount represents Issue.
+ * Calls static accountSendMultiMPT if saAmount represents MPTIssue.
+ */
+[[nodiscard]] TER
+accountSendMulti(
+    ApplyView& view,
+    AccountID const& senderID,
+    Asset const& asset,
+    MultiplePaymentDestinations const& receivers,
+    beast::Journal j,
+    WaiveTransferFee waiveFee = WaiveTransferFee::No);
+
+[[nodiscard]] TER
+transferXRP(
+    ApplyView& view,
+    AccountID const& from,
+    AccountID const& to,
+    STAmount const& amount,
+    beast::Journal j);
+
+}  // namespace xrpl

include/xrpl/ledger/helpers/VaultHelpers.h

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <xrpl/protocol/STAmount.h>
+#include <xrpl/protocol/STLedgerEntry.h>
+
+#include <memory>
+#include <optional>
+
+namespace xrpl {
+
+/** From the perspective of a vault, return the number of shares to give
+    depositor when they offer a fixed amount of assets. Note, since shares are
+    MPT, this number is integral and always truncated in this calculation.
+
+    @param vault The vault SLE.
+    @param issuance The MPTokenIssuance SLE for the vault's shares.
+    @param assets The amount of assets to convert.
+
+    @return The number of shares, or nullopt on error.
+*/
+[[nodiscard]] std::optional<STAmount>
+assetsToSharesDeposit(
+    std::shared_ptr<SLE const> const& vault,
+    std::shared_ptr<SLE const> const& issuance,
+    STAmount const& assets);
+
+/** From the perspective of a vault, return the number of assets to take from
+    depositor when they receive a fixed amount of shares. Note, since shares are
+    MPT, they are always an integral number.
+
+    @param vault The vault SLE.
+    @param issuance The MPTokenIssuance SLE for the vault's shares.
+    @param shares The amount of shares to convert.
+
+    @return The number of assets, or nullopt on error.
+*/
+[[nodiscard]] std::optional<STAmount>
+sharesToAssetsDeposit(
+    std::shared_ptr<SLE const> const& vault,
+    std::shared_ptr<SLE const> const& issuance,
+    STAmount const& shares);
+
+/** Controls whether to truncate shares instead of rounding. */
+enum class TruncateShares : bool { no = false, yes = true };
+
+/** From the perspective of a vault, return the number of shares to demand from
+    the depositor when they ask to withdraw a fixed amount of assets. Since
+    shares are MPT this number is integral, and it will be rounded to nearest
+    unless explicitly requested to be truncated instead.
+
+    @param vault The vault SLE.
+    @param issuance The MPTokenIssuance SLE for the vault's shares.
+    @param assets The amount of assets to convert.
+    @param truncate Whether to truncate instead of rounding.
+
+    @return The number of shares, or nullopt on error.
+*/
+[[nodiscard]] std::optional<STAmount>
+assetsToSharesWithdraw(
+    std::shared_ptr<SLE const> const& vault,
+    std::shared_ptr<SLE const> const& issuance,
+    STAmount const& assets,
+    TruncateShares truncate = TruncateShares::no);
+
+/** From the perspective of a vault, return the number of assets to give the
+    depositor when they redeem a fixed amount of shares. Note, since shares are
+    MPT, they are always an integral number.
+
+    @param vault The vault SLE.
+    @param issuance The MPTokenIssuance SLE for the vault's shares.
+    @param shares The amount of shares to convert.
+
+    @return The number of assets, or nullopt on error.
+*/
+[[nodiscard]] std::optional<STAmount>
+sharesToAssetsWithdraw(
+    std::shared_ptr<SLE const> const& vault,
+    std::shared_ptr<SLE const> const& issuance,
+    STAmount const& shares);
+
+}  // namespace xrpl

include/xrpl/net/HTTPClient.h

@@ -29,6 +29,18 @@ public:
         bool sslVerify,
         beast::Journal j);
 
+    /** Destroys the global SSL context created by initializeSSLContext().
+     *
+     *  This releases the underlying boost::asio::ssl::context and any
+     *  associated OpenSSL resources. Must not be called while any
+     *  HTTPClient requests are in flight.
+     *
+     *  @note Currently only called from tests during teardown. In production,
+     *        the SSL context lives for the lifetime of the process.
+     */
+    static void
+    cleanupSSLContext();
+
     static void
     get(bool bSSL,
         boost::asio::io_context& io_context,

include/xrpl/protocol/Feature.h

@@ -64,6 +64,49 @@
 
 namespace xrpl {
 
+// Feature names must not exceed this length (in characters, excluding the null terminator).
+static constexpr std::size_t maxFeatureNameSize = 63;
+// Reserve this exact feature-name length (in characters/bytes, excluding the null terminator)
+// so that a 32-byte uint256 (for example, in WASM or other interop contexts) can be used
+// as a compact, fixed-size feature selector without conflicting with human-readable names.
+static constexpr std::size_t reservedFeatureNameSize = 32;
+
+// Both validFeatureNameSize and validFeatureName are consteval functions that can be used in
+// static_asserts to validate feature names at compile time. They are only used inside
+// enforceValidFeatureName in Feature.cpp, but are exposed here for testing. The expected
+// parameter `auto fn` is a constexpr lambda which returns a const char*, making it available
+// for compile-time evaluation. Read more in https://accu.org/journals/overload/30/172/wu/
+consteval auto
+validFeatureNameSize(auto fn) -> bool
+{
+    constexpr char const* n = fn();
+    // Note, std::strlen is not constexpr, we need to implement our own here.
+    constexpr std::size_t N = [](auto n) {
+        std::size_t ret = 0;
+        for (auto ptr = n; *ptr != '\0'; ret++, ++ptr)
+            ;
+        return ret;
+    }(n);
+    return N != reservedFeatureNameSize &&  //
+        N <= maxFeatureNameSize;
+}
+
+consteval auto
+validFeatureName(auto fn) -> bool
+{
+    constexpr char const* n = fn();
+    // Prevent the use of visually confusable characters and enforce that feature names
+    // are always valid ASCII. This is needed because C++ allows Unicode identifiers.
+    // Characters below 0x20 are nonprintable control characters, and characters with the 0x80 bit
+    // set are non-ASCII (e.g. UTF-8 encoding of Unicode), so both are disallowed.
+    for (auto ptr = n; *ptr != '\0'; ++ptr)
+    {
+        if (*ptr & 0x80 || *ptr < 0x20)
+            return false;
+    }
+    return true;
+}
+
 enum class VoteBehavior : int { Obsolete = -1, DefaultNo = 0, DefaultYes };
 enum class AmendmentSupport : int { Retired = -1, Supported = 0, Unsupported };
 

include/xrpl/protocol/Fees.h

@@ -4,6 +4,10 @@
 
 namespace xrpl {
 
+// Deprecated constant for backwards compatibility with pre-XRPFees amendment.
+// This was the reference fee units used in the old fee calculation.
+inline constexpr std::uint32_t FEE_UNITS_DEPRECATED = 10;
+
 /** Reflects the fee settings for a particular ledger.
 
     The fees are always the same for any transactions applied
@@ -11,15 +15,25 @@ namespace xrpl {
 */
 struct Fees
 {
-    XRPAmount base{0};       // Reference tx cost (drops)
-    XRPAmount reserve{0};    // Reserve base (drops)
-    XRPAmount increment{0};  // Reserve increment (drops)
+    /** @brief Cost of a reference transaction in drops. */
+    XRPAmount base{0};
+
+    /** @brief Minimum XRP an account must hold to exist on the ledger. */
+    XRPAmount reserve{0};
+
+    /** @brief Additional XRP reserve required per owned ledger object. */
+    XRPAmount increment{0};
 
     explicit Fees() = default;
     Fees(Fees const&) = default;
     Fees&
     operator=(Fees const&) = default;
 
+    Fees(XRPAmount base_, XRPAmount reserve_, XRPAmount increment_)
+        : base(base_), reserve(reserve_), increment(increment_)
+    {
+    }
+
     /** Returns the account reserve given the owner count, in drops.
 
         The reserve is calculated as the reserve base plus

include/xrpl/protocol/LedgerHeader.h

@@ -72,4 +72,8 @@ deserializeHeader(Slice data, bool hasHash = false);
 LedgerHeader
 deserializePrefixedHeader(Slice data, bool hasHash = false);
 
+/** Calculate the hash of a ledger header. */
+uint256
+calculateLedgerHash(LedgerHeader const& info);
+
 }  // namespace xrpl

include/xrpl/protocol/Permissions.h

@@ -65,19 +65,19 @@ public:
     std::optional<TxType>
     getGranularTxType(GranularPermissionType const& gpType) const;
 
-    std::optional<std::reference_wrapper<uint256 const>> const
+    std::optional<std::reference_wrapper<uint256 const>>
     getTxFeature(TxType txType) const;
 
     bool
     isDelegable(std::uint32_t const& permissionValue, Rules const& rules) const;
 
     // for tx level permission, permission value is equal to tx type plus one
-    uint32_t
-    txToPermissionType(TxType const& type) const;
+    static uint32_t
+    txToPermissionType(TxType const& type);
 
     // tx type value is permission value minus one
-    TxType
-    permissionToTxType(uint32_t const& value) const;
+    static TxType
+    permissionToTxType(uint32_t const& value);
 };
 
 }  // namespace xrpl

include/xrpl/protocol/Protocol.h

@@ -209,7 +209,7 @@ std::size_t constexpr maxDIDDocumentLength = 256;
 std::size_t constexpr maxDIDURILength = 256;
 
 /** The maximum length of an Attestation inside a DID */
-std::size_t constexpr maxDIDAttestationLength = 256;
+std::size_t constexpr maxDIDDataLength = 256;
 
 /** The maximum length of a domain */
 std::size_t constexpr maxDomainLength = 256;

include/xrpl/protocol/PublicKey.h

@@ -44,7 +44,7 @@ protected:
     // All the constructed public keys are valid, non-empty and contain 33
     // bytes of data.
     static constexpr std::size_t size_ = 33;
-    std::uint8_t buf_[size_];  // should be large enough
+    std::uint8_t buf_[size_]{};  // should be large enough
 
 public:
     using const_iterator = std::uint8_t const*;

include/xrpl/protocol/STAccount.h

@@ -24,7 +24,7 @@ public:
     STAccount();
 
     STAccount(SField const& n);
-    STAccount(SField const& n, Buffer&& v);
+    STAccount(SField const& n, Buffer const& v);
     STAccount(SerialIter& sit, SField const& name);
     STAccount(SField const& n, AccountID const& v);
 

include/xrpl/protocol/STObject.h

@@ -57,7 +57,7 @@ class STObject : public STBase, public CountedObject<STObject>
     using list_type = std::vector<detail::STVar>;
 
     list_type v_;
-    SOTemplate const* mType;
+    SOTemplate const* mType{};
 
 public:
     using iterator = boost::transform_iterator<Transform, STObject::list_type::const_iterator>;
@@ -401,7 +401,7 @@ public:
     getStyle(SField const& field) const;
 
     bool
-    hasMatchingEntry(STBase const&);
+    hasMatchingEntry(STBase const&) const;
 
     bool
     operator==(STObject const& o) const;

include/xrpl/protocol/STTx.h

@@ -15,7 +15,7 @@
 
 namespace xrpl {
 
-enum TxnSql : char {
+enum class TxnSql : char {
     txnSqlNew = 'N',
     txnSqlConflict = 'C',
     txnSqlHeld = 'H',
@@ -83,6 +83,9 @@ public:
     std::uint32_t
     getSeqValue() const;
 
+    AccountID
+    getFeePayer() const;
+
     boost::container::flat_set<AccountID>
     getMentionedAccounts() const;
 
@@ -122,7 +125,7 @@ public:
     getMetaSQL(
         Serializer rawTxn,
         std::uint32_t inLedger,
-        char status,
+        TxnSql status,
         std::string const& escapedMetaData) const;
 
     std::vector<uint256> const&

include/xrpl/protocol/STVector256.h

@@ -69,9 +69,6 @@ public:
     std::vector<uint256>::iterator
     insert(std::vector<uint256>::const_iterator pos, uint256 const& value);
 
-    std::vector<uint256>::iterator
-    insert(std::vector<uint256>::const_iterator pos, uint256&& value);
-
     void
     push_back(uint256 const& v);
 
@@ -184,12 +181,6 @@ STVector256::insert(std::vector<uint256>::const_iterator pos, uint256 const& val
     return mValue.insert(pos, value);
 }
 
-inline std::vector<uint256>::iterator
-STVector256::insert(std::vector<uint256>::const_iterator pos, uint256&& value)
-{
-    return mValue.insert(pos, std::move(value));
-}
-
 inline void
 STVector256::push_back(uint256 const& v)
 {

include/xrpl/protocol/SecretKey.h

@@ -16,8 +16,11 @@ namespace xrpl {
 /** A secret key. */
 class SecretKey
 {
+public:
+    static constexpr std::size_t size_ = 32;
+
 private:
-    std::uint8_t buf_[32];
+    std::uint8_t buf_[size_]{};
 
 public:
     using const_iterator = std::uint8_t const*;
@@ -27,9 +30,14 @@ public:
     SecretKey&
     operator=(SecretKey const&) = default;
 
+    bool
+    operator==(SecretKey const&) = delete;
+    bool
+    operator!=(SecretKey const&) = delete;
+
     ~SecretKey();
 
-    SecretKey(std::array<std::uint8_t, 32> const& data);
+    SecretKey(std::array<std::uint8_t, size_> const& data);
     SecretKey(Slice const& slice);
 
     std::uint8_t const*
@@ -78,16 +86,10 @@ public:
 };
 
 inline bool
-operator==(SecretKey const& lhs, SecretKey const& rhs)
-{
-    return lhs.size() == rhs.size() && std::memcmp(lhs.data(), rhs.data(), rhs.size()) == 0;
-}
+operator==(SecretKey const& lhs, SecretKey const& rhs) = delete;
 
 inline bool
-operator!=(SecretKey const& lhs, SecretKey const& rhs)
-{
-    return !(lhs == rhs);
-}
+operator!=(SecretKey const& lhs, SecretKey const& rhs) = delete;
 
 //------------------------------------------------------------------------------
 

include/xrpl/protocol/Seed.h

@@ -13,7 +13,7 @@ namespace xrpl {
 class Seed
 {
 private:
-    std::array<uint8_t, 16> buf_;
+    std::array<uint8_t, 16> buf_{};
 
 public:
     using const_iterator = std::array<uint8_t, 16>::const_iterator;

include/xrpl/protocol/Serializer.h

@@ -336,7 +336,7 @@ public:
         static_assert(N > 0, "");
     }
 
-    std::size_t
+    [[nodiscard]] bool
     empty() const noexcept
     {
         return remain_ == 0;

include/xrpl/protocol/SystemParameters.h

@@ -14,7 +14,7 @@ namespace xrpl {
 static inline std::string const&
 systemName()
 {
-    static std::string const name = "ripple";
+    static std::string const name = "xrpld";
     return name;
 }
 

include/xrpl/protocol/TxSearched.h

@@ -2,6 +2,6 @@
 
 namespace xrpl {
 
-enum class TxSearched { all, some, unknown };
+enum class TxSearched { All, Some, Unknown };
 
 }

include/xrpl/protocol/detail/STVar.h

@@ -44,7 +44,7 @@ private:
     // The largest "small object" we can accommodate
     static std::size_t constexpr max_size = 72;
 
-    std::aligned_storage<max_size>::type d_;
+    std::aligned_storage<max_size>::type d_ = {};
     STBase* p_ = nullptr;
 
 public:

include/xrpl/protocol/detail/features.macro

@@ -16,6 +16,7 @@
 // Add new amendments to the top of this list.
 // Keep it sorted in reverse chronological order.
 
+XRPL_FIX   (Security3_1_3,               Supported::no, VoteBehavior::DefaultNo)
 XRPL_FIX   (PermissionedDomainInvariant, Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (ExpiredNFTokenOfferRemoval, Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (BatchInnerSigs,             Supported::no, VoteBehavior::DefaultNo)

include/xrpl/protocol/detail/transactions.macro

@@ -76,7 +76,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/account/AccountSet.h>
 #endif
 TRANSACTION(ttACCOUNT_SET, 3, AccountSet,
     Delegation::notDelegable,
@@ -124,7 +124,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/dex/OfferCreate.h>
 #endif
 TRANSACTION(ttOFFER_CREATE, 7, OfferCreate,
     Delegation::delegable,
@@ -140,7 +140,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/dex/OfferCancel.h>
 #endif
 TRANSACTION(ttOFFER_CANCEL, 8, OfferCancel,
     Delegation::delegable,
@@ -154,7 +154,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/system/TicketCreate.h>
 #endif
 TRANSACTION(ttTICKET_CREATE, 10, TicketCreate,
     Delegation::delegable,
@@ -170,7 +170,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/account/SignerListSet.h>
 #endif
 TRANSACTION(ttSIGNER_LIST_SET, 12, SignerListSet,
     Delegation::notDelegable,
@@ -183,7 +183,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/PayChanCreate.h>
+#   include <xrpl/tx/transactors/payment_channel/PaymentChannelCreate.h>
 #endif
 TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate,
     Delegation::delegable,
@@ -200,7 +200,7 @@ TRANSACTION(ttPAYCHAN_CREATE, 13, PaymentChannelCreate,
 
 /** This transaction type funds an existing unidirectional XRP payment channel. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/payment_channel/PayChanFund.h>
+#   include <xrpl/tx/transactors/payment_channel/PaymentChannelFund.h>
 #endif
 TRANSACTION(ttPAYCHAN_FUND, 14, PaymentChannelFund,
     Delegation::delegable,
@@ -214,7 +214,7 @@ TRANSACTION(ttPAYCHAN_FUND, 14, PaymentChannelFund,
 
 /** This transaction type submits a claim against an existing unidirectional payment channel. */
 #if TRANSACTION_INCLUDE
-#   include <xrpl/tx/transactors/payment_channel/PayChanClaim.h>
+#   include <xrpl/tx/transactors/payment_channel/PaymentChannelClaim.h>
 #endif
 TRANSACTION(ttPAYCHAN_CLAIM, 15, PaymentChannelClaim,
     Delegation::delegable,
@@ -231,7 +231,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/CheckCreate.h>
 #endif
 TRANSACTION(ttCHECK_CREATE, 16, CheckCreate,
     Delegation::delegable,
@@ -247,7 +247,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/CheckCash.h>
 #endif
 TRANSACTION(ttCHECK_CASH, 17, CheckCash,
     Delegation::delegable,
@@ -261,7 +261,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/CheckCancel.h>
 #endif
 TRANSACTION(ttCHECK_CANCEL, 18, CheckCancel,
     Delegation::delegable,
@@ -288,7 +288,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/token/TrustSet.h>
 #endif
 TRANSACTION(ttTRUST_SET, 20, TrustSet,
     Delegation::delegable,
@@ -302,7 +302,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/account/AccountDelete.h>
 #endif
 TRANSACTION(ttACCOUNT_DELETE, 21, AccountDelete,
     Delegation::notDelegable,
@@ -650,7 +650,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/oracle/OracleSet.h>
 #endif
 TRANSACTION(ttORACLE_SET, 51, OracleSet,
     Delegation::delegable,
@@ -667,7 +667,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/oracle/OracleDelete.h>
 #endif
 TRANSACTION(ttORACLE_DELETE, 52, OracleDelete,
     Delegation::delegable,

include/xrpl/protocol/digest.h

@@ -40,7 +40,7 @@ public:
     operator result_type() noexcept;
 
 private:
-    char ctx_[96];
+    char ctx_[96]{};
 };
 
 /** SHA-512 digest
@@ -63,7 +63,7 @@ public:
     operator result_type() noexcept;
 
 private:
-    char ctx_[216];
+    char ctx_[216]{};
 };
 
 /** SHA-256 digest
@@ -86,7 +86,7 @@ public:
     operator result_type() noexcept;
 
 private:
-    char ctx_[112];
+    char ctx_[112]{};
 };
 
 //------------------------------------------------------------------------------

include/xrpl/protocol/jss.h

@@ -112,6 +112,7 @@ JSS(accounts);                // in: LedgerEntry, Subscribe,
                               //     handlers/Ledger, Unsubscribe
 JSS(accounts_proposed);       // in: Subscribe, Unsubscribe
 JSS(action);
+JSS(active);                  // out: OverlayImpl
 JSS(acquiring);               // out: LedgerRequest
 JSS(address);                 // out: PeerImp
 JSS(affected);                // out: AcceptedLedgerTx
@@ -300,6 +301,7 @@ JSS(id);                      // websocket.
 JSS(ident);                   // in: AccountCurrencies, AccountInfo,
                               //     OwnerInfo
 JSS(ignore_default);          // in: AccountLines
+JSS(in);                      // out: OverlayImpl
 JSS(inLedger);                // out: tx/Transaction
 JSS(inbound);                 // out: PeerImp
 JSS(index);                   // in: LedgerEntry
@@ -464,6 +466,7 @@ 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(out);                     // out: OverlayImpl
 JSS(owner);                   // in: LedgerEntry, out: NetworkOPs
 JSS(owner_funds);             // in/out: Ledger, NetworkOPs, AcceptedLedgerTx
 JSS(page_index);

include/xrpl/protocol_autogen/LedgerEntryBase.h

@@ -0,0 +1,152 @@
+#pragma once
+
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol_autogen/STObjectValidation.h>
+#include <xrpl/protocol_autogen/Utils.h>
+
+#include <optional>
+#include <string>
+
+namespace xrpl::ledger_entries {
+
+/**
+ * @brief Base class for type-safe ledger entry wrappers.
+ *
+ * This class provides common functionality for all ledger entry types,
+ * including access to common fields (sfLedgerIndex, sfLedgerEntryType, sfFlags).
+ *
+ * This is an immutable wrapper around SLE (Serialized Ledger Entry).
+ * Use the corresponding Builder classes to construct new ledger entries.
+ */
+class LedgerEntryBase
+{
+public:
+    /**
+     * @brief Construct a ledger entry wrapper from an existing SLE object.
+     * @param sle The underlying serialized ledger entry to wrap
+     */
+    explicit LedgerEntryBase(std::shared_ptr<SLE const> sle) : sle_(std::move(sle))
+    {
+    }
+
+    /**
+     * @brief Validate the ledger entry
+     * @return true if validation passes, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    validate() const
+    {
+        if (!sle_->isFieldPresent(sfLedgerEntryType))
+        {
+            return false;  // LCOV_EXCL_LINE
+        }
+        auto ledgerEntryType = static_cast<LedgerEntryType>(sle_->getFieldU16(sfLedgerEntryType));
+        return protocol_autogen::validateSTObject(
+            *sle_, LedgerFormats::getInstance().findByType(ledgerEntryType)->getSOTemplate());
+    }
+
+    /**
+     * @brief Get the ledger entry type.
+     * @return The type of this ledger entry
+     */
+    [[nodiscard]]
+    LedgerEntryType
+    getType() const
+    {
+        return sle_->getType();
+    }
+
+    /**
+     * @brief Get the key (index) of this ledger entry.
+     *
+     * The key uniquely identifies this ledger entry in the ledger state.
+     * @return A constant reference to the 256-bit key
+     */
+    [[nodiscard]]
+    uint256 const&
+    getKey() const
+    {
+        return sle_->key();
+    }
+
+    // Common field getters (from LedgerFormats.cpp commonFields)
+
+    /**
+     * @brief Get the ledger index (sfLedgerIndex).
+     *
+     * This field is OPTIONAL and represents the index of the ledger entry.
+     * @return The ledger index if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<uint256>
+    getLedgerIndex() const
+    {
+        if (sle_->isFieldPresent(sfLedgerIndex))
+        {
+            return sle_->at(sfLedgerIndex);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the ledger entry has a ledger index.
+     * @return true if sfLedgerIndex is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasLedgerIndex() const
+    {
+        return sle_->isFieldPresent(sfLedgerIndex);
+    }
+
+    /**
+     * @brief Get the ledger entry type field (sfLedgerEntryType).
+     *
+     * This field is REQUIRED for all ledger entries and indicates the type
+     * of the ledger entry (e.g., AccountRoot, RippleState, Offer, etc.).
+     * @return The ledger entry type as a 16-bit unsigned integer
+     */
+    [[nodiscard]]
+    uint16_t
+    getLedgerEntryType() const
+    {
+        return sle_->at(sfLedgerEntryType);
+    }
+
+    /**
+     * @brief Get the flags field (sfFlags).
+     *
+     * This field is REQUIRED for all ledger entries and contains
+     * type-specific flags that modify the behavior of the ledger entry.
+     * @return The flags value as a 32-bit unsigned integer
+     */
+    [[nodiscard]]
+    std::uint32_t
+    getFlags() const
+    {
+        return sle_->at(sfFlags);
+    }
+
+    /**
+     * @brief Get the underlying SLE object.
+     *
+     * Provides direct access to the wrapped serialized ledger entry object
+     * for cases where the type-safe accessors are insufficient.
+     * @return A constant reference to the underlying SLE object
+     */
+    [[nodiscard]]
+    std::shared_ptr<SLE const>
+    getSle() const
+    {
+        return sle_;
+    }
+
+protected:
+    /** @brief The underlying serialized ledger entry being wrapped. */
+    std::shared_ptr<SLE const> sle_;
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/LedgerEntryBuilderBase.h

@@ -0,0 +1,84 @@
+#pragma once
+
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STAccount.h>
+#include <xrpl/protocol/STAmount.h>
+#include <xrpl/protocol/STBlob.h>
+#include <xrpl/protocol/STInteger.h>
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STObject.h>
+#include <xrpl/protocol_autogen/STObjectValidation.h>
+
+namespace xrpl::ledger_entries {
+
+/**
+ * Base class for all ledger entry builders.
+ * Provides common field setters that are available for all ledger entry types.
+ */
+template <typename Derived>
+class LedgerEntryBuilderBase
+{
+public:
+    LedgerEntryBuilderBase() = default;
+
+    LedgerEntryBuilderBase(
+        SF_UINT16::type::value_type ledgerEntryType,
+        SF_UINT32::type::value_type flags = 0)
+    {
+        // Don't call object_.set(soTemplate) - keep object_ as a free object.
+        // This avoids creating STBase placeholders for soeDEFAULT fields,
+        // which would cause applyTemplate() to throw "may not be explicitly
+        // set to default" when building the SLE.
+        // The SLE constructor will call applyTemplate() which properly
+        // handles missing fields.
+        object_[sfLedgerEntryType] = ledgerEntryType;
+        object_[sfFlags] = flags;
+    }
+
+    /**
+     * @brief Validate the ledger entry
+     * @return true if validation passes, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    validate() const
+    {
+        if (!object_.isFieldPresent(sfLedgerEntryType))
+        {
+            return false;  // LCOV_EXCL_LINE
+        }
+        auto ledgerEntryType = static_cast<LedgerEntryType>(object_.getFieldU16(sfLedgerEntryType));
+        return protocol_autogen::validateSTObject(
+            object_, LedgerFormats::getInstance().findByType(ledgerEntryType)->getSOTemplate());
+    }
+
+    /**
+     * Set the ledger index.
+     * @param value Ledger index
+     * @return Reference to the derived builder for method chaining.
+     */
+    Derived&
+    setLedgerIndex(uint256 const& value)
+    {
+        object_[sfLedgerIndex] = value;
+        return static_cast<Derived&>(*this);
+    }
+
+    /**
+     * Set the flags.
+     * @param value Flags value
+     * @return Reference to the derived builder for method chaining.
+     */
+    Derived&
+    setFlags(uint32_t value)
+    {
+        object_.setFieldU32(sfFlags, value);
+        return static_cast<Derived&>(*this);
+    }
+
+protected:
+    STObject object_{sfLedgerEntry};
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/README.md

@@ -0,0 +1,79 @@
+# Protocol Autogen
+
+This directory contains auto-generated C++ wrapper classes for XRP Ledger protocol types.
+
+## Generated Files
+
+The files in this directory are automatically generated at **CMake configure time** from macro definition files:
+
+- **Transaction classes** (in `transactions/`): Generated from `include/xrpl/protocol/detail/transactions.macro` by `scripts/generate_tx_classes.py`
+- **Ledger entry classes** (in `ledger_entries/`): Generated from `include/xrpl/protocol/detail/ledger_entries.macro` by `scripts/generate_ledger_classes.py`
+
+## Generation Process
+
+The generation happens automatically when you **configure** the project (not during build). When you run CMake, the system:
+
+1. Creates a Python virtual environment in the build directory (`codegen_venv`)
+2. Installs Python dependencies from `scripts/requirements.txt` into the venv (only if needed)
+3. Runs the Python generation scripts using the venv Python interpreter
+4. Parses the macro files to extract type definitions
+5. Generates type-safe C++ wrapper classes using Mako templates
+6. Places the generated headers in this directory
+
+### When Regeneration Happens
+
+The code is regenerated when:
+
+- You run CMake configure for the first time
+- The Python virtual environment doesn't exist
+- `scripts/requirements.txt` has been modified
+
+To force regeneration, delete the build directory and reconfigure.
+
+### Python Dependencies
+
+The code generation requires the following Python packages (automatically installed):
+
+- `pcpp` - C preprocessor for Python
+- `pyparsing` - Parser combinator library
+- `Mako` - Template engine
+
+These are isolated in a virtual environment and won't affect your system Python installation.
+
+## Version Control
+
+The generated `.h` files **are checked into version control**. This means:
+
+- Developers without Python 3 can still build the project using the committed files
+- CI/CD systems don't need to run code generation if files are up to date
+- Changes to generated files are visible in code review
+
+## Modifying Generated Code
+
+**Do not manually edit generated files.** Any changes will be overwritten the next time CMake configure runs.
+
+To modify the generated classes:
+
+- Edit the macro files in `include/xrpl/protocol/detail/`
+- Edit the Mako templates in `scripts/templates/`
+- Edit the generation scripts in `scripts/`
+- Update Python dependencies in `scripts/requirements.txt`
+- Run CMake configure to regenerate
+
+## Adding Common Fields
+
+If you add a new common field to `TxFormats.cpp` or `LedgerFormats.cpp`, you should also update the corresponding base classes and templates manually:
+
+Base classes:
+
+- `TransactionBase.h` - Add getters for new common transaction fields
+- `TransactionBuilderBase.h` - Add setters, and if the field is required, add it to the constructor parameters
+- `LedgerEntryBase.h` - Add getters for new common ledger entry fields
+- `LedgerEntryBuilderBase.h` - Add setters, and if the field is required, add it to the constructor parameters
+
+Templates (update to pass required common fields to base class constructors):
+
+- `scripts/templates/Transaction.h.mako`
+- `scripts/templates/LedgerEntry.h.mako`
+
+These files are **not auto-generated** and must be updated by hand.

include/xrpl/protocol_autogen/STObjectValidation.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <xrpl/protocol/SOTemplate.h>
+#include <xrpl/protocol/STObject.h>
+
+namespace xrpl::protocol_autogen {
+
+[[nodiscard]]
+inline bool
+validateSTObject(STObject const& obj, SOTemplate const& format)
+{
+    for (auto const& field : format)
+    {
+        if (!obj.isFieldPresent(field.sField()) && field.style() == soeREQUIRED)
+        {
+            return false;  // LCOV_EXCL_LINE
+        }
+
+        if (field.supportMPT() == soeMPTNotSupported && obj.isFieldPresent(field.sField()))
+        {
+            if (field.sField().fieldType == STI_AMOUNT)
+            {
+                auto const& amount = obj.getFieldAmount(field.sField());
+
+                if (amount.asset().holds<MPTIssue>())
+                    return false;  // LCOV_EXCL_LINE
+            }
+            else if (field.sField().fieldType == STI_ISSUE)
+            {
+                auto issue = dynamic_cast<STIssue const*>(obj.peekAtPField(field.sField()));
+                if (!issue)
+                    return false;  // LCOV_EXCL_LINE
+
+                if (issue->holds<MPTIssue>())
+                    return false;  // LCOV_EXCL_LINE
+            }
+        }
+    }
+
+    return true;
+}
+
+}  // namespace xrpl::protocol_autogen

include/xrpl/protocol_autogen/TransactionBase.h

@@ -0,0 +1,457 @@
+#pragma once
+
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STAccount.h>
+#include <xrpl/protocol/STArray.h>
+#include <xrpl/protocol/STObject.h>
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/TxFormats.h>
+#include <xrpl/protocol_autogen/STObjectValidation.h>
+#include <xrpl/protocol_autogen/Utils.h>
+
+#include <optional>
+#include <string>
+
+namespace xrpl::transactions {
+
+/**
+ * @brief Base class for all transaction wrapper types.
+ *
+ * Provides type-safe read-only accessors for common transaction fields.
+ * This is an immutable wrapper around STTx. Use the corresponding Builder classes
+ * to construct new transactions.
+ */
+class TransactionBase
+{
+public:
+    /**
+     * @brief Construct a transaction wrapper from an existing STTx object.
+     * @param tx The underlying transaction object to wrap
+     */
+    explicit TransactionBase(std::shared_ptr<STTx const> tx) : tx_(std::move(tx))
+    {
+    }
+
+    /**
+     * @brief Validate the transaction
+     * @return true if validation passes, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    validate(std::string& reason) const
+    {
+        if (!protocol_autogen::validateSTObject(
+                *tx_, TxFormats::getInstance().findByType(tx_->getTxnType())->getSOTemplate()))
+        {
+            // LCOV_EXCL_START
+            reason = "Transaction failed schema validation";
+            return false;
+            // LCOV_EXCL_STOP
+        }
+
+        // Pseudo transactions are not submitted to the network
+        if (isPseudoTx(*tx_))
+        {
+            return true;
+        }
+        return passesLocalChecks(*tx_, reason);
+    }
+
+    /**
+     * @brief Get the transaction type.
+     * @return The type of this transaction
+     */
+    [[nodiscard]]
+    xrpl::TxType
+    getTransactionType() const
+    {
+        return tx_->getTxnType();
+    }
+
+    /**
+     * @brief Get the account initiating the transaction (sfAccount).
+     *
+     * This field is REQUIRED for all transactions.
+     * @return The account ID of the transaction sender
+     */
+    [[nodiscard]]
+    AccountID
+    getAccount() const
+    {
+        return tx_->at(sfAccount);
+    }
+
+    /**
+     * @brief Get the sequence number of the transaction (sfSequence).
+     *
+     * This field is REQUIRED for all transactions.
+     * @return The sequence number
+     */
+    [[nodiscard]]
+    std::uint32_t
+    getSequence() const
+    {
+        return tx_->at(sfSequence);
+    }
+
+    /**
+     * @brief Get the transaction fee (sfFee).
+     *
+     * This field is REQUIRED for all transactions.
+     * @return The fee amount
+     */
+    [[nodiscard]]
+    STAmount
+    getFee() const
+    {
+        return tx_->at(sfFee);
+    }
+
+    /**
+     * @brief Get the signing public key (sfSigningPubKey).
+     *
+     * This field is REQUIRED for all transactions.
+     * @return The public key used for signing as a blob
+     */
+    [[nodiscard]]
+    Blob
+    getSigningPubKey() const
+    {
+        return tx_->getFieldVL(sfSigningPubKey);
+    }
+
+    /**
+     * @brief Get the transaction flags (sfFlags).
+     *
+     * This field is OPTIONAL.
+     * @return The flags value if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<uint32_t>
+    getFlags() const
+    {
+        if (tx_->isFieldPresent(sfFlags))
+            return tx_->at(sfFlags);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has flags set.
+     * @return true if sfFlags is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasFlags() const
+    {
+        return tx_->isFieldPresent(sfFlags);
+    }
+
+    /**
+     * @brief Get the source tag (sfSourceTag).
+     *
+     * This field is OPTIONAL and used to identify the source of a payment.
+     * @return The source tag value if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<uint32_t>
+    getSourceTag() const
+    {
+        if (tx_->isFieldPresent(sfSourceTag))
+            return tx_->at(sfSourceTag);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has a source tag.
+     * @return true if sfSourceTag is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasSourceTag() const
+    {
+        return tx_->isFieldPresent(sfSourceTag);
+    }
+
+    /**
+     * @brief Get the previous transaction ID (sfPreviousTxnID).
+     *
+     * This field is OPTIONAL and used for transaction chaining.
+     * @return The previous transaction ID if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<uint256>
+    getPreviousTxnID() const
+    {
+        if (tx_->isFieldPresent(sfPreviousTxnID))
+            return tx_->at(sfPreviousTxnID);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has a previous transaction ID.
+     * @return true if sfPreviousTxnID is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasPreviousTxnID() const
+    {
+        return tx_->isFieldPresent(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get the last ledger sequence (sfLastLedgerSequence).
+     *
+     * This field is OPTIONAL and specifies the latest ledger sequence
+     * in which this transaction can be included.
+     * @return The last ledger sequence if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<uint32_t>
+    getLastLedgerSequence() const
+    {
+        if (tx_->isFieldPresent(sfLastLedgerSequence))
+            return tx_->at(sfLastLedgerSequence);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has a last ledger sequence.
+     * @return true if sfLastLedgerSequence is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasLastLedgerSequence() const
+    {
+        return tx_->isFieldPresent(sfLastLedgerSequence);
+    }
+
+    /**
+     * @brief Get the account transaction ID (sfAccountTxnID).
+     *
+     * This field is OPTIONAL and used to track transaction sequences.
+     * @return The account transaction ID if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<uint256>
+    getAccountTxnID() const
+    {
+        if (tx_->isFieldPresent(sfAccountTxnID))
+            return tx_->at(sfAccountTxnID);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has an account transaction ID.
+     * @return true if sfAccountTxnID is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasAccountTxnID() const
+    {
+        return tx_->isFieldPresent(sfAccountTxnID);
+    }
+
+    /**
+     * @brief Get the operation limit (sfOperationLimit).
+     *
+     * This field is OPTIONAL and limits the number of operations in a transaction.
+     * @return The operation limit if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<uint32_t>
+    getOperationLimit() const
+    {
+        if (tx_->isFieldPresent(sfOperationLimit))
+            return tx_->at(sfOperationLimit);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has an operation limit.
+     * @return true if sfOperationLimit is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasOperationLimit() const
+    {
+        return tx_->isFieldPresent(sfOperationLimit);
+    }
+
+    /**
+     * @brief Get the memos array (sfMemos).
+     *
+     * This field is OPTIONAL and contains arbitrary data attached to the transaction.
+     * @note This is an untyped field (STArray).
+     * @return A reference wrapper to the memos array if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<std::reference_wrapper<STArray const>>
+    getMemos() const
+    {
+        if (tx_->isFieldPresent(sfMemos))
+            return tx_->getFieldArray(sfMemos);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has memos.
+     * @return true if sfMemos is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasMemos() const
+    {
+        return tx_->isFieldPresent(sfMemos);
+    }
+
+    /**
+     * @brief Get the ticket sequence (sfTicketSequence).
+     *
+     * This field is OPTIONAL and used when consuming a ticket instead of a sequence number.
+     * @return The ticket sequence if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<uint32_t>
+    getTicketSequence() const
+    {
+        if (tx_->isFieldPresent(sfTicketSequence))
+            return tx_->at(sfTicketSequence);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has a ticket sequence.
+     * @return true if sfTicketSequence is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasTicketSequence() const
+    {
+        return tx_->isFieldPresent(sfTicketSequence);
+    }
+
+    /**
+     * @brief Get the transaction signature (sfTxnSignature).
+     *
+     * This field is OPTIONAL and contains the signature for single-signed transactions.
+     * @return The transaction signature as a blob if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<Blob>
+    getTxnSignature() const
+    {
+        if (tx_->isFieldPresent(sfTxnSignature))
+            return tx_->getFieldVL(sfTxnSignature);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has a transaction signature.
+     * @return true if sfTxnSignature is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasTxnSignature() const
+    {
+        return tx_->isFieldPresent(sfTxnSignature);
+    }
+
+    /**
+     * @brief Get the signers array (sfSigners).
+     *
+     * This field is OPTIONAL and contains the list of signers for multi-signed transactions.
+     * @note This is an untyped field (STArray).
+     * @return A reference wrapper to the signers array if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<std::reference_wrapper<STArray const>>
+    getSigners() const
+    {
+        if (tx_->isFieldPresent(sfSigners))
+            return tx_->getFieldArray(sfSigners);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has signers.
+     * @return true if sfSigners is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasSigners() const
+    {
+        return tx_->isFieldPresent(sfSigners);
+    }
+
+    /**
+     * @brief Get the network ID (sfNetworkID).
+     *
+     * This field is OPTIONAL and identifies the network this transaction is intended for.
+     * @return The network ID if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<uint32_t>
+    getNetworkID() const
+    {
+        if (tx_->isFieldPresent(sfNetworkID))
+            return tx_->at(sfNetworkID);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has a network ID.
+     * @return true if sfNetworkID is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasNetworkID() const
+    {
+        return tx_->isFieldPresent(sfNetworkID);
+    }
+
+    /**
+     * @brief Get the delegate account (sfDelegate).
+     *
+     * This field is OPTIONAL and specifies a delegate account for the transaction.
+     * @return The delegate account ID if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<AccountID>
+    getDelegate() const
+    {
+        if (tx_->isFieldPresent(sfDelegate))
+            return tx_->at(sfDelegate);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has a delegate account.
+     * @return true if sfDelegate is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasDelegate() const
+    {
+        return tx_->isFieldPresent(sfDelegate);
+    }
+
+    /**
+     * @brief Get the underlying STTx object.
+     *
+     * Provides direct access to the wrapped transaction object for cases
+     * where the type-safe accessors are insufficient.
+     * @return A constant reference to the underlying STTx object
+     */
+    [[nodiscard]]
+    std::shared_ptr<STTx const>
+    getSTTx() const
+    {
+        return tx_;
+    }
+
+protected:
+    /** @brief The underlying transaction object being wrapped. */
+    std::shared_ptr<STTx const> tx_;
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/TransactionBuilderBase.h

@@ -0,0 +1,269 @@
+#pragma once
+
+#include <xrpl/protocol/HashPrefix.h>
+#include <xrpl/protocol/PublicKey.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STAccount.h>
+#include <xrpl/protocol/STAmount.h>
+#include <xrpl/protocol/STArray.h>
+#include <xrpl/protocol/STBlob.h>
+#include <xrpl/protocol/STInteger.h>
+#include <xrpl/protocol/STObject.h>
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STXChainBridge.h>
+#include <xrpl/protocol/SecretKey.h>
+#include <xrpl/protocol/Serializer.h>
+#include <xrpl/protocol/TxFormats.h>
+#include <xrpl/protocol/jss.h>
+
+namespace xrpl::transactions {
+
+/**
+ * Base class for all transaction builders.
+ * Provides common field setters that are available for all transaction types.
+ */
+template <typename Derived>
+class TransactionBuilderBase
+{
+public:
+    TransactionBuilderBase() = default;
+
+    TransactionBuilderBase(
+        SF_UINT16::type::value_type transactionType,
+        SF_ACCOUNT::type::value_type account,
+        std::optional<SF_UINT32::type::value_type> sequence,
+        std::optional<SF_AMOUNT::type::value_type> fee)
+    {
+        // Don't call object_.set(soTemplate) - keep object_ as a free object.
+        // This avoids creating STBase placeholders for soeDEFAULT fields,
+        // which would cause applyTemplate() to throw "may not be explicitly
+        // set to default" when building the STTx.
+        // The STTx constructor will call applyTemplate() which properly
+        // handles missing fields.
+        object_[sfTransactionType] = transactionType;
+        setAccount(account);
+
+        if (sequence)
+        {
+            setSequence(*sequence);
+        }
+        if (fee)
+        {
+            setFee(*fee);
+        }
+    }
+
+    /**
+     * Set the account that is sending the transaction.
+     * @param value Account address (typically as a string)
+     * @return Reference to the derived builder for method chaining.
+     */
+    Derived&
+    setAccount(AccountID const& value)
+    {
+        object_[sfAccount] = value;
+        return static_cast<Derived&>(*this);
+    }
+
+    /**
+     * Set the transaction fee.
+     * @param value Fee in drops (typically as a string or number)
+     * @return Reference to the derived builder for method chaining.
+     */
+    Derived&
+    setFee(STAmount const& value)
+    {
+        object_[sfFee] = value;
+        return static_cast<Derived&>(*this);
+    }
+
+    /**
+     * Set the sequence number.
+     * @param value Sequence number
+     * @return Reference to the derived builder for method chaining.
+     */
+    Derived&
+    setSequence(std::uint32_t const& value)
+    {
+        object_[sfSequence] = value;
+        return static_cast<Derived&>(*this);
+    }
+
+    /**
+     * Set the ticket sequence to use for this transaction.
+     * When using a ticket, the regular sequence number is set to 0.
+     * @param value Ticket sequence number
+     * @return Reference to the derived builder for method chaining.
+     */
+    Derived&
+    setTicketSequence(std::uint32_t const& value)
+    {
+        object_[sfSequence] = 0u;
+        object_[sfTicketSequence] = value;
+        return static_cast<Derived&>(*this);
+    }
+
+    /**
+     * Set transaction flags.
+     * @param value Flags value
+     * @return Reference to the derived builder for method chaining.
+     */
+    Derived&
+    setFlags(std::uint32_t const& value)
+    {
+        object_[sfFlags] = value;
+        return static_cast<Derived&>(*this);
+    }
+
+    /**
+     * Set the source tag.
+     * @param value Source tag
+     * @return Reference to the derived builder for method chaining.
+     */
+    Derived&
+    setSourceTag(std::uint32_t const& value)
+    {
+        object_[sfSourceTag] = value;
+        return static_cast<Derived&>(*this);
+    }
+
+    /**
+     * Set the last ledger sequence.
+     * @param value Last ledger sequence number
+     * @return Reference to the derived builder for method chaining.
+     */
+    Derived&
+    setLastLedgerSequence(std::uint32_t const& value)
+    {
+        object_[sfLastLedgerSequence] = value;
+        return static_cast<Derived&>(*this);
+    }
+
+    /**
+     * Set the account transaction ID.
+     * @param value Account transaction ID (typically as a hex string)
+     * @return Reference to the derived builder for method chaining.
+     */
+    Derived&
+    setAccountTxnID(uint256 const& value)
+    {
+        object_[sfAccountTxnID] = value;
+        return static_cast<Derived&>(*this);
+    }
+
+    /**
+     * Set the previous transaction ID.
+     * Used for emulate027 compatibility.
+     * @param value Previous transaction ID
+     * @return Reference to the derived builder for method chaining.
+     */
+    Derived&
+    setPreviousTxnID(uint256 const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return static_cast<Derived&>(*this);
+    }
+
+    /**
+     * Set the operation limit.
+     * @param value Operation limit
+     * @return Reference to the derived builder for method chaining.
+     */
+    Derived&
+    setOperationLimit(std::uint32_t const& value)
+    {
+        object_[sfOperationLimit] = value;
+        return static_cast<Derived&>(*this);
+    }
+
+    /**
+     * Set the memos array.
+     * @param value Array of memo objects
+     * @return Reference to the derived builder for method chaining.
+     */
+    Derived&
+    setMemos(STArray const& value)
+    {
+        object_.setFieldArray(sfMemos, value);
+        return static_cast<Derived&>(*this);
+    }
+
+    /**
+     * Set the signers array for multi-signing.
+     * @param value Array of signer objects
+     * @return Reference to the derived builder for method chaining.
+     */
+    Derived&
+    setSigners(STArray const& value)
+    {
+        object_.setFieldArray(sfSigners, value);
+        return static_cast<Derived&>(*this);
+    }
+
+    /**
+     * Set the network ID.
+     * @param value Network ID
+     * @return Reference to the derived builder for method chaining.
+     */
+    Derived&
+    setNetworkID(std::uint32_t const& value)
+    {
+        object_[sfNetworkID] = value;
+        return static_cast<Derived&>(*this);
+    }
+
+    /**
+     * Set the delegate account for delegated transactions.
+     * @param value Delegate account ID
+     * @return Reference to the derived builder for method chaining.
+     */
+    Derived&
+    setDelegate(AccountID const& value)
+    {
+        object_[sfDelegate] = value;
+        return static_cast<Derived&>(*this);
+    }
+
+    /**
+     * Get the underlying STObject.
+     * @return The STObject
+     */
+    STObject const&
+    getSTObject() const
+    {
+        return object_;
+    }
+
+protected:
+    /**
+     * Sign the transaction with the given keys.
+     *
+     * This sets the SigningPubKey field and computes the TxnSignature.
+     *
+     * @param publicKey The public key for signing
+     * @param secretKey The secret key for signing
+     * @return Reference to the derived builder for method chaining.
+     */
+    Derived&
+    sign(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        // Set the signing public key
+        object_.setFieldVL(sfSigningPubKey, publicKey.slice());
+
+        // Build the signing data: HashPrefix::txSign + serialized object
+        // (without signing fields)
+        Serializer s;
+        s.add32(HashPrefix::txSign);
+        object_.addWithoutSigningFields(s);
+
+        // Sign and set the signature
+        auto const sig = xrpl::sign(publicKey, secretKey, s.slice());
+        object_.setFieldVL(sfTxnSignature, sig);
+
+        return static_cast<Derived&>(*this);
+    }
+
+    STObject object_{sfTransaction};
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/Utils.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <optional>
+#include <type_traits>
+
+namespace xrpl::protocol_autogen {
+
+template <typename ValueType>
+using Optional = std::conditional_t<
+    std::is_reference_v<ValueType>,
+    std::optional<std::reference_wrapper<std::remove_reference_t<ValueType>>>,
+    std::optional<ValueType>>;
+
+}

include/xrpl/protocol_autogen/ledger_entries/AMM.h

@@ -0,0 +1,392 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class AMMBuilder;
+
+/**
+ * @brief Ledger Entry: AMM
+ *
+ * Type: ltAMM (0x0079)
+ * RPC Name: amm
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use AMMBuilder to construct new ledger entries.
+ */
+class AMM : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltAMM;
+
+    /**
+     * @brief Construct a AMM ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit AMM(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for AMM");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfAccount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_->at(sfAccount);
+    }
+
+    /**
+     * @brief Get sfTradingFee (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT16::type::value_type>
+    getTradingFee() const
+    {
+        if (hasTradingFee())
+            return this->sle_->at(sfTradingFee);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfTradingFee is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasTradingFee() const
+    {
+        return this->sle_->isFieldPresent(sfTradingFee);
+    }
+
+    /**
+     * @brief Get sfVoteSlots (soeOPTIONAL)
+     * @note This is an untyped field (unknown).
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    std::optional<std::reference_wrapper<STArray const>>
+    getVoteSlots() const
+    {
+        if (this->sle_->isFieldPresent(sfVoteSlots))
+            return this->sle_->getFieldArray(sfVoteSlots);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfVoteSlots is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasVoteSlots() const
+    {
+        return this->sle_->isFieldPresent(sfVoteSlots);
+    }
+
+    /**
+     * @brief Get sfAuctionSlot (soeOPTIONAL)
+     * @note This is an untyped field (unknown).
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    std::optional<STObject>
+    getAuctionSlot() const
+    {
+        if (this->sle_->isFieldPresent(sfAuctionSlot))
+            return this->sle_->getFieldObject(sfAuctionSlot);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfAuctionSlot is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasAuctionSlot() const
+    {
+        return this->sle_->isFieldPresent(sfAuctionSlot);
+    }
+
+    /**
+     * @brief Get sfLPTokenBalance (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getLPTokenBalance() const
+    {
+        return this->sle_->at(sfLPTokenBalance);
+    }
+
+    /**
+     * @brief Get sfAsset (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset() const
+    {
+        return this->sle_->at(sfAsset);
+    }
+
+    /**
+     * @brief Get sfAsset2 (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset2() const
+    {
+        return this->sle_->at(sfAsset2);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getPreviousTxnID() const
+    {
+        if (hasPreviousTxnID())
+            return this->sle_->at(sfPreviousTxnID);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfPreviousTxnID is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasPreviousTxnID() const
+    {
+        return this->sle_->isFieldPresent(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getPreviousTxnLgrSeq() const
+    {
+        if (hasPreviousTxnLgrSeq())
+            return this->sle_->at(sfPreviousTxnLgrSeq);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfPreviousTxnLgrSeq is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasPreviousTxnLgrSeq() const
+    {
+        return this->sle_->isFieldPresent(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * @brief Builder for AMM ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class AMMBuilder : public LedgerEntryBuilderBase<AMMBuilder>
+{
+public:
+    /**
+     * @brief Construct a new AMMBuilder with required fields.
+     * @param account The sfAccount field value.
+     * @param lPTokenBalance The sfLPTokenBalance field value.
+     * @param asset The sfAsset field value.
+     * @param asset2 The sfAsset2 field value.
+     * @param ownerNode The sfOwnerNode field value.
+     */
+    AMMBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_AMOUNT::type::value_type> const& lPTokenBalance,std::decay_t<typename SF_ISSUE::type::value_type> const& asset,std::decay_t<typename SF_ISSUE::type::value_type> const& asset2,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode)
+        : LedgerEntryBuilderBase<AMMBuilder>(ltAMM)
+    {
+        setAccount(account);
+        setLPTokenBalance(lPTokenBalance);
+        setAsset(asset);
+        setAsset2(asset2);
+        setOwnerNode(ownerNode);
+    }
+
+    /**
+     * @brief Construct a AMMBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    AMMBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltAMM)
+        {
+            throw std::runtime_error("Invalid ledger entry type for AMM");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfAccount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMBuilder&
+    setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAccount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfTradingFee (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMBuilder&
+    setTradingFee(std::decay_t<typename SF_UINT16::type::value_type> const& value)
+    {
+        object_[sfTradingFee] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfVoteSlots (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMBuilder&
+    setVoteSlots(STArray const& value)
+    {
+        object_.setFieldArray(sfVoteSlots, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAuctionSlot (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMBuilder&
+    setAuctionSlot(STObject const& value)
+    {
+        object_.setFieldObject(sfAuctionSlot, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfLPTokenBalance (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMBuilder&
+    setLPTokenBalance(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfLPTokenBalance] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAsset (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMBuilder&
+    setAsset(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
+    {
+        object_[sfAsset] = STIssue(sfAsset, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAsset2 (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMBuilder&
+    setAsset2(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
+    {
+        object_[sfAsset2] = STIssue(sfAsset2, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed AMM wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    AMM
+    build(uint256 const& index)
+    {
+        return AMM{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/AccountRoot.h

@@ -0,0 +1,834 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class AccountRootBuilder;
+
+/**
+ * @brief Ledger Entry: AccountRoot
+ *
+ * Type: ltACCOUNT_ROOT (0x0061)
+ * RPC Name: account
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use AccountRootBuilder to construct new ledger entries.
+ */
+class AccountRoot : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltACCOUNT_ROOT;
+
+    /**
+     * @brief Construct a AccountRoot ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit AccountRoot(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for AccountRoot");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfAccount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_->at(sfAccount);
+    }
+
+    /**
+     * @brief Get sfSequence (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getSequence() const
+    {
+        return this->sle_->at(sfSequence);
+    }
+
+    /**
+     * @brief Get sfBalance (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getBalance() const
+    {
+        return this->sle_->at(sfBalance);
+    }
+
+    /**
+     * @brief Get sfOwnerCount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getOwnerCount() const
+    {
+        return this->sle_->at(sfOwnerCount);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Get sfAccountTxnID (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getAccountTxnID() const
+    {
+        if (hasAccountTxnID())
+            return this->sle_->at(sfAccountTxnID);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfAccountTxnID is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasAccountTxnID() const
+    {
+        return this->sle_->isFieldPresent(sfAccountTxnID);
+    }
+
+    /**
+     * @brief Get sfRegularKey (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getRegularKey() const
+    {
+        if (hasRegularKey())
+            return this->sle_->at(sfRegularKey);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfRegularKey is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasRegularKey() const
+    {
+        return this->sle_->isFieldPresent(sfRegularKey);
+    }
+
+    /**
+     * @brief Get sfEmailHash (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT128::type::value_type>
+    getEmailHash() const
+    {
+        if (hasEmailHash())
+            return this->sle_->at(sfEmailHash);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfEmailHash is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasEmailHash() const
+    {
+        return this->sle_->isFieldPresent(sfEmailHash);
+    }
+
+    /**
+     * @brief Get sfWalletLocator (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getWalletLocator() const
+    {
+        if (hasWalletLocator())
+            return this->sle_->at(sfWalletLocator);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfWalletLocator is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasWalletLocator() const
+    {
+        return this->sle_->isFieldPresent(sfWalletLocator);
+    }
+
+    /**
+     * @brief Get sfWalletSize (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getWalletSize() const
+    {
+        if (hasWalletSize())
+            return this->sle_->at(sfWalletSize);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfWalletSize is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasWalletSize() const
+    {
+        return this->sle_->isFieldPresent(sfWalletSize);
+    }
+
+    /**
+     * @brief Get sfMessageKey (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getMessageKey() const
+    {
+        if (hasMessageKey())
+            return this->sle_->at(sfMessageKey);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfMessageKey is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasMessageKey() const
+    {
+        return this->sle_->isFieldPresent(sfMessageKey);
+    }
+
+    /**
+     * @brief Get sfTransferRate (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getTransferRate() const
+    {
+        if (hasTransferRate())
+            return this->sle_->at(sfTransferRate);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfTransferRate is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasTransferRate() const
+    {
+        return this->sle_->isFieldPresent(sfTransferRate);
+    }
+
+    /**
+     * @brief Get sfDomain (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getDomain() const
+    {
+        if (hasDomain())
+            return this->sle_->at(sfDomain);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfDomain is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasDomain() const
+    {
+        return this->sle_->isFieldPresent(sfDomain);
+    }
+
+    /**
+     * @brief Get sfTickSize (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT8::type::value_type>
+    getTickSize() const
+    {
+        if (hasTickSize())
+            return this->sle_->at(sfTickSize);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfTickSize is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasTickSize() const
+    {
+        return this->sle_->isFieldPresent(sfTickSize);
+    }
+
+    /**
+     * @brief Get sfTicketCount (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getTicketCount() const
+    {
+        if (hasTicketCount())
+            return this->sle_->at(sfTicketCount);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfTicketCount is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasTicketCount() const
+    {
+        return this->sle_->isFieldPresent(sfTicketCount);
+    }
+
+    /**
+     * @brief Get sfNFTokenMinter (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getNFTokenMinter() const
+    {
+        if (hasNFTokenMinter())
+            return this->sle_->at(sfNFTokenMinter);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfNFTokenMinter is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasNFTokenMinter() const
+    {
+        return this->sle_->isFieldPresent(sfNFTokenMinter);
+    }
+
+    /**
+     * @brief Get sfMintedNFTokens (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getMintedNFTokens() const
+    {
+        if (hasMintedNFTokens())
+            return this->sle_->at(sfMintedNFTokens);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfMintedNFTokens is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasMintedNFTokens() const
+    {
+        return this->sle_->isFieldPresent(sfMintedNFTokens);
+    }
+
+    /**
+     * @brief Get sfBurnedNFTokens (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getBurnedNFTokens() const
+    {
+        if (hasBurnedNFTokens())
+            return this->sle_->at(sfBurnedNFTokens);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfBurnedNFTokens is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasBurnedNFTokens() const
+    {
+        return this->sle_->isFieldPresent(sfBurnedNFTokens);
+    }
+
+    /**
+     * @brief Get sfFirstNFTokenSequence (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getFirstNFTokenSequence() const
+    {
+        if (hasFirstNFTokenSequence())
+            return this->sle_->at(sfFirstNFTokenSequence);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfFirstNFTokenSequence is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasFirstNFTokenSequence() const
+    {
+        return this->sle_->isFieldPresent(sfFirstNFTokenSequence);
+    }
+
+    /**
+     * @brief Get sfAMMID (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getAMMID() const
+    {
+        if (hasAMMID())
+            return this->sle_->at(sfAMMID);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfAMMID is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasAMMID() const
+    {
+        return this->sle_->isFieldPresent(sfAMMID);
+    }
+
+    /**
+     * @brief Get sfVaultID (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getVaultID() const
+    {
+        if (hasVaultID())
+            return this->sle_->at(sfVaultID);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfVaultID is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasVaultID() const
+    {
+        return this->sle_->isFieldPresent(sfVaultID);
+    }
+
+    /**
+     * @brief Get sfLoanBrokerID (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getLoanBrokerID() const
+    {
+        if (hasLoanBrokerID())
+            return this->sle_->at(sfLoanBrokerID);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfLoanBrokerID is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasLoanBrokerID() const
+    {
+        return this->sle_->isFieldPresent(sfLoanBrokerID);
+    }
+};
+
+/**
+ * @brief Builder for AccountRoot ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class AccountRootBuilder : public LedgerEntryBuilderBase<AccountRootBuilder>
+{
+public:
+    /**
+     * @brief Construct a new AccountRootBuilder with required fields.
+     * @param account The sfAccount field value.
+     * @param sequence The sfSequence field value.
+     * @param balance The sfBalance field value.
+     * @param ownerCount The sfOwnerCount field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    AccountRootBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_UINT32::type::value_type> const& sequence,std::decay_t<typename SF_AMOUNT::type::value_type> const& balance,std::decay_t<typename SF_UINT32::type::value_type> const& ownerCount,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<AccountRootBuilder>(ltACCOUNT_ROOT)
+    {
+        setAccount(account);
+        setSequence(sequence);
+        setBalance(balance);
+        setOwnerCount(ownerCount);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a AccountRootBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    AccountRootBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltACCOUNT_ROOT)
+        {
+            throw std::runtime_error("Invalid ledger entry type for AccountRoot");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfAccount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountRootBuilder&
+    setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAccount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSequence (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountRootBuilder&
+    setSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfSequence] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfBalance (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountRootBuilder&
+    setBalance(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfBalance] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerCount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountRootBuilder&
+    setOwnerCount(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfOwnerCount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountRootBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountRootBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAccountTxnID (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountRootBuilder&
+    setAccountTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfAccountTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfRegularKey (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountRootBuilder&
+    setRegularKey(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfRegularKey] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfEmailHash (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountRootBuilder&
+    setEmailHash(std::decay_t<typename SF_UINT128::type::value_type> const& value)
+    {
+        object_[sfEmailHash] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfWalletLocator (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountRootBuilder&
+    setWalletLocator(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfWalletLocator] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfWalletSize (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountRootBuilder&
+    setWalletSize(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfWalletSize] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfMessageKey (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountRootBuilder&
+    setMessageKey(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfMessageKey] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfTransferRate (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountRootBuilder&
+    setTransferRate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfTransferRate] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDomain (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountRootBuilder&
+    setDomain(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfDomain] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfTickSize (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountRootBuilder&
+    setTickSize(std::decay_t<typename SF_UINT8::type::value_type> const& value)
+    {
+        object_[sfTickSize] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfTicketCount (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountRootBuilder&
+    setTicketCount(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfTicketCount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfNFTokenMinter (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountRootBuilder&
+    setNFTokenMinter(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfNFTokenMinter] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfMintedNFTokens (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountRootBuilder&
+    setMintedNFTokens(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfMintedNFTokens] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfBurnedNFTokens (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountRootBuilder&
+    setBurnedNFTokens(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfBurnedNFTokens] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfFirstNFTokenSequence (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountRootBuilder&
+    setFirstNFTokenSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfFirstNFTokenSequence] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAMMID (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountRootBuilder&
+    setAMMID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfAMMID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfVaultID (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountRootBuilder&
+    setVaultID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfVaultID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfLoanBrokerID (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountRootBuilder&
+    setLoanBrokerID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfLoanBrokerID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed AccountRoot wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    AccountRoot
+    build(uint256 const& index)
+    {
+        return AccountRoot{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/Amendments.h

@@ -0,0 +1,236 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class AmendmentsBuilder;
+
+/**
+ * @brief Ledger Entry: Amendments
+ *
+ * Type: ltAMENDMENTS (0x0066)
+ * RPC Name: amendments
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use AmendmentsBuilder to construct new ledger entries.
+ */
+class Amendments : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltAMENDMENTS;
+
+    /**
+     * @brief Construct a Amendments ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit Amendments(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Amendments");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfAmendments (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VECTOR256::type::value_type>
+    getAmendments() const
+    {
+        if (hasAmendments())
+            return this->sle_->at(sfAmendments);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfAmendments is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasAmendments() const
+    {
+        return this->sle_->isFieldPresent(sfAmendments);
+    }
+
+    /**
+     * @brief Get sfMajorities (soeOPTIONAL)
+     * @note This is an untyped field (unknown).
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    std::optional<std::reference_wrapper<STArray const>>
+    getMajorities() const
+    {
+        if (this->sle_->isFieldPresent(sfMajorities))
+            return this->sle_->getFieldArray(sfMajorities);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfMajorities is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasMajorities() const
+    {
+        return this->sle_->isFieldPresent(sfMajorities);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getPreviousTxnID() const
+    {
+        if (hasPreviousTxnID())
+            return this->sle_->at(sfPreviousTxnID);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfPreviousTxnID is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasPreviousTxnID() const
+    {
+        return this->sle_->isFieldPresent(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getPreviousTxnLgrSeq() const
+    {
+        if (hasPreviousTxnLgrSeq())
+            return this->sle_->at(sfPreviousTxnLgrSeq);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfPreviousTxnLgrSeq is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasPreviousTxnLgrSeq() const
+    {
+        return this->sle_->isFieldPresent(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * @brief Builder for Amendments ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class AmendmentsBuilder : public LedgerEntryBuilderBase<AmendmentsBuilder>
+{
+public:
+    /**
+     * @brief Construct a new AmendmentsBuilder with required fields.
+     */
+    AmendmentsBuilder()
+        : LedgerEntryBuilderBase<AmendmentsBuilder>(ltAMENDMENTS)
+    {
+    }
+
+    /**
+     * @brief Construct a AmendmentsBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    AmendmentsBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltAMENDMENTS)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Amendments");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfAmendments (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AmendmentsBuilder&
+    setAmendments(std::decay_t<typename SF_VECTOR256::type::value_type> const& value)
+    {
+        object_[sfAmendments] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfMajorities (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AmendmentsBuilder&
+    setMajorities(STArray const& value)
+    {
+        object_.setFieldArray(sfMajorities, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AmendmentsBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AmendmentsBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed Amendments wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    Amendments
+    build(uint256 const& index)
+    {
+        return Amendments{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/Bridge.h

@@ -0,0 +1,346 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class BridgeBuilder;
+
+/**
+ * @brief Ledger Entry: Bridge
+ *
+ * Type: ltBRIDGE (0x0069)
+ * RPC Name: bridge
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use BridgeBuilder to construct new ledger entries.
+ */
+class Bridge : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltBRIDGE;
+
+    /**
+     * @brief Construct a Bridge ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit Bridge(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Bridge");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfAccount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_->at(sfAccount);
+    }
+
+    /**
+     * @brief Get sfSignatureReward (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getSignatureReward() const
+    {
+        return this->sle_->at(sfSignatureReward);
+    }
+
+    /**
+     * @brief Get sfMinAccountCreateAmount (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getMinAccountCreateAmount() const
+    {
+        if (hasMinAccountCreateAmount())
+            return this->sle_->at(sfMinAccountCreateAmount);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfMinAccountCreateAmount is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasMinAccountCreateAmount() const
+    {
+        return this->sle_->isFieldPresent(sfMinAccountCreateAmount);
+    }
+
+    /**
+     * @brief Get sfXChainBridge (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_XCHAIN_BRIDGE::type::value_type
+    getXChainBridge() const
+    {
+        return this->sle_->at(sfXChainBridge);
+    }
+
+    /**
+     * @brief Get sfXChainClaimID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getXChainClaimID() const
+    {
+        return this->sle_->at(sfXChainClaimID);
+    }
+
+    /**
+     * @brief Get sfXChainAccountCreateCount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getXChainAccountCreateCount() const
+    {
+        return this->sle_->at(sfXChainAccountCreateCount);
+    }
+
+    /**
+     * @brief Get sfXChainAccountClaimCount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getXChainAccountClaimCount() const
+    {
+        return this->sle_->at(sfXChainAccountClaimCount);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * @brief Builder for Bridge ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class BridgeBuilder : public LedgerEntryBuilderBase<BridgeBuilder>
+{
+public:
+    /**
+     * @brief Construct a new BridgeBuilder with required fields.
+     * @param account The sfAccount field value.
+     * @param signatureReward The sfSignatureReward field value.
+     * @param xChainBridge The sfXChainBridge field value.
+     * @param xChainClaimID The sfXChainClaimID field value.
+     * @param xChainAccountCreateCount The sfXChainAccountCreateCount field value.
+     * @param xChainAccountClaimCount The sfXChainAccountClaimCount field value.
+     * @param ownerNode The sfOwnerNode field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    BridgeBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_AMOUNT::type::value_type> const& signatureReward,std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& xChainBridge,std::decay_t<typename SF_UINT64::type::value_type> const& xChainClaimID,std::decay_t<typename SF_UINT64::type::value_type> const& xChainAccountCreateCount,std::decay_t<typename SF_UINT64::type::value_type> const& xChainAccountClaimCount,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<BridgeBuilder>(ltBRIDGE)
+    {
+        setAccount(account);
+        setSignatureReward(signatureReward);
+        setXChainBridge(xChainBridge);
+        setXChainClaimID(xChainClaimID);
+        setXChainAccountCreateCount(xChainAccountCreateCount);
+        setXChainAccountClaimCount(xChainAccountClaimCount);
+        setOwnerNode(ownerNode);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a BridgeBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    BridgeBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltBRIDGE)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Bridge");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfAccount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    BridgeBuilder&
+    setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAccount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSignatureReward (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    BridgeBuilder&
+    setSignatureReward(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfSignatureReward] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfMinAccountCreateAmount (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    BridgeBuilder&
+    setMinAccountCreateAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfMinAccountCreateAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainBridge (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    BridgeBuilder&
+    setXChainBridge(std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& value)
+    {
+        object_[sfXChainBridge] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainClaimID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    BridgeBuilder&
+    setXChainClaimID(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfXChainClaimID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainAccountCreateCount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    BridgeBuilder&
+    setXChainAccountCreateCount(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfXChainAccountCreateCount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainAccountClaimCount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    BridgeBuilder&
+    setXChainAccountClaimCount(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfXChainAccountClaimCount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    BridgeBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    BridgeBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    BridgeBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed Bridge wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    Bridge
+    build(uint256 const& index)
+    {
+        return Bridge{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/Check.h

@@ -0,0 +1,427 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class CheckBuilder;
+
+/**
+ * @brief Ledger Entry: Check
+ *
+ * Type: ltCHECK (0x0043)
+ * RPC Name: check
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use CheckBuilder to construct new ledger entries.
+ */
+class Check : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltCHECK;
+
+    /**
+     * @brief Construct a Check ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit Check(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Check");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfAccount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_->at(sfAccount);
+    }
+
+    /**
+     * @brief Get sfDestination (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getDestination() const
+    {
+        return this->sle_->at(sfDestination);
+    }
+
+    /**
+     * @brief Get sfSendMax (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getSendMax() const
+    {
+        return this->sle_->at(sfSendMax);
+    }
+
+    /**
+     * @brief Get sfSequence (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getSequence() const
+    {
+        return this->sle_->at(sfSequence);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfDestinationNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getDestinationNode() const
+    {
+        return this->sle_->at(sfDestinationNode);
+    }
+
+    /**
+     * @brief Get sfExpiration (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getExpiration() const
+    {
+        if (hasExpiration())
+            return this->sle_->at(sfExpiration);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfExpiration is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasExpiration() const
+    {
+        return this->sle_->isFieldPresent(sfExpiration);
+    }
+
+    /**
+     * @brief Get sfInvoiceID (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getInvoiceID() const
+    {
+        if (hasInvoiceID())
+            return this->sle_->at(sfInvoiceID);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfInvoiceID is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasInvoiceID() const
+    {
+        return this->sle_->isFieldPresent(sfInvoiceID);
+    }
+
+    /**
+     * @brief Get sfSourceTag (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getSourceTag() const
+    {
+        if (hasSourceTag())
+            return this->sle_->at(sfSourceTag);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfSourceTag is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasSourceTag() const
+    {
+        return this->sle_->isFieldPresent(sfSourceTag);
+    }
+
+    /**
+     * @brief Get sfDestinationTag (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getDestinationTag() const
+    {
+        if (hasDestinationTag())
+            return this->sle_->at(sfDestinationTag);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfDestinationTag is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasDestinationTag() const
+    {
+        return this->sle_->isFieldPresent(sfDestinationTag);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * @brief Builder for Check ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class CheckBuilder : public LedgerEntryBuilderBase<CheckBuilder>
+{
+public:
+    /**
+     * @brief Construct a new CheckBuilder with required fields.
+     * @param account The sfAccount field value.
+     * @param destination The sfDestination field value.
+     * @param sendMax The sfSendMax field value.
+     * @param sequence The sfSequence field value.
+     * @param ownerNode The sfOwnerNode field value.
+     * @param destinationNode The sfDestinationNode field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    CheckBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_ACCOUNT::type::value_type> const& destination,std::decay_t<typename SF_AMOUNT::type::value_type> const& sendMax,std::decay_t<typename SF_UINT32::type::value_type> const& sequence,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT64::type::value_type> const& destinationNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<CheckBuilder>(ltCHECK)
+    {
+        setAccount(account);
+        setDestination(destination);
+        setSendMax(sendMax);
+        setSequence(sequence);
+        setOwnerNode(ownerNode);
+        setDestinationNode(destinationNode);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a CheckBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    CheckBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltCHECK)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Check");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfAccount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    CheckBuilder&
+    setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAccount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDestination (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    CheckBuilder&
+    setDestination(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfDestination] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSendMax (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    CheckBuilder&
+    setSendMax(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfSendMax] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSequence (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    CheckBuilder&
+    setSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfSequence] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    CheckBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDestinationNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    CheckBuilder&
+    setDestinationNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfDestinationNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfExpiration (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    CheckBuilder&
+    setExpiration(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfExpiration] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfInvoiceID (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    CheckBuilder&
+    setInvoiceID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfInvoiceID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSourceTag (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    CheckBuilder&
+    setSourceTag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfSourceTag] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDestinationTag (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    CheckBuilder&
+    setDestinationTag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfDestinationTag] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    CheckBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    CheckBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed Check wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    Check
+    build(uint256 const& index)
+    {
+        return Check{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/Credential.h

@@ -0,0 +1,344 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class CredentialBuilder;
+
+/**
+ * @brief Ledger Entry: Credential
+ *
+ * Type: ltCREDENTIAL (0x0081)
+ * RPC Name: credential
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use CredentialBuilder to construct new ledger entries.
+ */
+class Credential : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltCREDENTIAL;
+
+    /**
+     * @brief Construct a Credential ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit Credential(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Credential");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfSubject (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getSubject() const
+    {
+        return this->sle_->at(sfSubject);
+    }
+
+    /**
+     * @brief Get sfIssuer (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getIssuer() const
+    {
+        return this->sle_->at(sfIssuer);
+    }
+
+    /**
+     * @brief Get sfCredentialType (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_VL::type::value_type
+    getCredentialType() const
+    {
+        return this->sle_->at(sfCredentialType);
+    }
+
+    /**
+     * @brief Get sfExpiration (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getExpiration() const
+    {
+        if (hasExpiration())
+            return this->sle_->at(sfExpiration);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfExpiration is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasExpiration() const
+    {
+        return this->sle_->isFieldPresent(sfExpiration);
+    }
+
+    /**
+     * @brief Get sfURI (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getURI() const
+    {
+        if (hasURI())
+            return this->sle_->at(sfURI);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfURI is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasURI() const
+    {
+        return this->sle_->isFieldPresent(sfURI);
+    }
+
+    /**
+     * @brief Get sfIssuerNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getIssuerNode() const
+    {
+        return this->sle_->at(sfIssuerNode);
+    }
+
+    /**
+     * @brief Get sfSubjectNode (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getSubjectNode() const
+    {
+        if (hasSubjectNode())
+            return this->sle_->at(sfSubjectNode);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfSubjectNode is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasSubjectNode() const
+    {
+        return this->sle_->isFieldPresent(sfSubjectNode);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * @brief Builder for Credential ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class CredentialBuilder : public LedgerEntryBuilderBase<CredentialBuilder>
+{
+public:
+    /**
+     * @brief Construct a new CredentialBuilder with required fields.
+     * @param subject The sfSubject field value.
+     * @param issuer The sfIssuer field value.
+     * @param credentialType The sfCredentialType field value.
+     * @param issuerNode The sfIssuerNode field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    CredentialBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& subject,std::decay_t<typename SF_ACCOUNT::type::value_type> const& issuer,std::decay_t<typename SF_VL::type::value_type> const& credentialType,std::decay_t<typename SF_UINT64::type::value_type> const& issuerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<CredentialBuilder>(ltCREDENTIAL)
+    {
+        setSubject(subject);
+        setIssuer(issuer);
+        setCredentialType(credentialType);
+        setIssuerNode(issuerNode);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a CredentialBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    CredentialBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltCREDENTIAL)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Credential");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfSubject (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    CredentialBuilder&
+    setSubject(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfSubject] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfIssuer (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    CredentialBuilder&
+    setIssuer(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfIssuer] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfCredentialType (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    CredentialBuilder&
+    setCredentialType(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfCredentialType] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfExpiration (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    CredentialBuilder&
+    setExpiration(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfExpiration] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfURI (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    CredentialBuilder&
+    setURI(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfURI] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfIssuerNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    CredentialBuilder&
+    setIssuerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfIssuerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSubjectNode (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    CredentialBuilder&
+    setSubjectNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfSubjectNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    CredentialBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    CredentialBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed Credential wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    Credential
+    build(uint256 const& index)
+    {
+        return Credential{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/DID.h

@@ -0,0 +1,296 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class DIDBuilder;
+
+/**
+ * @brief Ledger Entry: DID
+ *
+ * Type: ltDID (0x0049)
+ * RPC Name: did
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use DIDBuilder to construct new ledger entries.
+ */
+class DID : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltDID;
+
+    /**
+     * @brief Construct a DID ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit DID(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for DID");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfAccount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_->at(sfAccount);
+    }
+
+    /**
+     * @brief Get sfDIDDocument (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getDIDDocument() const
+    {
+        if (hasDIDDocument())
+            return this->sle_->at(sfDIDDocument);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfDIDDocument is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasDIDDocument() const
+    {
+        return this->sle_->isFieldPresent(sfDIDDocument);
+    }
+
+    /**
+     * @brief Get sfURI (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getURI() const
+    {
+        if (hasURI())
+            return this->sle_->at(sfURI);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfURI is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasURI() const
+    {
+        return this->sle_->isFieldPresent(sfURI);
+    }
+
+    /**
+     * @brief Get sfData (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getData() const
+    {
+        if (hasData())
+            return this->sle_->at(sfData);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfData is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasData() const
+    {
+        return this->sle_->isFieldPresent(sfData);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * @brief Builder for DID ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class DIDBuilder : public LedgerEntryBuilderBase<DIDBuilder>
+{
+public:
+    /**
+     * @brief Construct a new DIDBuilder with required fields.
+     * @param account The sfAccount field value.
+     * @param ownerNode The sfOwnerNode field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    DIDBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<DIDBuilder>(ltDID)
+    {
+        setAccount(account);
+        setOwnerNode(ownerNode);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a DIDBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    DIDBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltDID)
+        {
+            throw std::runtime_error("Invalid ledger entry type for DID");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfAccount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    DIDBuilder&
+    setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAccount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDIDDocument (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DIDBuilder&
+    setDIDDocument(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfDIDDocument] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfURI (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DIDBuilder&
+    setURI(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfURI] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfData (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DIDBuilder&
+    setData(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfData] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    DIDBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    DIDBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    DIDBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed DID wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    DID
+    build(uint256 const& index)
+    {
+        return DID{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/Delegate.h

@@ -0,0 +1,240 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class DelegateBuilder;
+
+/**
+ * @brief Ledger Entry: Delegate
+ *
+ * Type: ltDELEGATE (0x0083)
+ * RPC Name: delegate
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use DelegateBuilder to construct new ledger entries.
+ */
+class Delegate : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltDELEGATE;
+
+    /**
+     * @brief Construct a Delegate ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit Delegate(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Delegate");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfAccount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_->at(sfAccount);
+    }
+
+    /**
+     * @brief Get sfAuthorize (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAuthorize() const
+    {
+        return this->sle_->at(sfAuthorize);
+    }
+
+    /**
+     * @brief Get sfPermissions (soeREQUIRED)
+     * @note This is an untyped field (unknown).
+     * @return The field value.
+     */
+    [[nodiscard]]
+    STArray const&
+    getPermissions() const
+    {
+        return this->sle_->getFieldArray(sfPermissions);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * @brief Builder for Delegate ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class DelegateBuilder : public LedgerEntryBuilderBase<DelegateBuilder>
+{
+public:
+    /**
+     * @brief Construct a new DelegateBuilder with required fields.
+     * @param account The sfAccount field value.
+     * @param authorize The sfAuthorize field value.
+     * @param permissions The sfPermissions field value.
+     * @param ownerNode The sfOwnerNode field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    DelegateBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_ACCOUNT::type::value_type> const& authorize,STArray const& permissions,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<DelegateBuilder>(ltDELEGATE)
+    {
+        setAccount(account);
+        setAuthorize(authorize);
+        setPermissions(permissions);
+        setOwnerNode(ownerNode);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a DelegateBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    DelegateBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltDELEGATE)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Delegate");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfAccount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    DelegateBuilder&
+    setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAccount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAuthorize (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    DelegateBuilder&
+    setAuthorize(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAuthorize] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPermissions (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    DelegateBuilder&
+    setPermissions(STArray const& value)
+    {
+        object_.setFieldArray(sfPermissions, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    DelegateBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    DelegateBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    DelegateBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed Delegate wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    Delegate
+    build(uint256 const& index)
+    {
+        return Delegate{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/DepositPreauth.h

@@ -0,0 +1,262 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class DepositPreauthBuilder;
+
+/**
+ * @brief Ledger Entry: DepositPreauth
+ *
+ * Type: ltDEPOSIT_PREAUTH (0x0070)
+ * RPC Name: deposit_preauth
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use DepositPreauthBuilder to construct new ledger entries.
+ */
+class DepositPreauth : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltDEPOSIT_PREAUTH;
+
+    /**
+     * @brief Construct a DepositPreauth ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit DepositPreauth(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for DepositPreauth");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfAccount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_->at(sfAccount);
+    }
+
+    /**
+     * @brief Get sfAuthorize (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getAuthorize() const
+    {
+        if (hasAuthorize())
+            return this->sle_->at(sfAuthorize);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfAuthorize is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasAuthorize() const
+    {
+        return this->sle_->isFieldPresent(sfAuthorize);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Get sfAuthorizeCredentials (soeOPTIONAL)
+     * @note This is an untyped field (unknown).
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    std::optional<std::reference_wrapper<STArray const>>
+    getAuthorizeCredentials() const
+    {
+        if (this->sle_->isFieldPresent(sfAuthorizeCredentials))
+            return this->sle_->getFieldArray(sfAuthorizeCredentials);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfAuthorizeCredentials is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasAuthorizeCredentials() const
+    {
+        return this->sle_->isFieldPresent(sfAuthorizeCredentials);
+    }
+};
+
+/**
+ * @brief Builder for DepositPreauth ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class DepositPreauthBuilder : public LedgerEntryBuilderBase<DepositPreauthBuilder>
+{
+public:
+    /**
+     * @brief Construct a new DepositPreauthBuilder with required fields.
+     * @param account The sfAccount field value.
+     * @param ownerNode The sfOwnerNode field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    DepositPreauthBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<DepositPreauthBuilder>(ltDEPOSIT_PREAUTH)
+    {
+        setAccount(account);
+        setOwnerNode(ownerNode);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a DepositPreauthBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    DepositPreauthBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltDEPOSIT_PREAUTH)
+        {
+            throw std::runtime_error("Invalid ledger entry type for DepositPreauth");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfAccount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    DepositPreauthBuilder&
+    setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAccount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAuthorize (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DepositPreauthBuilder&
+    setAuthorize(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAuthorize] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    DepositPreauthBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    DepositPreauthBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    DepositPreauthBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAuthorizeCredentials (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DepositPreauthBuilder&
+    setAuthorizeCredentials(STArray const& value)
+    {
+        object_.setFieldArray(sfAuthorizeCredentials, value);
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed DepositPreauth wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    DepositPreauth
+    build(uint256 const& index)
+    {
+        return DepositPreauth{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/DirectoryNode.h

@@ -0,0 +1,563 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class DirectoryNodeBuilder;
+
+/**
+ * @brief Ledger Entry: DirectoryNode
+ *
+ * Type: ltDIR_NODE (0x0064)
+ * RPC Name: directory
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use DirectoryNodeBuilder to construct new ledger entries.
+ */
+class DirectoryNode : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltDIR_NODE;
+
+    /**
+     * @brief Construct a DirectoryNode ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit DirectoryNode(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for DirectoryNode");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfOwner (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getOwner() const
+    {
+        if (hasOwner())
+            return this->sle_->at(sfOwner);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfOwner is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasOwner() const
+    {
+        return this->sle_->isFieldPresent(sfOwner);
+    }
+
+    /**
+     * @brief Get sfTakerPaysCurrency (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT160::type::value_type>
+    getTakerPaysCurrency() const
+    {
+        if (hasTakerPaysCurrency())
+            return this->sle_->at(sfTakerPaysCurrency);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfTakerPaysCurrency is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasTakerPaysCurrency() const
+    {
+        return this->sle_->isFieldPresent(sfTakerPaysCurrency);
+    }
+
+    /**
+     * @brief Get sfTakerPaysIssuer (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT160::type::value_type>
+    getTakerPaysIssuer() const
+    {
+        if (hasTakerPaysIssuer())
+            return this->sle_->at(sfTakerPaysIssuer);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfTakerPaysIssuer is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasTakerPaysIssuer() const
+    {
+        return this->sle_->isFieldPresent(sfTakerPaysIssuer);
+    }
+
+    /**
+     * @brief Get sfTakerGetsCurrency (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT160::type::value_type>
+    getTakerGetsCurrency() const
+    {
+        if (hasTakerGetsCurrency())
+            return this->sle_->at(sfTakerGetsCurrency);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfTakerGetsCurrency is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasTakerGetsCurrency() const
+    {
+        return this->sle_->isFieldPresent(sfTakerGetsCurrency);
+    }
+
+    /**
+     * @brief Get sfTakerGetsIssuer (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT160::type::value_type>
+    getTakerGetsIssuer() const
+    {
+        if (hasTakerGetsIssuer())
+            return this->sle_->at(sfTakerGetsIssuer);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfTakerGetsIssuer is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasTakerGetsIssuer() const
+    {
+        return this->sle_->isFieldPresent(sfTakerGetsIssuer);
+    }
+
+    /**
+     * @brief Get sfExchangeRate (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getExchangeRate() const
+    {
+        if (hasExchangeRate())
+            return this->sle_->at(sfExchangeRate);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfExchangeRate is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasExchangeRate() const
+    {
+        return this->sle_->isFieldPresent(sfExchangeRate);
+    }
+
+    /**
+     * @brief Get sfIndexes (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_VECTOR256::type::value_type
+    getIndexes() const
+    {
+        return this->sle_->at(sfIndexes);
+    }
+
+    /**
+     * @brief Get sfRootIndex (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getRootIndex() const
+    {
+        return this->sle_->at(sfRootIndex);
+    }
+
+    /**
+     * @brief Get sfIndexNext (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getIndexNext() const
+    {
+        if (hasIndexNext())
+            return this->sle_->at(sfIndexNext);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfIndexNext is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasIndexNext() const
+    {
+        return this->sle_->isFieldPresent(sfIndexNext);
+    }
+
+    /**
+     * @brief Get sfIndexPrevious (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getIndexPrevious() const
+    {
+        if (hasIndexPrevious())
+            return this->sle_->at(sfIndexPrevious);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfIndexPrevious is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasIndexPrevious() const
+    {
+        return this->sle_->isFieldPresent(sfIndexPrevious);
+    }
+
+    /**
+     * @brief Get sfNFTokenID (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getNFTokenID() const
+    {
+        if (hasNFTokenID())
+            return this->sle_->at(sfNFTokenID);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfNFTokenID is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasNFTokenID() const
+    {
+        return this->sle_->isFieldPresent(sfNFTokenID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getPreviousTxnID() const
+    {
+        if (hasPreviousTxnID())
+            return this->sle_->at(sfPreviousTxnID);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfPreviousTxnID is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasPreviousTxnID() const
+    {
+        return this->sle_->isFieldPresent(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getPreviousTxnLgrSeq() const
+    {
+        if (hasPreviousTxnLgrSeq())
+            return this->sle_->at(sfPreviousTxnLgrSeq);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfPreviousTxnLgrSeq is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasPreviousTxnLgrSeq() const
+    {
+        return this->sle_->isFieldPresent(sfPreviousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Get sfDomainID (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getDomainID() const
+    {
+        if (hasDomainID())
+            return this->sle_->at(sfDomainID);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfDomainID is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasDomainID() const
+    {
+        return this->sle_->isFieldPresent(sfDomainID);
+    }
+};
+
+/**
+ * @brief Builder for DirectoryNode ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class DirectoryNodeBuilder : public LedgerEntryBuilderBase<DirectoryNodeBuilder>
+{
+public:
+    /**
+     * @brief Construct a new DirectoryNodeBuilder with required fields.
+     * @param indexes The sfIndexes field value.
+     * @param rootIndex The sfRootIndex field value.
+     */
+    DirectoryNodeBuilder(std::decay_t<typename SF_VECTOR256::type::value_type> const& indexes,std::decay_t<typename SF_UINT256::type::value_type> const& rootIndex)
+        : LedgerEntryBuilderBase<DirectoryNodeBuilder>(ltDIR_NODE)
+    {
+        setIndexes(indexes);
+        setRootIndex(rootIndex);
+    }
+
+    /**
+     * @brief Construct a DirectoryNodeBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    DirectoryNodeBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltDIR_NODE)
+        {
+            throw std::runtime_error("Invalid ledger entry type for DirectoryNode");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfOwner (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DirectoryNodeBuilder&
+    setOwner(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfOwner] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfTakerPaysCurrency (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DirectoryNodeBuilder&
+    setTakerPaysCurrency(std::decay_t<typename SF_UINT160::type::value_type> const& value)
+    {
+        object_[sfTakerPaysCurrency] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfTakerPaysIssuer (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DirectoryNodeBuilder&
+    setTakerPaysIssuer(std::decay_t<typename SF_UINT160::type::value_type> const& value)
+    {
+        object_[sfTakerPaysIssuer] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfTakerGetsCurrency (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DirectoryNodeBuilder&
+    setTakerGetsCurrency(std::decay_t<typename SF_UINT160::type::value_type> const& value)
+    {
+        object_[sfTakerGetsCurrency] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfTakerGetsIssuer (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DirectoryNodeBuilder&
+    setTakerGetsIssuer(std::decay_t<typename SF_UINT160::type::value_type> const& value)
+    {
+        object_[sfTakerGetsIssuer] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfExchangeRate (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DirectoryNodeBuilder&
+    setExchangeRate(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfExchangeRate] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfIndexes (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    DirectoryNodeBuilder&
+    setIndexes(std::decay_t<typename SF_VECTOR256::type::value_type> const& value)
+    {
+        object_[sfIndexes] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfRootIndex (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    DirectoryNodeBuilder&
+    setRootIndex(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfRootIndex] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfIndexNext (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DirectoryNodeBuilder&
+    setIndexNext(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfIndexNext] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfIndexPrevious (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DirectoryNodeBuilder&
+    setIndexPrevious(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfIndexPrevious] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfNFTokenID (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DirectoryNodeBuilder&
+    setNFTokenID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfNFTokenID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DirectoryNodeBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DirectoryNodeBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDomainID (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DirectoryNodeBuilder&
+    setDomainID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfDomainID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed DirectoryNode wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    DirectoryNode
+    build(uint256 const& index)
+    {
+        return DirectoryNode{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/Escrow.h

@@ -0,0 +1,554 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class EscrowBuilder;
+
+/**
+ * @brief Ledger Entry: Escrow
+ *
+ * Type: ltESCROW (0x0075)
+ * RPC Name: escrow
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use EscrowBuilder to construct new ledger entries.
+ */
+class Escrow : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltESCROW;
+
+    /**
+     * @brief Construct a Escrow ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit Escrow(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Escrow");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfAccount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_->at(sfAccount);
+    }
+
+    /**
+     * @brief Get sfSequence (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getSequence() const
+    {
+        if (hasSequence())
+            return this->sle_->at(sfSequence);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfSequence is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasSequence() const
+    {
+        return this->sle_->isFieldPresent(sfSequence);
+    }
+
+    /**
+     * @brief Get sfDestination (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getDestination() const
+    {
+        return this->sle_->at(sfDestination);
+    }
+
+    /**
+     * @brief Get sfAmount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getAmount() const
+    {
+        return this->sle_->at(sfAmount);
+    }
+
+    /**
+     * @brief Get sfCondition (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getCondition() const
+    {
+        if (hasCondition())
+            return this->sle_->at(sfCondition);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfCondition is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasCondition() const
+    {
+        return this->sle_->isFieldPresent(sfCondition);
+    }
+
+    /**
+     * @brief Get sfCancelAfter (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getCancelAfter() const
+    {
+        if (hasCancelAfter())
+            return this->sle_->at(sfCancelAfter);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfCancelAfter is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasCancelAfter() const
+    {
+        return this->sle_->isFieldPresent(sfCancelAfter);
+    }
+
+    /**
+     * @brief Get sfFinishAfter (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getFinishAfter() const
+    {
+        if (hasFinishAfter())
+            return this->sle_->at(sfFinishAfter);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfFinishAfter is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasFinishAfter() const
+    {
+        return this->sle_->isFieldPresent(sfFinishAfter);
+    }
+
+    /**
+     * @brief Get sfSourceTag (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getSourceTag() const
+    {
+        if (hasSourceTag())
+            return this->sle_->at(sfSourceTag);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfSourceTag is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasSourceTag() const
+    {
+        return this->sle_->isFieldPresent(sfSourceTag);
+    }
+
+    /**
+     * @brief Get sfDestinationTag (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getDestinationTag() const
+    {
+        if (hasDestinationTag())
+            return this->sle_->at(sfDestinationTag);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfDestinationTag is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasDestinationTag() const
+    {
+        return this->sle_->isFieldPresent(sfDestinationTag);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Get sfDestinationNode (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getDestinationNode() const
+    {
+        if (hasDestinationNode())
+            return this->sle_->at(sfDestinationNode);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfDestinationNode is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasDestinationNode() const
+    {
+        return this->sle_->isFieldPresent(sfDestinationNode);
+    }
+
+    /**
+     * @brief Get sfTransferRate (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getTransferRate() const
+    {
+        if (hasTransferRate())
+            return this->sle_->at(sfTransferRate);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfTransferRate is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasTransferRate() const
+    {
+        return this->sle_->isFieldPresent(sfTransferRate);
+    }
+
+    /**
+     * @brief Get sfIssuerNode (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getIssuerNode() const
+    {
+        if (hasIssuerNode())
+            return this->sle_->at(sfIssuerNode);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfIssuerNode is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasIssuerNode() const
+    {
+        return this->sle_->isFieldPresent(sfIssuerNode);
+    }
+};
+
+/**
+ * @brief Builder for Escrow ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class EscrowBuilder : public LedgerEntryBuilderBase<EscrowBuilder>
+{
+public:
+    /**
+     * @brief Construct a new EscrowBuilder with required fields.
+     * @param account The sfAccount field value.
+     * @param destination The sfDestination field value.
+     * @param amount The sfAmount field value.
+     * @param ownerNode The sfOwnerNode field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    EscrowBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_ACCOUNT::type::value_type> const& destination,std::decay_t<typename SF_AMOUNT::type::value_type> const& amount,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<EscrowBuilder>(ltESCROW)
+    {
+        setAccount(account);
+        setDestination(destination);
+        setAmount(amount);
+        setOwnerNode(ownerNode);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a EscrowBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    EscrowBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltESCROW)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Escrow");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfAccount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowBuilder&
+    setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAccount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSequence (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowBuilder&
+    setSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfSequence] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDestination (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowBuilder&
+    setDestination(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfDestination] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAmount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowBuilder&
+    setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfCondition (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowBuilder&
+    setCondition(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfCondition] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfCancelAfter (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowBuilder&
+    setCancelAfter(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfCancelAfter] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfFinishAfter (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowBuilder&
+    setFinishAfter(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfFinishAfter] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSourceTag (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowBuilder&
+    setSourceTag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfSourceTag] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDestinationTag (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowBuilder&
+    setDestinationTag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfDestinationTag] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDestinationNode (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowBuilder&
+    setDestinationNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfDestinationNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfTransferRate (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowBuilder&
+    setTransferRate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfTransferRate] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfIssuerNode (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowBuilder&
+    setIssuerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfIssuerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed Escrow wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    Escrow
+    build(uint256 const& index)
+    {
+        return Escrow{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/FeeSettings.h

@@ -0,0 +1,410 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class FeeSettingsBuilder;
+
+/**
+ * @brief Ledger Entry: FeeSettings
+ *
+ * Type: ltFEE_SETTINGS (0x0073)
+ * RPC Name: fee
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use FeeSettingsBuilder to construct new ledger entries.
+ */
+class FeeSettings : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltFEE_SETTINGS;
+
+    /**
+     * @brief Construct a FeeSettings ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit FeeSettings(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for FeeSettings");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfBaseFee (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getBaseFee() const
+    {
+        if (hasBaseFee())
+            return this->sle_->at(sfBaseFee);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfBaseFee is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasBaseFee() const
+    {
+        return this->sle_->isFieldPresent(sfBaseFee);
+    }
+
+    /**
+     * @brief Get sfReferenceFeeUnits (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getReferenceFeeUnits() const
+    {
+        if (hasReferenceFeeUnits())
+            return this->sle_->at(sfReferenceFeeUnits);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfReferenceFeeUnits is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasReferenceFeeUnits() const
+    {
+        return this->sle_->isFieldPresent(sfReferenceFeeUnits);
+    }
+
+    /**
+     * @brief Get sfReserveBase (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getReserveBase() const
+    {
+        if (hasReserveBase())
+            return this->sle_->at(sfReserveBase);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfReserveBase is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasReserveBase() const
+    {
+        return this->sle_->isFieldPresent(sfReserveBase);
+    }
+
+    /**
+     * @brief Get sfReserveIncrement (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getReserveIncrement() const
+    {
+        if (hasReserveIncrement())
+            return this->sle_->at(sfReserveIncrement);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfReserveIncrement is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasReserveIncrement() const
+    {
+        return this->sle_->isFieldPresent(sfReserveIncrement);
+    }
+
+    /**
+     * @brief Get sfBaseFeeDrops (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getBaseFeeDrops() const
+    {
+        if (hasBaseFeeDrops())
+            return this->sle_->at(sfBaseFeeDrops);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfBaseFeeDrops is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasBaseFeeDrops() const
+    {
+        return this->sle_->isFieldPresent(sfBaseFeeDrops);
+    }
+
+    /**
+     * @brief Get sfReserveBaseDrops (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getReserveBaseDrops() const
+    {
+        if (hasReserveBaseDrops())
+            return this->sle_->at(sfReserveBaseDrops);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfReserveBaseDrops is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasReserveBaseDrops() const
+    {
+        return this->sle_->isFieldPresent(sfReserveBaseDrops);
+    }
+
+    /**
+     * @brief Get sfReserveIncrementDrops (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getReserveIncrementDrops() const
+    {
+        if (hasReserveIncrementDrops())
+            return this->sle_->at(sfReserveIncrementDrops);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfReserveIncrementDrops is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasReserveIncrementDrops() const
+    {
+        return this->sle_->isFieldPresent(sfReserveIncrementDrops);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getPreviousTxnID() const
+    {
+        if (hasPreviousTxnID())
+            return this->sle_->at(sfPreviousTxnID);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfPreviousTxnID is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasPreviousTxnID() const
+    {
+        return this->sle_->isFieldPresent(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getPreviousTxnLgrSeq() const
+    {
+        if (hasPreviousTxnLgrSeq())
+            return this->sle_->at(sfPreviousTxnLgrSeq);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfPreviousTxnLgrSeq is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasPreviousTxnLgrSeq() const
+    {
+        return this->sle_->isFieldPresent(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * @brief Builder for FeeSettings ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class FeeSettingsBuilder : public LedgerEntryBuilderBase<FeeSettingsBuilder>
+{
+public:
+    /**
+     * @brief Construct a new FeeSettingsBuilder with required fields.
+     */
+    FeeSettingsBuilder()
+        : LedgerEntryBuilderBase<FeeSettingsBuilder>(ltFEE_SETTINGS)
+    {
+    }
+
+    /**
+     * @brief Construct a FeeSettingsBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    FeeSettingsBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltFEE_SETTINGS)
+        {
+            throw std::runtime_error("Invalid ledger entry type for FeeSettings");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfBaseFee (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    FeeSettingsBuilder&
+    setBaseFee(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfBaseFee] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfReferenceFeeUnits (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    FeeSettingsBuilder&
+    setReferenceFeeUnits(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfReferenceFeeUnits] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfReserveBase (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    FeeSettingsBuilder&
+    setReserveBase(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfReserveBase] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfReserveIncrement (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    FeeSettingsBuilder&
+    setReserveIncrement(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfReserveIncrement] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfBaseFeeDrops (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    FeeSettingsBuilder&
+    setBaseFeeDrops(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfBaseFeeDrops] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfReserveBaseDrops (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    FeeSettingsBuilder&
+    setReserveBaseDrops(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfReserveBaseDrops] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfReserveIncrementDrops (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    FeeSettingsBuilder&
+    setReserveIncrementDrops(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfReserveIncrementDrops] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    FeeSettingsBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    FeeSettingsBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed FeeSettings wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    FeeSettings
+    build(uint256 const& index)
+    {
+        return FeeSettings{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/LedgerHashes.h

@@ -0,0 +1,189 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class LedgerHashesBuilder;
+
+/**
+ * @brief Ledger Entry: LedgerHashes
+ *
+ * Type: ltLEDGER_HASHES (0x0068)
+ * RPC Name: hashes
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use LedgerHashesBuilder to construct new ledger entries.
+ */
+class LedgerHashes : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltLEDGER_HASHES;
+
+    /**
+     * @brief Construct a LedgerHashes ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit LedgerHashes(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for LedgerHashes");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfFirstLedgerSequence (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getFirstLedgerSequence() const
+    {
+        if (hasFirstLedgerSequence())
+            return this->sle_->at(sfFirstLedgerSequence);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfFirstLedgerSequence is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasFirstLedgerSequence() const
+    {
+        return this->sle_->isFieldPresent(sfFirstLedgerSequence);
+    }
+
+    /**
+     * @brief Get sfLastLedgerSequence (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getLastLedgerSequence() const
+    {
+        if (hasLastLedgerSequence())
+            return this->sle_->at(sfLastLedgerSequence);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfLastLedgerSequence is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasLastLedgerSequence() const
+    {
+        return this->sle_->isFieldPresent(sfLastLedgerSequence);
+    }
+
+    /**
+     * @brief Get sfHashes (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_VECTOR256::type::value_type
+    getHashes() const
+    {
+        return this->sle_->at(sfHashes);
+    }
+};
+
+/**
+ * @brief Builder for LedgerHashes ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class LedgerHashesBuilder : public LedgerEntryBuilderBase<LedgerHashesBuilder>
+{
+public:
+    /**
+     * @brief Construct a new LedgerHashesBuilder with required fields.
+     * @param hashes The sfHashes field value.
+     */
+    LedgerHashesBuilder(std::decay_t<typename SF_VECTOR256::type::value_type> const& hashes)
+        : LedgerEntryBuilderBase<LedgerHashesBuilder>(ltLEDGER_HASHES)
+    {
+        setHashes(hashes);
+    }
+
+    /**
+     * @brief Construct a LedgerHashesBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    LedgerHashesBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltLEDGER_HASHES)
+        {
+            throw std::runtime_error("Invalid ledger entry type for LedgerHashes");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfFirstLedgerSequence (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    LedgerHashesBuilder&
+    setFirstLedgerSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfFirstLedgerSequence] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfLastLedgerSequence (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    LedgerHashesBuilder&
+    setLastLedgerSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfLastLedgerSequence] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfHashes (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LedgerHashesBuilder&
+    setHashes(std::decay_t<typename SF_VECTOR256::type::value_type> const& value)
+    {
+        object_[sfHashes] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed LedgerHashes wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    LedgerHashes
+    build(uint256 const& index)
+    {
+        return LedgerHashes{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/Loan.h

@@ -0,0 +1,930 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class LoanBuilder;
+
+/**
+ * @brief Ledger Entry: Loan
+ *
+ * Type: ltLOAN (0x0089)
+ * RPC Name: loan
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use LoanBuilder to construct new ledger entries.
+ */
+class Loan : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltLOAN;
+
+    /**
+     * @brief Construct a Loan ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit Loan(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Loan");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfLoanBrokerNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getLoanBrokerNode() const
+    {
+        return this->sle_->at(sfLoanBrokerNode);
+    }
+
+    /**
+     * @brief Get sfLoanBrokerID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getLoanBrokerID() const
+    {
+        return this->sle_->at(sfLoanBrokerID);
+    }
+
+    /**
+     * @brief Get sfLoanSequence (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getLoanSequence() const
+    {
+        return this->sle_->at(sfLoanSequence);
+    }
+
+    /**
+     * @brief Get sfBorrower (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getBorrower() const
+    {
+        return this->sle_->at(sfBorrower);
+    }
+
+    /**
+     * @brief Get sfLoanOriginationFee (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getLoanOriginationFee() const
+    {
+        if (hasLoanOriginationFee())
+            return this->sle_->at(sfLoanOriginationFee);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfLoanOriginationFee is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasLoanOriginationFee() const
+    {
+        return this->sle_->isFieldPresent(sfLoanOriginationFee);
+    }
+
+    /**
+     * @brief Get sfLoanServiceFee (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getLoanServiceFee() const
+    {
+        if (hasLoanServiceFee())
+            return this->sle_->at(sfLoanServiceFee);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfLoanServiceFee is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasLoanServiceFee() const
+    {
+        return this->sle_->isFieldPresent(sfLoanServiceFee);
+    }
+
+    /**
+     * @brief Get sfLatePaymentFee (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getLatePaymentFee() const
+    {
+        if (hasLatePaymentFee())
+            return this->sle_->at(sfLatePaymentFee);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfLatePaymentFee is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasLatePaymentFee() const
+    {
+        return this->sle_->isFieldPresent(sfLatePaymentFee);
+    }
+
+    /**
+     * @brief Get sfClosePaymentFee (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getClosePaymentFee() const
+    {
+        if (hasClosePaymentFee())
+            return this->sle_->at(sfClosePaymentFee);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfClosePaymentFee is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasClosePaymentFee() const
+    {
+        return this->sle_->isFieldPresent(sfClosePaymentFee);
+    }
+
+    /**
+     * @brief Get sfOverpaymentFee (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getOverpaymentFee() const
+    {
+        if (hasOverpaymentFee())
+            return this->sle_->at(sfOverpaymentFee);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfOverpaymentFee is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasOverpaymentFee() const
+    {
+        return this->sle_->isFieldPresent(sfOverpaymentFee);
+    }
+
+    /**
+     * @brief Get sfInterestRate (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getInterestRate() const
+    {
+        if (hasInterestRate())
+            return this->sle_->at(sfInterestRate);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfInterestRate is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasInterestRate() const
+    {
+        return this->sle_->isFieldPresent(sfInterestRate);
+    }
+
+    /**
+     * @brief Get sfLateInterestRate (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getLateInterestRate() const
+    {
+        if (hasLateInterestRate())
+            return this->sle_->at(sfLateInterestRate);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfLateInterestRate is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasLateInterestRate() const
+    {
+        return this->sle_->isFieldPresent(sfLateInterestRate);
+    }
+
+    /**
+     * @brief Get sfCloseInterestRate (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getCloseInterestRate() const
+    {
+        if (hasCloseInterestRate())
+            return this->sle_->at(sfCloseInterestRate);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfCloseInterestRate is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasCloseInterestRate() const
+    {
+        return this->sle_->isFieldPresent(sfCloseInterestRate);
+    }
+
+    /**
+     * @brief Get sfOverpaymentInterestRate (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getOverpaymentInterestRate() const
+    {
+        if (hasOverpaymentInterestRate())
+            return this->sle_->at(sfOverpaymentInterestRate);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfOverpaymentInterestRate is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasOverpaymentInterestRate() const
+    {
+        return this->sle_->isFieldPresent(sfOverpaymentInterestRate);
+    }
+
+    /**
+     * @brief Get sfStartDate (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getStartDate() const
+    {
+        return this->sle_->at(sfStartDate);
+    }
+
+    /**
+     * @brief Get sfPaymentInterval (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPaymentInterval() const
+    {
+        return this->sle_->at(sfPaymentInterval);
+    }
+
+    /**
+     * @brief Get sfGracePeriod (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getGracePeriod() const
+    {
+        if (hasGracePeriod())
+            return this->sle_->at(sfGracePeriod);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfGracePeriod is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasGracePeriod() const
+    {
+        return this->sle_->isFieldPresent(sfGracePeriod);
+    }
+
+    /**
+     * @brief Get sfPreviousPaymentDueDate (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getPreviousPaymentDueDate() const
+    {
+        if (hasPreviousPaymentDueDate())
+            return this->sle_->at(sfPreviousPaymentDueDate);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfPreviousPaymentDueDate is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasPreviousPaymentDueDate() const
+    {
+        return this->sle_->isFieldPresent(sfPreviousPaymentDueDate);
+    }
+
+    /**
+     * @brief Get sfNextPaymentDueDate (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getNextPaymentDueDate() const
+    {
+        if (hasNextPaymentDueDate())
+            return this->sle_->at(sfNextPaymentDueDate);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfNextPaymentDueDate is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasNextPaymentDueDate() const
+    {
+        return this->sle_->isFieldPresent(sfNextPaymentDueDate);
+    }
+
+    /**
+     * @brief Get sfPaymentRemaining (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getPaymentRemaining() const
+    {
+        if (hasPaymentRemaining())
+            return this->sle_->at(sfPaymentRemaining);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfPaymentRemaining is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasPaymentRemaining() const
+    {
+        return this->sle_->isFieldPresent(sfPaymentRemaining);
+    }
+
+    /**
+     * @brief Get sfPeriodicPayment (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_NUMBER::type::value_type
+    getPeriodicPayment() const
+    {
+        return this->sle_->at(sfPeriodicPayment);
+    }
+
+    /**
+     * @brief Get sfPrincipalOutstanding (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getPrincipalOutstanding() const
+    {
+        if (hasPrincipalOutstanding())
+            return this->sle_->at(sfPrincipalOutstanding);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfPrincipalOutstanding is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasPrincipalOutstanding() const
+    {
+        return this->sle_->isFieldPresent(sfPrincipalOutstanding);
+    }
+
+    /**
+     * @brief Get sfTotalValueOutstanding (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getTotalValueOutstanding() const
+    {
+        if (hasTotalValueOutstanding())
+            return this->sle_->at(sfTotalValueOutstanding);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfTotalValueOutstanding is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasTotalValueOutstanding() const
+    {
+        return this->sle_->isFieldPresent(sfTotalValueOutstanding);
+    }
+
+    /**
+     * @brief Get sfManagementFeeOutstanding (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getManagementFeeOutstanding() const
+    {
+        if (hasManagementFeeOutstanding())
+            return this->sle_->at(sfManagementFeeOutstanding);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfManagementFeeOutstanding is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasManagementFeeOutstanding() const
+    {
+        return this->sle_->isFieldPresent(sfManagementFeeOutstanding);
+    }
+
+    /**
+     * @brief Get sfLoanScale (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_INT32::type::value_type>
+    getLoanScale() const
+    {
+        if (hasLoanScale())
+            return this->sle_->at(sfLoanScale);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfLoanScale is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasLoanScale() const
+    {
+        return this->sle_->isFieldPresent(sfLoanScale);
+    }
+};
+
+/**
+ * @brief Builder for Loan ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class LoanBuilder : public LedgerEntryBuilderBase<LoanBuilder>
+{
+public:
+    /**
+     * @brief Construct a new LoanBuilder with required fields.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     * @param ownerNode The sfOwnerNode field value.
+     * @param loanBrokerNode The sfLoanBrokerNode field value.
+     * @param loanBrokerID The sfLoanBrokerID field value.
+     * @param loanSequence The sfLoanSequence field value.
+     * @param borrower The sfBorrower field value.
+     * @param startDate The sfStartDate field value.
+     * @param paymentInterval The sfPaymentInterval field value.
+     * @param periodicPayment The sfPeriodicPayment field value.
+     */
+    LoanBuilder(std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT64::type::value_type> const& loanBrokerNode,std::decay_t<typename SF_UINT256::type::value_type> const& loanBrokerID,std::decay_t<typename SF_UINT32::type::value_type> const& loanSequence,std::decay_t<typename SF_ACCOUNT::type::value_type> const& borrower,std::decay_t<typename SF_UINT32::type::value_type> const& startDate,std::decay_t<typename SF_UINT32::type::value_type> const& paymentInterval,std::decay_t<typename SF_NUMBER::type::value_type> const& periodicPayment)
+        : LedgerEntryBuilderBase<LoanBuilder>(ltLOAN)
+    {
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+        setOwnerNode(ownerNode);
+        setLoanBrokerNode(loanBrokerNode);
+        setLoanBrokerID(loanBrokerID);
+        setLoanSequence(loanSequence);
+        setBorrower(borrower);
+        setStartDate(startDate);
+        setPaymentInterval(paymentInterval);
+        setPeriodicPayment(periodicPayment);
+    }
+
+    /**
+     * @brief Construct a LoanBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    LoanBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltLOAN)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Loan");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfLoanBrokerNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setLoanBrokerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfLoanBrokerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfLoanBrokerID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setLoanBrokerID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfLoanBrokerID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfLoanSequence (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setLoanSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfLoanSequence] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfBorrower (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setBorrower(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfBorrower] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfLoanOriginationFee (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setLoanOriginationFee(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
+    {
+        object_[sfLoanOriginationFee] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfLoanServiceFee (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setLoanServiceFee(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
+    {
+        object_[sfLoanServiceFee] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfLatePaymentFee (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setLatePaymentFee(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
+    {
+        object_[sfLatePaymentFee] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfClosePaymentFee (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setClosePaymentFee(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
+    {
+        object_[sfClosePaymentFee] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOverpaymentFee (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setOverpaymentFee(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfOverpaymentFee] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfInterestRate (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setInterestRate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfInterestRate] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfLateInterestRate (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setLateInterestRate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfLateInterestRate] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfCloseInterestRate (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setCloseInterestRate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfCloseInterestRate] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOverpaymentInterestRate (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setOverpaymentInterestRate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfOverpaymentInterestRate] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfStartDate (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setStartDate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfStartDate] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPaymentInterval (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setPaymentInterval(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPaymentInterval] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfGracePeriod (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setGracePeriod(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfGracePeriod] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousPaymentDueDate (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setPreviousPaymentDueDate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousPaymentDueDate] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfNextPaymentDueDate (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setNextPaymentDueDate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfNextPaymentDueDate] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPaymentRemaining (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setPaymentRemaining(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPaymentRemaining] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPeriodicPayment (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setPeriodicPayment(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
+    {
+        object_[sfPeriodicPayment] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPrincipalOutstanding (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setPrincipalOutstanding(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
+    {
+        object_[sfPrincipalOutstanding] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfTotalValueOutstanding (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setTotalValueOutstanding(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
+    {
+        object_[sfTotalValueOutstanding] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfManagementFeeOutstanding (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setManagementFeeOutstanding(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
+    {
+        object_[sfManagementFeeOutstanding] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfLoanScale (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBuilder&
+    setLoanScale(std::decay_t<typename SF_INT32::type::value_type> const& value)
+    {
+        object_[sfLoanScale] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed Loan wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    Loan
+    build(uint256 const& index)
+    {
+        return Loan{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/LoanBroker.h

@@ -0,0 +1,591 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class LoanBrokerBuilder;
+
+/**
+ * @brief Ledger Entry: LoanBroker
+ *
+ * Type: ltLOAN_BROKER (0x0088)
+ * RPC Name: loan_broker
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use LoanBrokerBuilder to construct new ledger entries.
+ */
+class LoanBroker : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltLOAN_BROKER;
+
+    /**
+     * @brief Construct a LoanBroker ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit LoanBroker(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for LoanBroker");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Get sfSequence (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getSequence() const
+    {
+        return this->sle_->at(sfSequence);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfVaultNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getVaultNode() const
+    {
+        return this->sle_->at(sfVaultNode);
+    }
+
+    /**
+     * @brief Get sfVaultID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getVaultID() const
+    {
+        return this->sle_->at(sfVaultID);
+    }
+
+    /**
+     * @brief Get sfAccount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_->at(sfAccount);
+    }
+
+    /**
+     * @brief Get sfOwner (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getOwner() const
+    {
+        return this->sle_->at(sfOwner);
+    }
+
+    /**
+     * @brief Get sfLoanSequence (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getLoanSequence() const
+    {
+        return this->sle_->at(sfLoanSequence);
+    }
+
+    /**
+     * @brief Get sfData (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getData() const
+    {
+        if (hasData())
+            return this->sle_->at(sfData);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfData is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasData() const
+    {
+        return this->sle_->isFieldPresent(sfData);
+    }
+
+    /**
+     * @brief Get sfManagementFeeRate (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT16::type::value_type>
+    getManagementFeeRate() const
+    {
+        if (hasManagementFeeRate())
+            return this->sle_->at(sfManagementFeeRate);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfManagementFeeRate is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasManagementFeeRate() const
+    {
+        return this->sle_->isFieldPresent(sfManagementFeeRate);
+    }
+
+    /**
+     * @brief Get sfOwnerCount (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getOwnerCount() const
+    {
+        if (hasOwnerCount())
+            return this->sle_->at(sfOwnerCount);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfOwnerCount is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasOwnerCount() const
+    {
+        return this->sle_->isFieldPresent(sfOwnerCount);
+    }
+
+    /**
+     * @brief Get sfDebtTotal (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getDebtTotal() const
+    {
+        if (hasDebtTotal())
+            return this->sle_->at(sfDebtTotal);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfDebtTotal is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasDebtTotal() const
+    {
+        return this->sle_->isFieldPresent(sfDebtTotal);
+    }
+
+    /**
+     * @brief Get sfDebtMaximum (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getDebtMaximum() const
+    {
+        if (hasDebtMaximum())
+            return this->sle_->at(sfDebtMaximum);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfDebtMaximum is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasDebtMaximum() const
+    {
+        return this->sle_->isFieldPresent(sfDebtMaximum);
+    }
+
+    /**
+     * @brief Get sfCoverAvailable (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getCoverAvailable() const
+    {
+        if (hasCoverAvailable())
+            return this->sle_->at(sfCoverAvailable);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfCoverAvailable is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasCoverAvailable() const
+    {
+        return this->sle_->isFieldPresent(sfCoverAvailable);
+    }
+
+    /**
+     * @brief Get sfCoverRateMinimum (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getCoverRateMinimum() const
+    {
+        if (hasCoverRateMinimum())
+            return this->sle_->at(sfCoverRateMinimum);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfCoverRateMinimum is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasCoverRateMinimum() const
+    {
+        return this->sle_->isFieldPresent(sfCoverRateMinimum);
+    }
+
+    /**
+     * @brief Get sfCoverRateLiquidation (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getCoverRateLiquidation() const
+    {
+        if (hasCoverRateLiquidation())
+            return this->sle_->at(sfCoverRateLiquidation);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfCoverRateLiquidation is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasCoverRateLiquidation() const
+    {
+        return this->sle_->isFieldPresent(sfCoverRateLiquidation);
+    }
+};
+
+/**
+ * @brief Builder for LoanBroker ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class LoanBrokerBuilder : public LedgerEntryBuilderBase<LoanBrokerBuilder>
+{
+public:
+    /**
+     * @brief Construct a new LoanBrokerBuilder with required fields.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     * @param sequence The sfSequence field value.
+     * @param ownerNode The sfOwnerNode field value.
+     * @param vaultNode The sfVaultNode field value.
+     * @param vaultID The sfVaultID field value.
+     * @param account The sfAccount field value.
+     * @param owner The sfOwner field value.
+     * @param loanSequence The sfLoanSequence field value.
+     */
+    LoanBrokerBuilder(std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq,std::decay_t<typename SF_UINT32::type::value_type> const& sequence,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT64::type::value_type> const& vaultNode,std::decay_t<typename SF_UINT256::type::value_type> const& vaultID,std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_ACCOUNT::type::value_type> const& owner,std::decay_t<typename SF_UINT32::type::value_type> const& loanSequence)
+        : LedgerEntryBuilderBase<LoanBrokerBuilder>(ltLOAN_BROKER)
+    {
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+        setSequence(sequence);
+        setOwnerNode(ownerNode);
+        setVaultNode(vaultNode);
+        setVaultID(vaultID);
+        setAccount(account);
+        setOwner(owner);
+        setLoanSequence(loanSequence);
+    }
+
+    /**
+     * @brief Construct a LoanBrokerBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    LoanBrokerBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltLOAN_BROKER)
+        {
+            throw std::runtime_error("Invalid ledger entry type for LoanBroker");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSequence (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerBuilder&
+    setSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfSequence] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfVaultNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerBuilder&
+    setVaultNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfVaultNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfVaultID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerBuilder&
+    setVaultID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfVaultID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAccount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerBuilder&
+    setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAccount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwner (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerBuilder&
+    setOwner(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfOwner] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfLoanSequence (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerBuilder&
+    setLoanSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfLoanSequence] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfData (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerBuilder&
+    setData(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfData] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfManagementFeeRate (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerBuilder&
+    setManagementFeeRate(std::decay_t<typename SF_UINT16::type::value_type> const& value)
+    {
+        object_[sfManagementFeeRate] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerCount (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerBuilder&
+    setOwnerCount(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfOwnerCount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDebtTotal (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerBuilder&
+    setDebtTotal(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
+    {
+        object_[sfDebtTotal] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDebtMaximum (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerBuilder&
+    setDebtMaximum(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
+    {
+        object_[sfDebtMaximum] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfCoverAvailable (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerBuilder&
+    setCoverAvailable(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
+    {
+        object_[sfCoverAvailable] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfCoverRateMinimum (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerBuilder&
+    setCoverRateMinimum(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfCoverRateMinimum] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfCoverRateLiquidation (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerBuilder&
+    setCoverRateLiquidation(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfCoverRateLiquidation] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed LoanBroker wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    LoanBroker
+    build(uint256 const& index)
+    {
+        return LoanBroker{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/MPToken.h

@@ -0,0 +1,285 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class MPTokenBuilder;
+
+/**
+ * @brief Ledger Entry: MPToken
+ *
+ * Type: ltMPTOKEN (0x007f)
+ * RPC Name: mptoken
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use MPTokenBuilder to construct new ledger entries.
+ */
+class MPToken : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltMPTOKEN;
+
+    /**
+     * @brief Construct a MPToken ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit MPToken(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for MPToken");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfAccount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_->at(sfAccount);
+    }
+
+    /**
+     * @brief Get sfMPTokenIssuanceID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT192::type::value_type
+    getMPTokenIssuanceID() const
+    {
+        return this->sle_->at(sfMPTokenIssuanceID);
+    }
+
+    /**
+     * @brief Get sfMPTAmount (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getMPTAmount() const
+    {
+        if (hasMPTAmount())
+            return this->sle_->at(sfMPTAmount);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfMPTAmount is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasMPTAmount() const
+    {
+        return this->sle_->isFieldPresent(sfMPTAmount);
+    }
+
+    /**
+     * @brief Get sfLockedAmount (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getLockedAmount() const
+    {
+        if (hasLockedAmount())
+            return this->sle_->at(sfLockedAmount);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfLockedAmount is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasLockedAmount() const
+    {
+        return this->sle_->isFieldPresent(sfLockedAmount);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * @brief Builder for MPToken ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class MPTokenBuilder : public LedgerEntryBuilderBase<MPTokenBuilder>
+{
+public:
+    /**
+     * @brief Construct a new MPTokenBuilder with required fields.
+     * @param account The sfAccount field value.
+     * @param mPTokenIssuanceID The sfMPTokenIssuanceID field value.
+     * @param ownerNode The sfOwnerNode field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    MPTokenBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_UINT192::type::value_type> const& mPTokenIssuanceID,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<MPTokenBuilder>(ltMPTOKEN)
+    {
+        setAccount(account);
+        setMPTokenIssuanceID(mPTokenIssuanceID);
+        setOwnerNode(ownerNode);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a MPTokenBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    MPTokenBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltMPTOKEN)
+        {
+            throw std::runtime_error("Invalid ledger entry type for MPToken");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfAccount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenBuilder&
+    setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAccount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfMPTokenIssuanceID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenBuilder&
+    setMPTokenIssuanceID(std::decay_t<typename SF_UINT192::type::value_type> const& value)
+    {
+        object_[sfMPTokenIssuanceID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfMPTAmount (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenBuilder&
+    setMPTAmount(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfMPTAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfLockedAmount (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenBuilder&
+    setLockedAmount(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfLockedAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed MPToken wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    MPToken
+    build(uint256 const& index)
+    {
+        return MPToken{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/MPTokenIssuance.h

@@ -0,0 +1,484 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class MPTokenIssuanceBuilder;
+
+/**
+ * @brief Ledger Entry: MPTokenIssuance
+ *
+ * Type: ltMPTOKEN_ISSUANCE (0x007e)
+ * RPC Name: mpt_issuance
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use MPTokenIssuanceBuilder to construct new ledger entries.
+ */
+class MPTokenIssuance : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltMPTOKEN_ISSUANCE;
+
+    /**
+     * @brief Construct a MPTokenIssuance ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit MPTokenIssuance(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for MPTokenIssuance");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfIssuer (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getIssuer() const
+    {
+        return this->sle_->at(sfIssuer);
+    }
+
+    /**
+     * @brief Get sfSequence (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getSequence() const
+    {
+        return this->sle_->at(sfSequence);
+    }
+
+    /**
+     * @brief Get sfTransferFee (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT16::type::value_type>
+    getTransferFee() const
+    {
+        if (hasTransferFee())
+            return this->sle_->at(sfTransferFee);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfTransferFee is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasTransferFee() const
+    {
+        return this->sle_->isFieldPresent(sfTransferFee);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfAssetScale (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT8::type::value_type>
+    getAssetScale() const
+    {
+        if (hasAssetScale())
+            return this->sle_->at(sfAssetScale);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfAssetScale is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasAssetScale() const
+    {
+        return this->sle_->isFieldPresent(sfAssetScale);
+    }
+
+    /**
+     * @brief Get sfMaximumAmount (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getMaximumAmount() const
+    {
+        if (hasMaximumAmount())
+            return this->sle_->at(sfMaximumAmount);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfMaximumAmount is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasMaximumAmount() const
+    {
+        return this->sle_->isFieldPresent(sfMaximumAmount);
+    }
+
+    /**
+     * @brief Get sfOutstandingAmount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOutstandingAmount() const
+    {
+        return this->sle_->at(sfOutstandingAmount);
+    }
+
+    /**
+     * @brief Get sfLockedAmount (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getLockedAmount() const
+    {
+        if (hasLockedAmount())
+            return this->sle_->at(sfLockedAmount);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfLockedAmount is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasLockedAmount() const
+    {
+        return this->sle_->isFieldPresent(sfLockedAmount);
+    }
+
+    /**
+     * @brief Get sfMPTokenMetadata (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getMPTokenMetadata() const
+    {
+        if (hasMPTokenMetadata())
+            return this->sle_->at(sfMPTokenMetadata);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfMPTokenMetadata is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasMPTokenMetadata() const
+    {
+        return this->sle_->isFieldPresent(sfMPTokenMetadata);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Get sfDomainID (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getDomainID() const
+    {
+        if (hasDomainID())
+            return this->sle_->at(sfDomainID);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfDomainID is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasDomainID() const
+    {
+        return this->sle_->isFieldPresent(sfDomainID);
+    }
+
+    /**
+     * @brief Get sfMutableFlags (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getMutableFlags() const
+    {
+        if (hasMutableFlags())
+            return this->sle_->at(sfMutableFlags);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfMutableFlags is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasMutableFlags() const
+    {
+        return this->sle_->isFieldPresent(sfMutableFlags);
+    }
+};
+
+/**
+ * @brief Builder for MPTokenIssuance ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class MPTokenIssuanceBuilder : public LedgerEntryBuilderBase<MPTokenIssuanceBuilder>
+{
+public:
+    /**
+     * @brief Construct a new MPTokenIssuanceBuilder with required fields.
+     * @param issuer The sfIssuer field value.
+     * @param sequence The sfSequence field value.
+     * @param ownerNode The sfOwnerNode field value.
+     * @param outstandingAmount The sfOutstandingAmount field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    MPTokenIssuanceBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& issuer,std::decay_t<typename SF_UINT32::type::value_type> const& sequence,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT64::type::value_type> const& outstandingAmount,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<MPTokenIssuanceBuilder>(ltMPTOKEN_ISSUANCE)
+    {
+        setIssuer(issuer);
+        setSequence(sequence);
+        setOwnerNode(ownerNode);
+        setOutstandingAmount(outstandingAmount);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a MPTokenIssuanceBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    MPTokenIssuanceBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltMPTOKEN_ISSUANCE)
+        {
+            throw std::runtime_error("Invalid ledger entry type for MPTokenIssuance");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfIssuer (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenIssuanceBuilder&
+    setIssuer(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfIssuer] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSequence (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenIssuanceBuilder&
+    setSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfSequence] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfTransferFee (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenIssuanceBuilder&
+    setTransferFee(std::decay_t<typename SF_UINT16::type::value_type> const& value)
+    {
+        object_[sfTransferFee] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenIssuanceBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAssetScale (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenIssuanceBuilder&
+    setAssetScale(std::decay_t<typename SF_UINT8::type::value_type> const& value)
+    {
+        object_[sfAssetScale] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfMaximumAmount (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenIssuanceBuilder&
+    setMaximumAmount(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfMaximumAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOutstandingAmount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenIssuanceBuilder&
+    setOutstandingAmount(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOutstandingAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfLockedAmount (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenIssuanceBuilder&
+    setLockedAmount(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfLockedAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfMPTokenMetadata (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenIssuanceBuilder&
+    setMPTokenMetadata(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfMPTokenMetadata] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenIssuanceBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenIssuanceBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDomainID (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenIssuanceBuilder&
+    setDomainID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfDomainID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfMutableFlags (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    MPTokenIssuanceBuilder&
+    setMutableFlags(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfMutableFlags] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed MPTokenIssuance wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    MPTokenIssuance
+    build(uint256 const& index)
+    {
+        return MPTokenIssuance{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/NFTokenOffer.h

@@ -0,0 +1,333 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class NFTokenOfferBuilder;
+
+/**
+ * @brief Ledger Entry: NFTokenOffer
+ *
+ * Type: ltNFTOKEN_OFFER (0x0037)
+ * RPC Name: nft_offer
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use NFTokenOfferBuilder to construct new ledger entries.
+ */
+class NFTokenOffer : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltNFTOKEN_OFFER;
+
+    /**
+     * @brief Construct a NFTokenOffer ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit NFTokenOffer(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for NFTokenOffer");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfOwner (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getOwner() const
+    {
+        return this->sle_->at(sfOwner);
+    }
+
+    /**
+     * @brief Get sfNFTokenID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getNFTokenID() const
+    {
+        return this->sle_->at(sfNFTokenID);
+    }
+
+    /**
+     * @brief Get sfAmount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getAmount() const
+    {
+        return this->sle_->at(sfAmount);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfNFTokenOfferNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getNFTokenOfferNode() const
+    {
+        return this->sle_->at(sfNFTokenOfferNode);
+    }
+
+    /**
+     * @brief Get sfDestination (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getDestination() const
+    {
+        if (hasDestination())
+            return this->sle_->at(sfDestination);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfDestination is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasDestination() const
+    {
+        return this->sle_->isFieldPresent(sfDestination);
+    }
+
+    /**
+     * @brief Get sfExpiration (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getExpiration() const
+    {
+        if (hasExpiration())
+            return this->sle_->at(sfExpiration);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfExpiration is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasExpiration() const
+    {
+        return this->sle_->isFieldPresent(sfExpiration);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * @brief Builder for NFTokenOffer ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class NFTokenOfferBuilder : public LedgerEntryBuilderBase<NFTokenOfferBuilder>
+{
+public:
+    /**
+     * @brief Construct a new NFTokenOfferBuilder with required fields.
+     * @param owner The sfOwner field value.
+     * @param nFTokenID The sfNFTokenID field value.
+     * @param amount The sfAmount field value.
+     * @param ownerNode The sfOwnerNode field value.
+     * @param nFTokenOfferNode The sfNFTokenOfferNode field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    NFTokenOfferBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& owner,std::decay_t<typename SF_UINT256::type::value_type> const& nFTokenID,std::decay_t<typename SF_AMOUNT::type::value_type> const& amount,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT64::type::value_type> const& nFTokenOfferNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<NFTokenOfferBuilder>(ltNFTOKEN_OFFER)
+    {
+        setOwner(owner);
+        setNFTokenID(nFTokenID);
+        setAmount(amount);
+        setOwnerNode(ownerNode);
+        setNFTokenOfferNode(nFTokenOfferNode);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a NFTokenOfferBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    NFTokenOfferBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltNFTOKEN_OFFER)
+        {
+            throw std::runtime_error("Invalid ledger entry type for NFTokenOffer");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfOwner (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    NFTokenOfferBuilder&
+    setOwner(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfOwner] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfNFTokenID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    NFTokenOfferBuilder&
+    setNFTokenID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfNFTokenID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAmount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    NFTokenOfferBuilder&
+    setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    NFTokenOfferBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfNFTokenOfferNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    NFTokenOfferBuilder&
+    setNFTokenOfferNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfNFTokenOfferNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDestination (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    NFTokenOfferBuilder&
+    setDestination(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfDestination] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfExpiration (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    NFTokenOfferBuilder&
+    setExpiration(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfExpiration] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    NFTokenOfferBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    NFTokenOfferBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed NFTokenOffer wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    NFTokenOffer
+    build(uint256 const& index)
+    {
+        return NFTokenOffer{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/NFTokenPage.h

@@ -0,0 +1,238 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class NFTokenPageBuilder;
+
+/**
+ * @brief Ledger Entry: NFTokenPage
+ *
+ * Type: ltNFTOKEN_PAGE (0x0050)
+ * RPC Name: nft_page
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use NFTokenPageBuilder to construct new ledger entries.
+ */
+class NFTokenPage : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltNFTOKEN_PAGE;
+
+    /**
+     * @brief Construct a NFTokenPage ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit NFTokenPage(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for NFTokenPage");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfPreviousPageMin (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getPreviousPageMin() const
+    {
+        if (hasPreviousPageMin())
+            return this->sle_->at(sfPreviousPageMin);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfPreviousPageMin is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasPreviousPageMin() const
+    {
+        return this->sle_->isFieldPresent(sfPreviousPageMin);
+    }
+
+    /**
+     * @brief Get sfNextPageMin (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getNextPageMin() const
+    {
+        if (hasNextPageMin())
+            return this->sle_->at(sfNextPageMin);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfNextPageMin is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasNextPageMin() const
+    {
+        return this->sle_->isFieldPresent(sfNextPageMin);
+    }
+
+    /**
+     * @brief Get sfNFTokens (soeREQUIRED)
+     * @note This is an untyped field (unknown).
+     * @return The field value.
+     */
+    [[nodiscard]]
+    STArray const&
+    getNFTokens() const
+    {
+        return this->sle_->getFieldArray(sfNFTokens);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * @brief Builder for NFTokenPage ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class NFTokenPageBuilder : public LedgerEntryBuilderBase<NFTokenPageBuilder>
+{
+public:
+    /**
+     * @brief Construct a new NFTokenPageBuilder with required fields.
+     * @param nFTokens The sfNFTokens field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    NFTokenPageBuilder(STArray const& nFTokens,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<NFTokenPageBuilder>(ltNFTOKEN_PAGE)
+    {
+        setNFTokens(nFTokens);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a NFTokenPageBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    NFTokenPageBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltNFTOKEN_PAGE)
+        {
+            throw std::runtime_error("Invalid ledger entry type for NFTokenPage");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfPreviousPageMin (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    NFTokenPageBuilder&
+    setPreviousPageMin(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousPageMin] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfNextPageMin (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    NFTokenPageBuilder&
+    setNextPageMin(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfNextPageMin] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfNFTokens (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    NFTokenPageBuilder&
+    setNFTokens(STArray const& value)
+    {
+        object_.setFieldArray(sfNFTokens, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    NFTokenPageBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    NFTokenPageBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed NFTokenPage wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    NFTokenPage
+    build(uint256 const& index)
+    {
+        return NFTokenPage{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/NegativeUNL.h

@@ -0,0 +1,271 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class NegativeUNLBuilder;
+
+/**
+ * @brief Ledger Entry: NegativeUNL
+ *
+ * Type: ltNEGATIVE_UNL (0x004e)
+ * RPC Name: nunl
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use NegativeUNLBuilder to construct new ledger entries.
+ */
+class NegativeUNL : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltNEGATIVE_UNL;
+
+    /**
+     * @brief Construct a NegativeUNL ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit NegativeUNL(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for NegativeUNL");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfDisabledValidators (soeOPTIONAL)
+     * @note This is an untyped field (unknown).
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    std::optional<std::reference_wrapper<STArray const>>
+    getDisabledValidators() const
+    {
+        if (this->sle_->isFieldPresent(sfDisabledValidators))
+            return this->sle_->getFieldArray(sfDisabledValidators);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfDisabledValidators is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasDisabledValidators() const
+    {
+        return this->sle_->isFieldPresent(sfDisabledValidators);
+    }
+
+    /**
+     * @brief Get sfValidatorToDisable (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getValidatorToDisable() const
+    {
+        if (hasValidatorToDisable())
+            return this->sle_->at(sfValidatorToDisable);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfValidatorToDisable is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasValidatorToDisable() const
+    {
+        return this->sle_->isFieldPresent(sfValidatorToDisable);
+    }
+
+    /**
+     * @brief Get sfValidatorToReEnable (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getValidatorToReEnable() const
+    {
+        if (hasValidatorToReEnable())
+            return this->sle_->at(sfValidatorToReEnable);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfValidatorToReEnable is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasValidatorToReEnable() const
+    {
+        return this->sle_->isFieldPresent(sfValidatorToReEnable);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getPreviousTxnID() const
+    {
+        if (hasPreviousTxnID())
+            return this->sle_->at(sfPreviousTxnID);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfPreviousTxnID is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasPreviousTxnID() const
+    {
+        return this->sle_->isFieldPresent(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getPreviousTxnLgrSeq() const
+    {
+        if (hasPreviousTxnLgrSeq())
+            return this->sle_->at(sfPreviousTxnLgrSeq);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfPreviousTxnLgrSeq is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasPreviousTxnLgrSeq() const
+    {
+        return this->sle_->isFieldPresent(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * @brief Builder for NegativeUNL ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class NegativeUNLBuilder : public LedgerEntryBuilderBase<NegativeUNLBuilder>
+{
+public:
+    /**
+     * @brief Construct a new NegativeUNLBuilder with required fields.
+     */
+    NegativeUNLBuilder()
+        : LedgerEntryBuilderBase<NegativeUNLBuilder>(ltNEGATIVE_UNL)
+    {
+    }
+
+    /**
+     * @brief Construct a NegativeUNLBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    NegativeUNLBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltNEGATIVE_UNL)
+        {
+            throw std::runtime_error("Invalid ledger entry type for NegativeUNL");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfDisabledValidators (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    NegativeUNLBuilder&
+    setDisabledValidators(STArray const& value)
+    {
+        object_.setFieldArray(sfDisabledValidators, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfValidatorToDisable (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    NegativeUNLBuilder&
+    setValidatorToDisable(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfValidatorToDisable] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfValidatorToReEnable (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    NegativeUNLBuilder&
+    setValidatorToReEnable(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfValidatorToReEnable] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    NegativeUNLBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    NegativeUNLBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed NegativeUNL wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    NegativeUNL
+    build(uint256 const& index)
+    {
+        return NegativeUNL{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/Offer.h

@@ -0,0 +1,417 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class OfferBuilder;
+
+/**
+ * @brief Ledger Entry: Offer
+ *
+ * Type: ltOFFER (0x006f)
+ * RPC Name: offer
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use OfferBuilder to construct new ledger entries.
+ */
+class Offer : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltOFFER;
+
+    /**
+     * @brief Construct a Offer ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit Offer(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Offer");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfAccount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_->at(sfAccount);
+    }
+
+    /**
+     * @brief Get sfSequence (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getSequence() const
+    {
+        return this->sle_->at(sfSequence);
+    }
+
+    /**
+     * @brief Get sfTakerPays (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getTakerPays() const
+    {
+        return this->sle_->at(sfTakerPays);
+    }
+
+    /**
+     * @brief Get sfTakerGets (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getTakerGets() const
+    {
+        return this->sle_->at(sfTakerGets);
+    }
+
+    /**
+     * @brief Get sfBookDirectory (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getBookDirectory() const
+    {
+        return this->sle_->at(sfBookDirectory);
+    }
+
+    /**
+     * @brief Get sfBookNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getBookNode() const
+    {
+        return this->sle_->at(sfBookNode);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Get sfExpiration (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getExpiration() const
+    {
+        if (hasExpiration())
+            return this->sle_->at(sfExpiration);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfExpiration is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasExpiration() const
+    {
+        return this->sle_->isFieldPresent(sfExpiration);
+    }
+
+    /**
+     * @brief Get sfDomainID (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getDomainID() const
+    {
+        if (hasDomainID())
+            return this->sle_->at(sfDomainID);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfDomainID is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasDomainID() const
+    {
+        return this->sle_->isFieldPresent(sfDomainID);
+    }
+
+    /**
+     * @brief Get sfAdditionalBooks (soeOPTIONAL)
+     * @note This is an untyped field (unknown).
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    std::optional<std::reference_wrapper<STArray const>>
+    getAdditionalBooks() const
+    {
+        if (this->sle_->isFieldPresent(sfAdditionalBooks))
+            return this->sle_->getFieldArray(sfAdditionalBooks);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfAdditionalBooks is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasAdditionalBooks() const
+    {
+        return this->sle_->isFieldPresent(sfAdditionalBooks);
+    }
+};
+
+/**
+ * @brief Builder for Offer ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class OfferBuilder : public LedgerEntryBuilderBase<OfferBuilder>
+{
+public:
+    /**
+     * @brief Construct a new OfferBuilder with required fields.
+     * @param account The sfAccount field value.
+     * @param sequence The sfSequence field value.
+     * @param takerPays The sfTakerPays field value.
+     * @param takerGets The sfTakerGets field value.
+     * @param bookDirectory The sfBookDirectory field value.
+     * @param bookNode The sfBookNode field value.
+     * @param ownerNode The sfOwnerNode field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    OfferBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_UINT32::type::value_type> const& sequence,std::decay_t<typename SF_AMOUNT::type::value_type> const& takerPays,std::decay_t<typename SF_AMOUNT::type::value_type> const& takerGets,std::decay_t<typename SF_UINT256::type::value_type> const& bookDirectory,std::decay_t<typename SF_UINT64::type::value_type> const& bookNode,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<OfferBuilder>(ltOFFER)
+    {
+        setAccount(account);
+        setSequence(sequence);
+        setTakerPays(takerPays);
+        setTakerGets(takerGets);
+        setBookDirectory(bookDirectory);
+        setBookNode(bookNode);
+        setOwnerNode(ownerNode);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a OfferBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    OfferBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltOFFER)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Offer");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfAccount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    OfferBuilder&
+    setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAccount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSequence (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    OfferBuilder&
+    setSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfSequence] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfTakerPays (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    OfferBuilder&
+    setTakerPays(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfTakerPays] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfTakerGets (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    OfferBuilder&
+    setTakerGets(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfTakerGets] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfBookDirectory (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    OfferBuilder&
+    setBookDirectory(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfBookDirectory] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfBookNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    OfferBuilder&
+    setBookNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfBookNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    OfferBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    OfferBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    OfferBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfExpiration (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    OfferBuilder&
+    setExpiration(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfExpiration] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDomainID (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    OfferBuilder&
+    setDomainID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfDomainID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAdditionalBooks (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    OfferBuilder&
+    setAdditionalBooks(STArray const& value)
+    {
+        object_.setFieldArray(sfAdditionalBooks, value);
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed Offer wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    Offer
+    build(uint256 const& index)
+    {
+        return Offer{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/Oracle.h

@@ -0,0 +1,358 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class OracleBuilder;
+
+/**
+ * @brief Ledger Entry: Oracle
+ *
+ * Type: ltORACLE (0x0080)
+ * RPC Name: oracle
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use OracleBuilder to construct new ledger entries.
+ */
+class Oracle : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltORACLE;
+
+    /**
+     * @brief Construct a Oracle ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit Oracle(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Oracle");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfOwner (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getOwner() const
+    {
+        return this->sle_->at(sfOwner);
+    }
+
+    /**
+     * @brief Get sfOracleDocumentID (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getOracleDocumentID() const
+    {
+        if (hasOracleDocumentID())
+            return this->sle_->at(sfOracleDocumentID);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfOracleDocumentID is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasOracleDocumentID() const
+    {
+        return this->sle_->isFieldPresent(sfOracleDocumentID);
+    }
+
+    /**
+     * @brief Get sfProvider (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_VL::type::value_type
+    getProvider() const
+    {
+        return this->sle_->at(sfProvider);
+    }
+
+    /**
+     * @brief Get sfPriceDataSeries (soeREQUIRED)
+     * @note This is an untyped field (unknown).
+     * @return The field value.
+     */
+    [[nodiscard]]
+    STArray const&
+    getPriceDataSeries() const
+    {
+        return this->sle_->getFieldArray(sfPriceDataSeries);
+    }
+
+    /**
+     * @brief Get sfAssetClass (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_VL::type::value_type
+    getAssetClass() const
+    {
+        return this->sle_->at(sfAssetClass);
+    }
+
+    /**
+     * @brief Get sfLastUpdateTime (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getLastUpdateTime() const
+    {
+        return this->sle_->at(sfLastUpdateTime);
+    }
+
+    /**
+     * @brief Get sfURI (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getURI() const
+    {
+        if (hasURI())
+            return this->sle_->at(sfURI);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfURI is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasURI() const
+    {
+        return this->sle_->isFieldPresent(sfURI);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * @brief Builder for Oracle ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class OracleBuilder : public LedgerEntryBuilderBase<OracleBuilder>
+{
+public:
+    /**
+     * @brief Construct a new OracleBuilder with required fields.
+     * @param owner The sfOwner field value.
+     * @param provider The sfProvider field value.
+     * @param priceDataSeries The sfPriceDataSeries field value.
+     * @param assetClass The sfAssetClass field value.
+     * @param lastUpdateTime The sfLastUpdateTime field value.
+     * @param ownerNode The sfOwnerNode field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    OracleBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& owner,std::decay_t<typename SF_VL::type::value_type> const& provider,STArray const& priceDataSeries,std::decay_t<typename SF_VL::type::value_type> const& assetClass,std::decay_t<typename SF_UINT32::type::value_type> const& lastUpdateTime,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<OracleBuilder>(ltORACLE)
+    {
+        setOwner(owner);
+        setProvider(provider);
+        setPriceDataSeries(priceDataSeries);
+        setAssetClass(assetClass);
+        setLastUpdateTime(lastUpdateTime);
+        setOwnerNode(ownerNode);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a OracleBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    OracleBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltORACLE)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Oracle");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfOwner (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    OracleBuilder&
+    setOwner(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfOwner] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOracleDocumentID (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    OracleBuilder&
+    setOracleDocumentID(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfOracleDocumentID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfProvider (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    OracleBuilder&
+    setProvider(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfProvider] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPriceDataSeries (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    OracleBuilder&
+    setPriceDataSeries(STArray const& value)
+    {
+        object_.setFieldArray(sfPriceDataSeries, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAssetClass (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    OracleBuilder&
+    setAssetClass(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfAssetClass] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfLastUpdateTime (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    OracleBuilder&
+    setLastUpdateTime(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfLastUpdateTime] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfURI (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    OracleBuilder&
+    setURI(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfURI] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    OracleBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    OracleBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    OracleBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed Oracle wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    Oracle
+    build(uint256 const& index)
+    {
+        return Oracle{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/PayChannel.h

@@ -0,0 +1,521 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class PayChannelBuilder;
+
+/**
+ * @brief Ledger Entry: PayChannel
+ *
+ * Type: ltPAYCHAN (0x0078)
+ * RPC Name: payment_channel
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use PayChannelBuilder to construct new ledger entries.
+ */
+class PayChannel : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltPAYCHAN;
+
+    /**
+     * @brief Construct a PayChannel ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit PayChannel(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for PayChannel");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfAccount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_->at(sfAccount);
+    }
+
+    /**
+     * @brief Get sfDestination (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getDestination() const
+    {
+        return this->sle_->at(sfDestination);
+    }
+
+    /**
+     * @brief Get sfSequence (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getSequence() const
+    {
+        if (hasSequence())
+            return this->sle_->at(sfSequence);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfSequence is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasSequence() const
+    {
+        return this->sle_->isFieldPresent(sfSequence);
+    }
+
+    /**
+     * @brief Get sfAmount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getAmount() const
+    {
+        return this->sle_->at(sfAmount);
+    }
+
+    /**
+     * @brief Get sfBalance (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getBalance() const
+    {
+        return this->sle_->at(sfBalance);
+    }
+
+    /**
+     * @brief Get sfPublicKey (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_VL::type::value_type
+    getPublicKey() const
+    {
+        return this->sle_->at(sfPublicKey);
+    }
+
+    /**
+     * @brief Get sfSettleDelay (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getSettleDelay() const
+    {
+        return this->sle_->at(sfSettleDelay);
+    }
+
+    /**
+     * @brief Get sfExpiration (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getExpiration() const
+    {
+        if (hasExpiration())
+            return this->sle_->at(sfExpiration);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfExpiration is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasExpiration() const
+    {
+        return this->sle_->isFieldPresent(sfExpiration);
+    }
+
+    /**
+     * @brief Get sfCancelAfter (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getCancelAfter() const
+    {
+        if (hasCancelAfter())
+            return this->sle_->at(sfCancelAfter);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfCancelAfter is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasCancelAfter() const
+    {
+        return this->sle_->isFieldPresent(sfCancelAfter);
+    }
+
+    /**
+     * @brief Get sfSourceTag (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getSourceTag() const
+    {
+        if (hasSourceTag())
+            return this->sle_->at(sfSourceTag);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfSourceTag is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasSourceTag() const
+    {
+        return this->sle_->isFieldPresent(sfSourceTag);
+    }
+
+    /**
+     * @brief Get sfDestinationTag (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getDestinationTag() const
+    {
+        if (hasDestinationTag())
+            return this->sle_->at(sfDestinationTag);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfDestinationTag is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasDestinationTag() const
+    {
+        return this->sle_->isFieldPresent(sfDestinationTag);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Get sfDestinationNode (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getDestinationNode() const
+    {
+        if (hasDestinationNode())
+            return this->sle_->at(sfDestinationNode);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfDestinationNode is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasDestinationNode() const
+    {
+        return this->sle_->isFieldPresent(sfDestinationNode);
+    }
+};
+
+/**
+ * @brief Builder for PayChannel ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class PayChannelBuilder : public LedgerEntryBuilderBase<PayChannelBuilder>
+{
+public:
+    /**
+     * @brief Construct a new PayChannelBuilder with required fields.
+     * @param account The sfAccount field value.
+     * @param destination The sfDestination field value.
+     * @param amount The sfAmount field value.
+     * @param balance The sfBalance field value.
+     * @param publicKey The sfPublicKey field value.
+     * @param settleDelay The sfSettleDelay field value.
+     * @param ownerNode The sfOwnerNode field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    PayChannelBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_ACCOUNT::type::value_type> const& destination,std::decay_t<typename SF_AMOUNT::type::value_type> const& amount,std::decay_t<typename SF_AMOUNT::type::value_type> const& balance,std::decay_t<typename SF_VL::type::value_type> const& publicKey,std::decay_t<typename SF_UINT32::type::value_type> const& settleDelay,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<PayChannelBuilder>(ltPAYCHAN)
+    {
+        setAccount(account);
+        setDestination(destination);
+        setAmount(amount);
+        setBalance(balance);
+        setPublicKey(publicKey);
+        setSettleDelay(settleDelay);
+        setOwnerNode(ownerNode);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a PayChannelBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    PayChannelBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltPAYCHAN)
+        {
+            throw std::runtime_error("Invalid ledger entry type for PayChannel");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfAccount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    PayChannelBuilder&
+    setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAccount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDestination (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    PayChannelBuilder&
+    setDestination(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfDestination] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSequence (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    PayChannelBuilder&
+    setSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfSequence] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAmount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    PayChannelBuilder&
+    setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfBalance (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    PayChannelBuilder&
+    setBalance(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfBalance] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPublicKey (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    PayChannelBuilder&
+    setPublicKey(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfPublicKey] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSettleDelay (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    PayChannelBuilder&
+    setSettleDelay(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfSettleDelay] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfExpiration (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    PayChannelBuilder&
+    setExpiration(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfExpiration] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfCancelAfter (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    PayChannelBuilder&
+    setCancelAfter(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfCancelAfter] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSourceTag (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    PayChannelBuilder&
+    setSourceTag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfSourceTag] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDestinationTag (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    PayChannelBuilder&
+    setDestinationTag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfDestinationTag] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    PayChannelBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    PayChannelBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    PayChannelBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDestinationNode (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    PayChannelBuilder&
+    setDestinationNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfDestinationNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed PayChannel wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    PayChannel
+    build(uint256 const& index)
+    {
+        return PayChannel{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/PermissionedDomain.h

@@ -0,0 +1,240 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class PermissionedDomainBuilder;
+
+/**
+ * @brief Ledger Entry: PermissionedDomain
+ *
+ * Type: ltPERMISSIONED_DOMAIN (0x0082)
+ * RPC Name: permissioned_domain
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use PermissionedDomainBuilder to construct new ledger entries.
+ */
+class PermissionedDomain : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltPERMISSIONED_DOMAIN;
+
+    /**
+     * @brief Construct a PermissionedDomain ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit PermissionedDomain(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for PermissionedDomain");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfOwner (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getOwner() const
+    {
+        return this->sle_->at(sfOwner);
+    }
+
+    /**
+     * @brief Get sfSequence (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getSequence() const
+    {
+        return this->sle_->at(sfSequence);
+    }
+
+    /**
+     * @brief Get sfAcceptedCredentials (soeREQUIRED)
+     * @note This is an untyped field (unknown).
+     * @return The field value.
+     */
+    [[nodiscard]]
+    STArray const&
+    getAcceptedCredentials() const
+    {
+        return this->sle_->getFieldArray(sfAcceptedCredentials);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * @brief Builder for PermissionedDomain ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class PermissionedDomainBuilder : public LedgerEntryBuilderBase<PermissionedDomainBuilder>
+{
+public:
+    /**
+     * @brief Construct a new PermissionedDomainBuilder with required fields.
+     * @param owner The sfOwner field value.
+     * @param sequence The sfSequence field value.
+     * @param acceptedCredentials The sfAcceptedCredentials field value.
+     * @param ownerNode The sfOwnerNode field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    PermissionedDomainBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& owner,std::decay_t<typename SF_UINT32::type::value_type> const& sequence,STArray const& acceptedCredentials,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<PermissionedDomainBuilder>(ltPERMISSIONED_DOMAIN)
+    {
+        setOwner(owner);
+        setSequence(sequence);
+        setAcceptedCredentials(acceptedCredentials);
+        setOwnerNode(ownerNode);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a PermissionedDomainBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    PermissionedDomainBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltPERMISSIONED_DOMAIN)
+        {
+            throw std::runtime_error("Invalid ledger entry type for PermissionedDomain");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfOwner (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    PermissionedDomainBuilder&
+    setOwner(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfOwner] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSequence (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    PermissionedDomainBuilder&
+    setSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfSequence] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAcceptedCredentials (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    PermissionedDomainBuilder&
+    setAcceptedCredentials(STArray const& value)
+    {
+        object_.setFieldArray(sfAcceptedCredentials, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    PermissionedDomainBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    PermissionedDomainBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    PermissionedDomainBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed PermissionedDomain wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    PermissionedDomain
+    build(uint256 const& index)
+    {
+        return PermissionedDomain{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/RippleState.h

@@ -0,0 +1,425 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class RippleStateBuilder;
+
+/**
+ * @brief Ledger Entry: RippleState
+ *
+ * Type: ltRIPPLE_STATE (0x0072)
+ * RPC Name: state
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use RippleStateBuilder to construct new ledger entries.
+ */
+class RippleState : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltRIPPLE_STATE;
+
+    /**
+     * @brief Construct a RippleState ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit RippleState(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for RippleState");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfBalance (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getBalance() const
+    {
+        return this->sle_->at(sfBalance);
+    }
+
+    /**
+     * @brief Get sfLowLimit (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getLowLimit() const
+    {
+        return this->sle_->at(sfLowLimit);
+    }
+
+    /**
+     * @brief Get sfHighLimit (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getHighLimit() const
+    {
+        return this->sle_->at(sfHighLimit);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Get sfLowNode (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getLowNode() const
+    {
+        if (hasLowNode())
+            return this->sle_->at(sfLowNode);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfLowNode is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasLowNode() const
+    {
+        return this->sle_->isFieldPresent(sfLowNode);
+    }
+
+    /**
+     * @brief Get sfLowQualityIn (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getLowQualityIn() const
+    {
+        if (hasLowQualityIn())
+            return this->sle_->at(sfLowQualityIn);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfLowQualityIn is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasLowQualityIn() const
+    {
+        return this->sle_->isFieldPresent(sfLowQualityIn);
+    }
+
+    /**
+     * @brief Get sfLowQualityOut (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getLowQualityOut() const
+    {
+        if (hasLowQualityOut())
+            return this->sle_->at(sfLowQualityOut);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfLowQualityOut is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasLowQualityOut() const
+    {
+        return this->sle_->isFieldPresent(sfLowQualityOut);
+    }
+
+    /**
+     * @brief Get sfHighNode (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getHighNode() const
+    {
+        if (hasHighNode())
+            return this->sle_->at(sfHighNode);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfHighNode is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasHighNode() const
+    {
+        return this->sle_->isFieldPresent(sfHighNode);
+    }
+
+    /**
+     * @brief Get sfHighQualityIn (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getHighQualityIn() const
+    {
+        if (hasHighQualityIn())
+            return this->sle_->at(sfHighQualityIn);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfHighQualityIn is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasHighQualityIn() const
+    {
+        return this->sle_->isFieldPresent(sfHighQualityIn);
+    }
+
+    /**
+     * @brief Get sfHighQualityOut (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getHighQualityOut() const
+    {
+        if (hasHighQualityOut())
+            return this->sle_->at(sfHighQualityOut);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfHighQualityOut is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasHighQualityOut() const
+    {
+        return this->sle_->isFieldPresent(sfHighQualityOut);
+    }
+};
+
+/**
+ * @brief Builder for RippleState ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class RippleStateBuilder : public LedgerEntryBuilderBase<RippleStateBuilder>
+{
+public:
+    /**
+     * @brief Construct a new RippleStateBuilder with required fields.
+     * @param balance The sfBalance field value.
+     * @param lowLimit The sfLowLimit field value.
+     * @param highLimit The sfHighLimit field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    RippleStateBuilder(std::decay_t<typename SF_AMOUNT::type::value_type> const& balance,std::decay_t<typename SF_AMOUNT::type::value_type> const& lowLimit,std::decay_t<typename SF_AMOUNT::type::value_type> const& highLimit,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<RippleStateBuilder>(ltRIPPLE_STATE)
+    {
+        setBalance(balance);
+        setLowLimit(lowLimit);
+        setHighLimit(highLimit);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a RippleStateBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    RippleStateBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltRIPPLE_STATE)
+        {
+            throw std::runtime_error("Invalid ledger entry type for RippleState");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfBalance (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    RippleStateBuilder&
+    setBalance(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfBalance] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfLowLimit (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    RippleStateBuilder&
+    setLowLimit(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfLowLimit] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfHighLimit (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    RippleStateBuilder&
+    setHighLimit(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfHighLimit] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    RippleStateBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    RippleStateBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfLowNode (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    RippleStateBuilder&
+    setLowNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfLowNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfLowQualityIn (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    RippleStateBuilder&
+    setLowQualityIn(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfLowQualityIn] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfLowQualityOut (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    RippleStateBuilder&
+    setLowQualityOut(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfLowQualityOut] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfHighNode (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    RippleStateBuilder&
+    setHighNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfHighNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfHighQualityIn (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    RippleStateBuilder&
+    setHighQualityIn(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfHighQualityIn] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfHighQualityOut (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    RippleStateBuilder&
+    setHighQualityOut(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfHighQualityOut] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed RippleState wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    RippleState
+    build(uint256 const& index)
+    {
+        return RippleState{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/SignerList.h

@@ -0,0 +1,275 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class SignerListBuilder;
+
+/**
+ * @brief Ledger Entry: SignerList
+ *
+ * Type: ltSIGNER_LIST (0x0053)
+ * RPC Name: signer_list
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use SignerListBuilder to construct new ledger entries.
+ */
+class SignerList : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltSIGNER_LIST;
+
+    /**
+     * @brief Construct a SignerList ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit SignerList(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for SignerList");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfOwner (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getOwner() const
+    {
+        if (hasOwner())
+            return this->sle_->at(sfOwner);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfOwner is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasOwner() const
+    {
+        return this->sle_->isFieldPresent(sfOwner);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfSignerQuorum (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getSignerQuorum() const
+    {
+        return this->sle_->at(sfSignerQuorum);
+    }
+
+    /**
+     * @brief Get sfSignerEntries (soeREQUIRED)
+     * @note This is an untyped field (unknown).
+     * @return The field value.
+     */
+    [[nodiscard]]
+    STArray const&
+    getSignerEntries() const
+    {
+        return this->sle_->getFieldArray(sfSignerEntries);
+    }
+
+    /**
+     * @brief Get sfSignerListID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getSignerListID() const
+    {
+        return this->sle_->at(sfSignerListID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * @brief Builder for SignerList ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class SignerListBuilder : public LedgerEntryBuilderBase<SignerListBuilder>
+{
+public:
+    /**
+     * @brief Construct a new SignerListBuilder with required fields.
+     * @param ownerNode The sfOwnerNode field value.
+     * @param signerQuorum The sfSignerQuorum field value.
+     * @param signerEntries The sfSignerEntries field value.
+     * @param signerListID The sfSignerListID field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    SignerListBuilder(std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT32::type::value_type> const& signerQuorum,STArray const& signerEntries,std::decay_t<typename SF_UINT32::type::value_type> const& signerListID,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<SignerListBuilder>(ltSIGNER_LIST)
+    {
+        setOwnerNode(ownerNode);
+        setSignerQuorum(signerQuorum);
+        setSignerEntries(signerEntries);
+        setSignerListID(signerListID);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a SignerListBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    SignerListBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltSIGNER_LIST)
+        {
+            throw std::runtime_error("Invalid ledger entry type for SignerList");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfOwner (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    SignerListBuilder&
+    setOwner(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfOwner] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    SignerListBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSignerQuorum (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    SignerListBuilder&
+    setSignerQuorum(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfSignerQuorum] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSignerEntries (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    SignerListBuilder&
+    setSignerEntries(STArray const& value)
+    {
+        object_.setFieldArray(sfSignerEntries, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSignerListID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    SignerListBuilder&
+    setSignerListID(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfSignerListID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    SignerListBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    SignerListBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed SignerList wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    SignerList
+    build(uint256 const& index)
+    {
+        return SignerList{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/Ticket.h

@@ -0,0 +1,215 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class TicketBuilder;
+
+/**
+ * @brief Ledger Entry: Ticket
+ *
+ * Type: ltTICKET (0x0054)
+ * RPC Name: ticket
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use TicketBuilder to construct new ledger entries.
+ */
+class Ticket : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltTICKET;
+
+    /**
+     * @brief Construct a Ticket ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit Ticket(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Ticket");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfAccount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_->at(sfAccount);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfTicketSequence (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getTicketSequence() const
+    {
+        return this->sle_->at(sfTicketSequence);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * @brief Builder for Ticket ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class TicketBuilder : public LedgerEntryBuilderBase<TicketBuilder>
+{
+public:
+    /**
+     * @brief Construct a new TicketBuilder with required fields.
+     * @param account The sfAccount field value.
+     * @param ownerNode The sfOwnerNode field value.
+     * @param ticketSequence The sfTicketSequence field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    TicketBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT32::type::value_type> const& ticketSequence,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<TicketBuilder>(ltTICKET)
+    {
+        setAccount(account);
+        setOwnerNode(ownerNode);
+        setTicketSequence(ticketSequence);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a TicketBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    TicketBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltTICKET)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Ticket");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfAccount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    TicketBuilder&
+    setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAccount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    TicketBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfTicketSequence (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    TicketBuilder&
+    setTicketSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfTicketSequence] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    TicketBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    TicketBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed Ticket wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    Ticket
+    build(uint256 const& index)
+    {
+        return Ticket{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/Vault.h

@@ -0,0 +1,521 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class VaultBuilder;
+
+/**
+ * @brief Ledger Entry: Vault
+ *
+ * Type: ltVAULT (0x0084)
+ * RPC Name: vault
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use VaultBuilder to construct new ledger entries.
+ */
+class Vault : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltVAULT;
+
+    /**
+     * @brief Construct a Vault ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit Vault(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Vault");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Get sfSequence (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getSequence() const
+    {
+        return this->sle_->at(sfSequence);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfOwner (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getOwner() const
+    {
+        return this->sle_->at(sfOwner);
+    }
+
+    /**
+     * @brief Get sfAccount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_->at(sfAccount);
+    }
+
+    /**
+     * @brief Get sfData (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getData() const
+    {
+        if (hasData())
+            return this->sle_->at(sfData);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfData is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasData() const
+    {
+        return this->sle_->isFieldPresent(sfData);
+    }
+
+    /**
+     * @brief Get sfAsset (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset() const
+    {
+        return this->sle_->at(sfAsset);
+    }
+
+    /**
+     * @brief Get sfAssetsTotal (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getAssetsTotal() const
+    {
+        if (hasAssetsTotal())
+            return this->sle_->at(sfAssetsTotal);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfAssetsTotal is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasAssetsTotal() const
+    {
+        return this->sle_->isFieldPresent(sfAssetsTotal);
+    }
+
+    /**
+     * @brief Get sfAssetsAvailable (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getAssetsAvailable() const
+    {
+        if (hasAssetsAvailable())
+            return this->sle_->at(sfAssetsAvailable);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfAssetsAvailable is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasAssetsAvailable() const
+    {
+        return this->sle_->isFieldPresent(sfAssetsAvailable);
+    }
+
+    /**
+     * @brief Get sfAssetsMaximum (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getAssetsMaximum() const
+    {
+        if (hasAssetsMaximum())
+            return this->sle_->at(sfAssetsMaximum);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfAssetsMaximum is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasAssetsMaximum() const
+    {
+        return this->sle_->isFieldPresent(sfAssetsMaximum);
+    }
+
+    /**
+     * @brief Get sfLossUnrealized (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getLossUnrealized() const
+    {
+        if (hasLossUnrealized())
+            return this->sle_->at(sfLossUnrealized);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfLossUnrealized is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasLossUnrealized() const
+    {
+        return this->sle_->isFieldPresent(sfLossUnrealized);
+    }
+
+    /**
+     * @brief Get sfShareMPTID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT192::type::value_type
+    getShareMPTID() const
+    {
+        return this->sle_->at(sfShareMPTID);
+    }
+
+    /**
+     * @brief Get sfWithdrawalPolicy (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT8::type::value_type
+    getWithdrawalPolicy() const
+    {
+        return this->sle_->at(sfWithdrawalPolicy);
+    }
+
+    /**
+     * @brief Get sfScale (soeDEFAULT)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT8::type::value_type>
+    getScale() const
+    {
+        if (hasScale())
+            return this->sle_->at(sfScale);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfScale is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasScale() const
+    {
+        return this->sle_->isFieldPresent(sfScale);
+    }
+};
+
+/**
+ * @brief Builder for Vault ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class VaultBuilder : public LedgerEntryBuilderBase<VaultBuilder>
+{
+public:
+    /**
+     * @brief Construct a new VaultBuilder with required fields.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     * @param sequence The sfSequence field value.
+     * @param ownerNode The sfOwnerNode field value.
+     * @param owner The sfOwner field value.
+     * @param account The sfAccount field value.
+     * @param asset The sfAsset field value.
+     * @param shareMPTID The sfShareMPTID field value.
+     * @param withdrawalPolicy The sfWithdrawalPolicy field value.
+     */
+    VaultBuilder(std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq,std::decay_t<typename SF_UINT32::type::value_type> const& sequence,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_ACCOUNT::type::value_type> const& owner,std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_ISSUE::type::value_type> const& asset,std::decay_t<typename SF_UINT192::type::value_type> const& shareMPTID,std::decay_t<typename SF_UINT8::type::value_type> const& withdrawalPolicy)
+        : LedgerEntryBuilderBase<VaultBuilder>(ltVAULT)
+    {
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+        setSequence(sequence);
+        setOwnerNode(ownerNode);
+        setOwner(owner);
+        setAccount(account);
+        setAsset(asset);
+        setShareMPTID(shareMPTID);
+        setWithdrawalPolicy(withdrawalPolicy);
+    }
+
+    /**
+     * @brief Construct a VaultBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    VaultBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltVAULT)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Vault");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    VaultBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    VaultBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSequence (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    VaultBuilder&
+    setSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfSequence] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    VaultBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwner (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    VaultBuilder&
+    setOwner(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfOwner] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAccount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    VaultBuilder&
+    setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAccount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfData (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    VaultBuilder&
+    setData(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfData] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAsset (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    VaultBuilder&
+    setAsset(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
+    {
+        object_[sfAsset] = STIssue(sfAsset, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAssetsTotal (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    VaultBuilder&
+    setAssetsTotal(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
+    {
+        object_[sfAssetsTotal] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAssetsAvailable (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    VaultBuilder&
+    setAssetsAvailable(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
+    {
+        object_[sfAssetsAvailable] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAssetsMaximum (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    VaultBuilder&
+    setAssetsMaximum(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
+    {
+        object_[sfAssetsMaximum] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfLossUnrealized (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    VaultBuilder&
+    setLossUnrealized(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
+    {
+        object_[sfLossUnrealized] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfShareMPTID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    VaultBuilder&
+    setShareMPTID(std::decay_t<typename SF_UINT192::type::value_type> const& value)
+    {
+        object_[sfShareMPTID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfWithdrawalPolicy (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    VaultBuilder&
+    setWithdrawalPolicy(std::decay_t<typename SF_UINT8::type::value_type> const& value)
+    {
+        object_[sfWithdrawalPolicy] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfScale (soeDEFAULT)
+     * @return Reference to this builder for method chaining.
+     */
+    VaultBuilder&
+    setScale(std::decay_t<typename SF_UINT8::type::value_type> const& value)
+    {
+        object_[sfScale] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed Vault wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    Vault
+    build(uint256 const& index)
+    {
+        return Vault{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/XChainOwnedClaimID.h

@@ -0,0 +1,312 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class XChainOwnedClaimIDBuilder;
+
+/**
+ * @brief Ledger Entry: XChainOwnedClaimID
+ *
+ * Type: ltXCHAIN_OWNED_CLAIM_ID (0x0071)
+ * RPC Name: xchain_owned_claim_id
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use XChainOwnedClaimIDBuilder to construct new ledger entries.
+ */
+class XChainOwnedClaimID : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltXCHAIN_OWNED_CLAIM_ID;
+
+    /**
+     * @brief Construct a XChainOwnedClaimID ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit XChainOwnedClaimID(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for XChainOwnedClaimID");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfAccount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_->at(sfAccount);
+    }
+
+    /**
+     * @brief Get sfXChainBridge (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_XCHAIN_BRIDGE::type::value_type
+    getXChainBridge() const
+    {
+        return this->sle_->at(sfXChainBridge);
+    }
+
+    /**
+     * @brief Get sfXChainClaimID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getXChainClaimID() const
+    {
+        return this->sle_->at(sfXChainClaimID);
+    }
+
+    /**
+     * @brief Get sfOtherChainSource (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getOtherChainSource() const
+    {
+        return this->sle_->at(sfOtherChainSource);
+    }
+
+    /**
+     * @brief Get sfXChainClaimAttestations (soeREQUIRED)
+     * @note This is an untyped field (unknown).
+     * @return The field value.
+     */
+    [[nodiscard]]
+    STArray const&
+    getXChainClaimAttestations() const
+    {
+        return this->sle_->getFieldArray(sfXChainClaimAttestations);
+    }
+
+    /**
+     * @brief Get sfSignatureReward (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getSignatureReward() const
+    {
+        return this->sle_->at(sfSignatureReward);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * @brief Builder for XChainOwnedClaimID ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class XChainOwnedClaimIDBuilder : public LedgerEntryBuilderBase<XChainOwnedClaimIDBuilder>
+{
+public:
+    /**
+     * @brief Construct a new XChainOwnedClaimIDBuilder with required fields.
+     * @param account The sfAccount field value.
+     * @param xChainBridge The sfXChainBridge field value.
+     * @param xChainClaimID The sfXChainClaimID field value.
+     * @param otherChainSource The sfOtherChainSource field value.
+     * @param xChainClaimAttestations The sfXChainClaimAttestations field value.
+     * @param signatureReward The sfSignatureReward field value.
+     * @param ownerNode The sfOwnerNode field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    XChainOwnedClaimIDBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& xChainBridge,std::decay_t<typename SF_UINT64::type::value_type> const& xChainClaimID,std::decay_t<typename SF_ACCOUNT::type::value_type> const& otherChainSource,STArray const& xChainClaimAttestations,std::decay_t<typename SF_AMOUNT::type::value_type> const& signatureReward,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<XChainOwnedClaimIDBuilder>(ltXCHAIN_OWNED_CLAIM_ID)
+    {
+        setAccount(account);
+        setXChainBridge(xChainBridge);
+        setXChainClaimID(xChainClaimID);
+        setOtherChainSource(otherChainSource);
+        setXChainClaimAttestations(xChainClaimAttestations);
+        setSignatureReward(signatureReward);
+        setOwnerNode(ownerNode);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a XChainOwnedClaimIDBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    XChainOwnedClaimIDBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltXCHAIN_OWNED_CLAIM_ID)
+        {
+            throw std::runtime_error("Invalid ledger entry type for XChainOwnedClaimID");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfAccount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedClaimIDBuilder&
+    setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAccount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainBridge (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedClaimIDBuilder&
+    setXChainBridge(std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& value)
+    {
+        object_[sfXChainBridge] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainClaimID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedClaimIDBuilder&
+    setXChainClaimID(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfXChainClaimID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOtherChainSource (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedClaimIDBuilder&
+    setOtherChainSource(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfOtherChainSource] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainClaimAttestations (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedClaimIDBuilder&
+    setXChainClaimAttestations(STArray const& value)
+    {
+        object_.setFieldArray(sfXChainClaimAttestations, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSignatureReward (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedClaimIDBuilder&
+    setSignatureReward(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfSignatureReward] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedClaimIDBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedClaimIDBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedClaimIDBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed XChainOwnedClaimID wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    XChainOwnedClaimID
+    build(uint256 const& index)
+    {
+        return XChainOwnedClaimID{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_entries/XChainOwnedCreateAccountClaimID.h

@@ -0,0 +1,264 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+class XChainOwnedCreateAccountClaimIDBuilder;
+
+/**
+ * @brief Ledger Entry: XChainOwnedCreateAccountClaimID
+ *
+ * Type: ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID (0x0074)
+ * RPC Name: xchain_owned_create_account_claim_id
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use XChainOwnedCreateAccountClaimIDBuilder to construct new ledger entries.
+ */
+class XChainOwnedCreateAccountClaimID : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID;
+
+    /**
+     * @brief Construct a XChainOwnedCreateAccountClaimID ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit XChainOwnedCreateAccountClaimID(std::shared_ptr<SLE const> sle)
+        : LedgerEntryBase(std::move(sle))
+    {
+        // Verify ledger entry type
+        if (sle_->getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for XChainOwnedCreateAccountClaimID");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * @brief Get sfAccount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_->at(sfAccount);
+    }
+
+    /**
+     * @brief Get sfXChainBridge (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_XCHAIN_BRIDGE::type::value_type
+    getXChainBridge() const
+    {
+        return this->sle_->at(sfXChainBridge);
+    }
+
+    /**
+     * @brief Get sfXChainAccountCreateCount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getXChainAccountCreateCount() const
+    {
+        return this->sle_->at(sfXChainAccountCreateCount);
+    }
+
+    /**
+     * @brief Get sfXChainCreateAccountAttestations (soeREQUIRED)
+     * @note This is an untyped field (unknown).
+     * @return The field value.
+     */
+    [[nodiscard]]
+    STArray const&
+    getXChainCreateAccountAttestations() const
+    {
+        return this->sle_->getFieldArray(sfXChainCreateAccountAttestations);
+    }
+
+    /**
+     * @brief Get sfOwnerNode (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_->at(sfOwnerNode);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_->at(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_->at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * @brief Builder for XChainOwnedCreateAccountClaimID ledger entries.
+ *
+ * Provides a fluent interface for constructing ledger entries with method chaining.
+ * Uses Json::Value internally for flexible ledger entry construction.
+ * Inherits common field setters from LedgerEntryBuilderBase.
+ */
+class XChainOwnedCreateAccountClaimIDBuilder : public LedgerEntryBuilderBase<XChainOwnedCreateAccountClaimIDBuilder>
+{
+public:
+    /**
+     * @brief Construct a new XChainOwnedCreateAccountClaimIDBuilder with required fields.
+     * @param account The sfAccount field value.
+     * @param xChainBridge The sfXChainBridge field value.
+     * @param xChainAccountCreateCount The sfXChainAccountCreateCount field value.
+     * @param xChainCreateAccountAttestations The sfXChainCreateAccountAttestations field value.
+     * @param ownerNode The sfOwnerNode field value.
+     * @param previousTxnID The sfPreviousTxnID field value.
+     * @param previousTxnLgrSeq The sfPreviousTxnLgrSeq field value.
+     */
+    XChainOwnedCreateAccountClaimIDBuilder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& account,std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& xChainBridge,std::decay_t<typename SF_UINT64::type::value_type> const& xChainAccountCreateCount,STArray const& xChainCreateAccountAttestations,std::decay_t<typename SF_UINT64::type::value_type> const& ownerNode,std::decay_t<typename SF_UINT256::type::value_type> const& previousTxnID,std::decay_t<typename SF_UINT32::type::value_type> const& previousTxnLgrSeq)
+        : LedgerEntryBuilderBase<XChainOwnedCreateAccountClaimIDBuilder>(ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID)
+    {
+        setAccount(account);
+        setXChainBridge(xChainBridge);
+        setXChainAccountCreateCount(xChainAccountCreateCount);
+        setXChainCreateAccountAttestations(xChainCreateAccountAttestations);
+        setOwnerNode(ownerNode);
+        setPreviousTxnID(previousTxnID);
+        setPreviousTxnLgrSeq(previousTxnLgrSeq);
+    }
+
+    /**
+     * @brief Construct a XChainOwnedCreateAccountClaimIDBuilder from an existing SLE object.
+     * @param sle The existing ledger entry to copy from.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    XChainOwnedCreateAccountClaimIDBuilder(std::shared_ptr<SLE const> sle)
+    {
+        if (sle->at(sfLedgerEntryType) != ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID)
+        {
+            throw std::runtime_error("Invalid ledger entry type for XChainOwnedCreateAccountClaimID");
+        }
+        object_ = *sle;
+    }
+
+    /** @brief Ledger entry-specific field setters */
+
+    /**
+     * @brief Set sfAccount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedCreateAccountClaimIDBuilder&
+    setAccount(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAccount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainBridge (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedCreateAccountClaimIDBuilder&
+    setXChainBridge(std::decay_t<typename SF_XCHAIN_BRIDGE::type::value_type> const& value)
+    {
+        object_[sfXChainBridge] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainAccountCreateCount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedCreateAccountClaimIDBuilder&
+    setXChainAccountCreateCount(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfXChainAccountCreateCount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfXChainCreateAccountAttestations (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedCreateAccountClaimIDBuilder&
+    setXChainCreateAccountAttestations(STArray const& value)
+    {
+        object_.setFieldArray(sfXChainCreateAccountAttestations, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfOwnerNode (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedCreateAccountClaimIDBuilder&
+    setOwnerNode(std::decay_t<typename SF_UINT64::type::value_type> const& value)
+    {
+        object_[sfOwnerNode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedCreateAccountClaimIDBuilder&
+    setPreviousTxnID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfPreviousTxnLgrSeq (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedCreateAccountClaimIDBuilder&
+    setPreviousTxnLgrSeq(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfPreviousTxnLgrSeq] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the completed XChainOwnedCreateAccountClaimID wrapper.
+     * @param index The ledger entry index.
+     * @return The constructed ledger entry wrapper.
+     */
+    XChainOwnedCreateAccountClaimID
+    build(uint256 const& index)
+    {
+        return XChainOwnedCreateAccountClaimID{std::make_shared<SLE>(std::move(object_), index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/transactions/AMMBid.h

@@ -0,0 +1,262 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class AMMBidBuilder;
+
+/**
+ * @brief Transaction: AMMBid
+ *
+ * Type: ttAMM_BID (39)
+ * Delegable: Delegation::delegable
+ * Amendment: featureAMM
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use AMMBidBuilder to construct new transactions.
+ */
+class AMMBid : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttAMM_BID;
+
+    /**
+     * @brief Construct a AMMBid transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit AMMBid(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMBid");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfAsset (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset() const
+    {
+        return this->tx_->at(sfAsset);
+    }
+
+    /**
+     * @brief Get sfAsset2 (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset2() const
+    {
+        return this->tx_->at(sfAsset2);
+    }
+
+    /**
+     * @brief Get sfBidMin (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getBidMin() const
+    {
+        if (hasBidMin())
+        {
+            return this->tx_->at(sfBidMin);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfBidMin is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasBidMin() const
+    {
+        return this->tx_->isFieldPresent(sfBidMin);
+    }
+
+    /**
+     * @brief Get sfBidMax (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getBidMax() const
+    {
+        if (hasBidMax())
+        {
+            return this->tx_->at(sfBidMax);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfBidMax is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasBidMax() const
+    {
+        return this->tx_->isFieldPresent(sfBidMax);
+    }
+    /**
+     * @brief Get sfAuthAccounts (soeOPTIONAL)
+     * @note This is an untyped field.
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    std::optional<std::reference_wrapper<STArray const>>
+    getAuthAccounts() const
+    {
+        if (this->tx_->isFieldPresent(sfAuthAccounts))
+            return this->tx_->getFieldArray(sfAuthAccounts);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfAuthAccounts is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasAuthAccounts() const
+    {
+        return this->tx_->isFieldPresent(sfAuthAccounts);
+    }
+};
+
+/**
+ * @brief Builder for AMMBid transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses Json::Value internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class AMMBidBuilder : public TransactionBuilderBase<AMMBidBuilder>
+{
+public:
+    /**
+     * @brief Construct a new AMMBidBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param asset The sfAsset field value.
+     * @param asset2 The sfAsset2 field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    AMMBidBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_ISSUE::type::value_type> const& asset,                     std::decay_t<typename SF_ISSUE::type::value_type> const& asset2,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<AMMBidBuilder>(ttAMM_BID, account, sequence, fee)
+    {
+        setAsset(asset);
+        setAsset2(asset2);
+    }
+
+    /**
+     * @brief Construct a AMMBidBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    AMMBidBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttAMM_BID)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMBidBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /** @brief Transaction-specific field setters */
+
+    /**
+     * @brief Set sfAsset (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMBidBuilder&
+    setAsset(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
+    {
+        object_[sfAsset] = STIssue(sfAsset, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAsset2 (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMBidBuilder&
+    setAsset2(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
+    {
+        object_[sfAsset2] = STIssue(sfAsset2, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfBidMin (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMBidBuilder&
+    setBidMin(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfBidMin] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfBidMax (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMBidBuilder&
+    setBidMax(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfBidMax] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAuthAccounts (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMBidBuilder&
+    setAuthAccounts(STArray const& value)
+    {
+        object_.setFieldArray(sfAuthAccounts, value);
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the AMMBid wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    AMMBid
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return AMMBid{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/AMMClawback.h

@@ -0,0 +1,214 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class AMMClawbackBuilder;
+
+/**
+ * @brief Transaction: AMMClawback
+ *
+ * Type: ttAMM_CLAWBACK (31)
+ * Delegable: Delegation::delegable
+ * Amendment: featureAMMClawback
+ * Privileges: mayDeleteAcct | overrideFreeze
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use AMMClawbackBuilder to construct new transactions.
+ */
+class AMMClawback : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttAMM_CLAWBACK;
+
+    /**
+     * @brief Construct a AMMClawback transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit AMMClawback(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMClawback");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfHolder (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getHolder() const
+    {
+        return this->tx_->at(sfHolder);
+    }
+
+    /**
+     * @brief Get sfAsset (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset() const
+    {
+        return this->tx_->at(sfAsset);
+    }
+
+    /**
+     * @brief Get sfAsset2 (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset2() const
+    {
+        return this->tx_->at(sfAsset2);
+    }
+
+    /**
+     * @brief Get sfAmount (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getAmount() const
+    {
+        if (hasAmount())
+        {
+            return this->tx_->at(sfAmount);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfAmount is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasAmount() const
+    {
+        return this->tx_->isFieldPresent(sfAmount);
+    }
+};
+
+/**
+ * @brief Builder for AMMClawback transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses Json::Value internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class AMMClawbackBuilder : public TransactionBuilderBase<AMMClawbackBuilder>
+{
+public:
+    /**
+     * @brief Construct a new AMMClawbackBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param holder The sfHolder field value.
+     * @param asset The sfAsset field value.
+     * @param asset2 The sfAsset2 field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    AMMClawbackBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_ACCOUNT::type::value_type> const& holder,                     std::decay_t<typename SF_ISSUE::type::value_type> const& asset,                     std::decay_t<typename SF_ISSUE::type::value_type> const& asset2,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<AMMClawbackBuilder>(ttAMM_CLAWBACK, account, sequence, fee)
+    {
+        setHolder(holder);
+        setAsset(asset);
+        setAsset2(asset2);
+    }
+
+    /**
+     * @brief Construct a AMMClawbackBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    AMMClawbackBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttAMM_CLAWBACK)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMClawbackBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /** @brief Transaction-specific field setters */
+
+    /**
+     * @brief Set sfHolder (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMClawbackBuilder&
+    setHolder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfHolder] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAsset (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMClawbackBuilder&
+    setAsset(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
+    {
+        object_[sfAsset] = STIssue(sfAsset, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAsset2 (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMClawbackBuilder&
+    setAsset2(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
+    {
+        object_[sfAsset2] = STIssue(sfAsset2, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAmount (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMClawbackBuilder&
+    setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the AMMClawback wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    AMMClawback
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return AMMClawback{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/AMMCreate.h

@@ -0,0 +1,177 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class AMMCreateBuilder;
+
+/**
+ * @brief Transaction: AMMCreate
+ *
+ * Type: ttAMM_CREATE (35)
+ * Delegable: Delegation::delegable
+ * Amendment: featureAMM
+ * Privileges: createPseudoAcct
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use AMMCreateBuilder to construct new transactions.
+ */
+class AMMCreate : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttAMM_CREATE;
+
+    /**
+     * @brief Construct a AMMCreate transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit AMMCreate(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMCreate");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfAmount (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getAmount() const
+    {
+        return this->tx_->at(sfAmount);
+    }
+
+    /**
+     * @brief Get sfAmount2 (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getAmount2() const
+    {
+        return this->tx_->at(sfAmount2);
+    }
+
+    /**
+     * @brief Get sfTradingFee (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT16::type::value_type
+    getTradingFee() const
+    {
+        return this->tx_->at(sfTradingFee);
+    }
+};
+
+/**
+ * @brief Builder for AMMCreate transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses Json::Value internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class AMMCreateBuilder : public TransactionBuilderBase<AMMCreateBuilder>
+{
+public:
+    /**
+     * @brief Construct a new AMMCreateBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param amount The sfAmount field value.
+     * @param amount2 The sfAmount2 field value.
+     * @param tradingFee The sfTradingFee field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    AMMCreateBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_AMOUNT::type::value_type> const& amount,                     std::decay_t<typename SF_AMOUNT::type::value_type> const& amount2,                     std::decay_t<typename SF_UINT16::type::value_type> const& tradingFee,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<AMMCreateBuilder>(ttAMM_CREATE, account, sequence, fee)
+    {
+        setAmount(amount);
+        setAmount2(amount2);
+        setTradingFee(tradingFee);
+    }
+
+    /**
+     * @brief Construct a AMMCreateBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    AMMCreateBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttAMM_CREATE)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMCreateBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /** @brief Transaction-specific field setters */
+
+    /**
+     * @brief Set sfAmount (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMCreateBuilder&
+    setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAmount2 (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMCreateBuilder&
+    setAmount2(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfAmount2] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfTradingFee (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMCreateBuilder&
+    setTradingFee(std::decay_t<typename SF_UINT16::type::value_type> const& value)
+    {
+        object_[sfTradingFee] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the AMMCreate wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    AMMCreate
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return AMMCreate{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/AMMDelete.h

@@ -0,0 +1,153 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class AMMDeleteBuilder;
+
+/**
+ * @brief Transaction: AMMDelete
+ *
+ * Type: ttAMM_DELETE (40)
+ * Delegable: Delegation::delegable
+ * Amendment: featureAMM
+ * Privileges: mustDeleteAcct
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use AMMDeleteBuilder to construct new transactions.
+ */
+class AMMDelete : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttAMM_DELETE;
+
+    /**
+     * @brief Construct a AMMDelete transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit AMMDelete(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMDelete");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfAsset (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset() const
+    {
+        return this->tx_->at(sfAsset);
+    }
+
+    /**
+     * @brief Get sfAsset2 (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset2() const
+    {
+        return this->tx_->at(sfAsset2);
+    }
+};
+
+/**
+ * @brief Builder for AMMDelete transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses Json::Value internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class AMMDeleteBuilder : public TransactionBuilderBase<AMMDeleteBuilder>
+{
+public:
+    /**
+     * @brief Construct a new AMMDeleteBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param asset The sfAsset field value.
+     * @param asset2 The sfAsset2 field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    AMMDeleteBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_ISSUE::type::value_type> const& asset,                     std::decay_t<typename SF_ISSUE::type::value_type> const& asset2,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<AMMDeleteBuilder>(ttAMM_DELETE, account, sequence, fee)
+    {
+        setAsset(asset);
+        setAsset2(asset2);
+    }
+
+    /**
+     * @brief Construct a AMMDeleteBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    AMMDeleteBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttAMM_DELETE)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMDeleteBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /** @brief Transaction-specific field setters */
+
+    /**
+     * @brief Set sfAsset (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMDeleteBuilder&
+    setAsset(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
+    {
+        object_[sfAsset] = STIssue(sfAsset, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAsset2 (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMDeleteBuilder&
+    setAsset2(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
+    {
+        object_[sfAsset2] = STIssue(sfAsset2, value);
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the AMMDelete wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    AMMDelete
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return AMMDelete{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/AMMDeposit.h

@@ -0,0 +1,338 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class AMMDepositBuilder;
+
+/**
+ * @brief Transaction: AMMDeposit
+ *
+ * Type: ttAMM_DEPOSIT (36)
+ * Delegable: Delegation::delegable
+ * Amendment: featureAMM
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use AMMDepositBuilder to construct new transactions.
+ */
+class AMMDeposit : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttAMM_DEPOSIT;
+
+    /**
+     * @brief Construct a AMMDeposit transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit AMMDeposit(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMDeposit");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfAsset (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset() const
+    {
+        return this->tx_->at(sfAsset);
+    }
+
+    /**
+     * @brief Get sfAsset2 (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset2() const
+    {
+        return this->tx_->at(sfAsset2);
+    }
+
+    /**
+     * @brief Get sfAmount (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getAmount() const
+    {
+        if (hasAmount())
+        {
+            return this->tx_->at(sfAmount);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfAmount is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasAmount() const
+    {
+        return this->tx_->isFieldPresent(sfAmount);
+    }
+
+    /**
+     * @brief Get sfAmount2 (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getAmount2() const
+    {
+        if (hasAmount2())
+        {
+            return this->tx_->at(sfAmount2);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfAmount2 is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasAmount2() const
+    {
+        return this->tx_->isFieldPresent(sfAmount2);
+    }
+
+    /**
+     * @brief Get sfEPrice (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getEPrice() const
+    {
+        if (hasEPrice())
+        {
+            return this->tx_->at(sfEPrice);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfEPrice is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasEPrice() const
+    {
+        return this->tx_->isFieldPresent(sfEPrice);
+    }
+
+    /**
+     * @brief Get sfLPTokenOut (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getLPTokenOut() const
+    {
+        if (hasLPTokenOut())
+        {
+            return this->tx_->at(sfLPTokenOut);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfLPTokenOut is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasLPTokenOut() const
+    {
+        return this->tx_->isFieldPresent(sfLPTokenOut);
+    }
+
+    /**
+     * @brief Get sfTradingFee (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT16::type::value_type>
+    getTradingFee() const
+    {
+        if (hasTradingFee())
+        {
+            return this->tx_->at(sfTradingFee);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfTradingFee is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasTradingFee() const
+    {
+        return this->tx_->isFieldPresent(sfTradingFee);
+    }
+};
+
+/**
+ * @brief Builder for AMMDeposit transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses Json::Value internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class AMMDepositBuilder : public TransactionBuilderBase<AMMDepositBuilder>
+{
+public:
+    /**
+     * @brief Construct a new AMMDepositBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param asset The sfAsset field value.
+     * @param asset2 The sfAsset2 field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    AMMDepositBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_ISSUE::type::value_type> const& asset,                     std::decay_t<typename SF_ISSUE::type::value_type> const& asset2,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<AMMDepositBuilder>(ttAMM_DEPOSIT, account, sequence, fee)
+    {
+        setAsset(asset);
+        setAsset2(asset2);
+    }
+
+    /**
+     * @brief Construct a AMMDepositBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    AMMDepositBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttAMM_DEPOSIT)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMDepositBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /** @brief Transaction-specific field setters */
+
+    /**
+     * @brief Set sfAsset (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMDepositBuilder&
+    setAsset(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
+    {
+        object_[sfAsset] = STIssue(sfAsset, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAsset2 (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMDepositBuilder&
+    setAsset2(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
+    {
+        object_[sfAsset2] = STIssue(sfAsset2, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAmount (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMDepositBuilder&
+    setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAmount2 (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMDepositBuilder&
+    setAmount2(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfAmount2] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfEPrice (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMDepositBuilder&
+    setEPrice(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfEPrice] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfLPTokenOut (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMDepositBuilder&
+    setLPTokenOut(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfLPTokenOut] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfTradingFee (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMDepositBuilder&
+    setTradingFee(std::decay_t<typename SF_UINT16::type::value_type> const& value)
+    {
+        object_[sfTradingFee] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the AMMDeposit wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    AMMDeposit
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return AMMDeposit{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/AMMVote.h

@@ -0,0 +1,177 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class AMMVoteBuilder;
+
+/**
+ * @brief Transaction: AMMVote
+ *
+ * Type: ttAMM_VOTE (38)
+ * Delegable: Delegation::delegable
+ * Amendment: featureAMM
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use AMMVoteBuilder to construct new transactions.
+ */
+class AMMVote : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttAMM_VOTE;
+
+    /**
+     * @brief Construct a AMMVote transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit AMMVote(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMVote");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfAsset (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset() const
+    {
+        return this->tx_->at(sfAsset);
+    }
+
+    /**
+     * @brief Get sfAsset2 (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset2() const
+    {
+        return this->tx_->at(sfAsset2);
+    }
+
+    /**
+     * @brief Get sfTradingFee (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT16::type::value_type
+    getTradingFee() const
+    {
+        return this->tx_->at(sfTradingFee);
+    }
+};
+
+/**
+ * @brief Builder for AMMVote transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses Json::Value internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class AMMVoteBuilder : public TransactionBuilderBase<AMMVoteBuilder>
+{
+public:
+    /**
+     * @brief Construct a new AMMVoteBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param asset The sfAsset field value.
+     * @param asset2 The sfAsset2 field value.
+     * @param tradingFee The sfTradingFee field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    AMMVoteBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_ISSUE::type::value_type> const& asset,                     std::decay_t<typename SF_ISSUE::type::value_type> const& asset2,                     std::decay_t<typename SF_UINT16::type::value_type> const& tradingFee,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<AMMVoteBuilder>(ttAMM_VOTE, account, sequence, fee)
+    {
+        setAsset(asset);
+        setAsset2(asset2);
+        setTradingFee(tradingFee);
+    }
+
+    /**
+     * @brief Construct a AMMVoteBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    AMMVoteBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttAMM_VOTE)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMVoteBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /** @brief Transaction-specific field setters */
+
+    /**
+     * @brief Set sfAsset (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMVoteBuilder&
+    setAsset(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
+    {
+        object_[sfAsset] = STIssue(sfAsset, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAsset2 (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMVoteBuilder&
+    setAsset2(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
+    {
+        object_[sfAsset2] = STIssue(sfAsset2, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfTradingFee (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMVoteBuilder&
+    setTradingFee(std::decay_t<typename SF_UINT16::type::value_type> const& value)
+    {
+        object_[sfTradingFee] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the AMMVote wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    AMMVote
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return AMMVote{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/AMMWithdraw.h

@@ -0,0 +1,301 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class AMMWithdrawBuilder;
+
+/**
+ * @brief Transaction: AMMWithdraw
+ *
+ * Type: ttAMM_WITHDRAW (37)
+ * Delegable: Delegation::delegable
+ * Amendment: featureAMM
+ * Privileges: mayDeleteAcct
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use AMMWithdrawBuilder to construct new transactions.
+ */
+class AMMWithdraw : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttAMM_WITHDRAW;
+
+    /**
+     * @brief Construct a AMMWithdraw transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit AMMWithdraw(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMWithdraw");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfAsset (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset() const
+    {
+        return this->tx_->at(sfAsset);
+    }
+
+    /**
+     * @brief Get sfAsset2 (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset2() const
+    {
+        return this->tx_->at(sfAsset2);
+    }
+
+    /**
+     * @brief Get sfAmount (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getAmount() const
+    {
+        if (hasAmount())
+        {
+            return this->tx_->at(sfAmount);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfAmount is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasAmount() const
+    {
+        return this->tx_->isFieldPresent(sfAmount);
+    }
+
+    /**
+     * @brief Get sfAmount2 (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getAmount2() const
+    {
+        if (hasAmount2())
+        {
+            return this->tx_->at(sfAmount2);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfAmount2 is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasAmount2() const
+    {
+        return this->tx_->isFieldPresent(sfAmount2);
+    }
+
+    /**
+     * @brief Get sfEPrice (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getEPrice() const
+    {
+        if (hasEPrice())
+        {
+            return this->tx_->at(sfEPrice);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfEPrice is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasEPrice() const
+    {
+        return this->tx_->isFieldPresent(sfEPrice);
+    }
+
+    /**
+     * @brief Get sfLPTokenIn (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getLPTokenIn() const
+    {
+        if (hasLPTokenIn())
+        {
+            return this->tx_->at(sfLPTokenIn);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfLPTokenIn is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasLPTokenIn() const
+    {
+        return this->tx_->isFieldPresent(sfLPTokenIn);
+    }
+};
+
+/**
+ * @brief Builder for AMMWithdraw transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses Json::Value internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class AMMWithdrawBuilder : public TransactionBuilderBase<AMMWithdrawBuilder>
+{
+public:
+    /**
+     * @brief Construct a new AMMWithdrawBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param asset The sfAsset field value.
+     * @param asset2 The sfAsset2 field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    AMMWithdrawBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_ISSUE::type::value_type> const& asset,                     std::decay_t<typename SF_ISSUE::type::value_type> const& asset2,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<AMMWithdrawBuilder>(ttAMM_WITHDRAW, account, sequence, fee)
+    {
+        setAsset(asset);
+        setAsset2(asset2);
+    }
+
+    /**
+     * @brief Construct a AMMWithdrawBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    AMMWithdrawBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttAMM_WITHDRAW)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMWithdrawBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /** @brief Transaction-specific field setters */
+
+    /**
+     * @brief Set sfAsset (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMWithdrawBuilder&
+    setAsset(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
+    {
+        object_[sfAsset] = STIssue(sfAsset, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAsset2 (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMWithdrawBuilder&
+    setAsset2(std::decay_t<typename SF_ISSUE::type::value_type> const& value)
+    {
+        object_[sfAsset2] = STIssue(sfAsset2, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAmount (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMWithdrawBuilder&
+    setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAmount2 (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMWithdrawBuilder&
+    setAmount2(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfAmount2] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfEPrice (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMWithdrawBuilder&
+    setEPrice(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfEPrice] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfLPTokenIn (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMWithdrawBuilder&
+    setLPTokenIn(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfLPTokenIn] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the AMMWithdraw wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    AMMWithdraw
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return AMMWithdraw{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/AccountDelete.h

@@ -0,0 +1,203 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class AccountDeleteBuilder;
+
+/**
+ * @brief Transaction: AccountDelete
+ *
+ * Type: ttACCOUNT_DELETE (21)
+ * Delegable: Delegation::notDelegable
+ * Amendment: uint256{}
+ * Privileges: mustDeleteAcct
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use AccountDeleteBuilder to construct new transactions.
+ */
+class AccountDelete : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttACCOUNT_DELETE;
+
+    /**
+     * @brief Construct a AccountDelete transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit AccountDelete(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for AccountDelete");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfDestination (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getDestination() const
+    {
+        return this->tx_->at(sfDestination);
+    }
+
+    /**
+     * @brief Get sfDestinationTag (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getDestinationTag() const
+    {
+        if (hasDestinationTag())
+        {
+            return this->tx_->at(sfDestinationTag);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfDestinationTag is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasDestinationTag() const
+    {
+        return this->tx_->isFieldPresent(sfDestinationTag);
+    }
+
+    /**
+     * @brief Get sfCredentialIDs (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VECTOR256::type::value_type>
+    getCredentialIDs() const
+    {
+        if (hasCredentialIDs())
+        {
+            return this->tx_->at(sfCredentialIDs);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfCredentialIDs is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasCredentialIDs() const
+    {
+        return this->tx_->isFieldPresent(sfCredentialIDs);
+    }
+};
+
+/**
+ * @brief Builder for AccountDelete transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses Json::Value internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class AccountDeleteBuilder : public TransactionBuilderBase<AccountDeleteBuilder>
+{
+public:
+    /**
+     * @brief Construct a new AccountDeleteBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param destination The sfDestination field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    AccountDeleteBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_ACCOUNT::type::value_type> const& destination,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<AccountDeleteBuilder>(ttACCOUNT_DELETE, account, sequence, fee)
+    {
+        setDestination(destination);
+    }
+
+    /**
+     * @brief Construct a AccountDeleteBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    AccountDeleteBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttACCOUNT_DELETE)
+        {
+            throw std::runtime_error("Invalid transaction type for AccountDeleteBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /** @brief Transaction-specific field setters */
+
+    /**
+     * @brief Set sfDestination (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountDeleteBuilder&
+    setDestination(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfDestination] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDestinationTag (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountDeleteBuilder&
+    setDestinationTag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfDestinationTag] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfCredentialIDs (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountDeleteBuilder&
+    setCredentialIDs(std::decay_t<typename SF_VECTOR256::type::value_type> const& value)
+    {
+        object_[sfCredentialIDs] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the AccountDelete wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    AccountDelete
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return AccountDelete{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/AccountSet.h

@@ -0,0 +1,475 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class AccountSetBuilder;
+
+/**
+ * @brief Transaction: AccountSet
+ *
+ * Type: ttACCOUNT_SET (3)
+ * Delegable: Delegation::notDelegable
+ * Amendment: uint256{}
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use AccountSetBuilder to construct new transactions.
+ */
+class AccountSet : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttACCOUNT_SET;
+
+    /**
+     * @brief Construct a AccountSet transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit AccountSet(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for AccountSet");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfEmailHash (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT128::type::value_type>
+    getEmailHash() const
+    {
+        if (hasEmailHash())
+        {
+            return this->tx_->at(sfEmailHash);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfEmailHash is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasEmailHash() const
+    {
+        return this->tx_->isFieldPresent(sfEmailHash);
+    }
+
+    /**
+     * @brief Get sfWalletLocator (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getWalletLocator() const
+    {
+        if (hasWalletLocator())
+        {
+            return this->tx_->at(sfWalletLocator);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfWalletLocator is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasWalletLocator() const
+    {
+        return this->tx_->isFieldPresent(sfWalletLocator);
+    }
+
+    /**
+     * @brief Get sfWalletSize (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getWalletSize() const
+    {
+        if (hasWalletSize())
+        {
+            return this->tx_->at(sfWalletSize);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfWalletSize is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasWalletSize() const
+    {
+        return this->tx_->isFieldPresent(sfWalletSize);
+    }
+
+    /**
+     * @brief Get sfMessageKey (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getMessageKey() const
+    {
+        if (hasMessageKey())
+        {
+            return this->tx_->at(sfMessageKey);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfMessageKey is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasMessageKey() const
+    {
+        return this->tx_->isFieldPresent(sfMessageKey);
+    }
+
+    /**
+     * @brief Get sfDomain (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getDomain() const
+    {
+        if (hasDomain())
+        {
+            return this->tx_->at(sfDomain);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfDomain is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasDomain() const
+    {
+        return this->tx_->isFieldPresent(sfDomain);
+    }
+
+    /**
+     * @brief Get sfTransferRate (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getTransferRate() const
+    {
+        if (hasTransferRate())
+        {
+            return this->tx_->at(sfTransferRate);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfTransferRate is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasTransferRate() const
+    {
+        return this->tx_->isFieldPresent(sfTransferRate);
+    }
+
+    /**
+     * @brief Get sfSetFlag (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getSetFlag() const
+    {
+        if (hasSetFlag())
+        {
+            return this->tx_->at(sfSetFlag);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfSetFlag is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasSetFlag() const
+    {
+        return this->tx_->isFieldPresent(sfSetFlag);
+    }
+
+    /**
+     * @brief Get sfClearFlag (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getClearFlag() const
+    {
+        if (hasClearFlag())
+        {
+            return this->tx_->at(sfClearFlag);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfClearFlag is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasClearFlag() const
+    {
+        return this->tx_->isFieldPresent(sfClearFlag);
+    }
+
+    /**
+     * @brief Get sfTickSize (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT8::type::value_type>
+    getTickSize() const
+    {
+        if (hasTickSize())
+        {
+            return this->tx_->at(sfTickSize);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfTickSize is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasTickSize() const
+    {
+        return this->tx_->isFieldPresent(sfTickSize);
+    }
+
+    /**
+     * @brief Get sfNFTokenMinter (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getNFTokenMinter() const
+    {
+        if (hasNFTokenMinter())
+        {
+            return this->tx_->at(sfNFTokenMinter);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfNFTokenMinter is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasNFTokenMinter() const
+    {
+        return this->tx_->isFieldPresent(sfNFTokenMinter);
+    }
+};
+
+/**
+ * @brief Builder for AccountSet transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses Json::Value internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class AccountSetBuilder : public TransactionBuilderBase<AccountSetBuilder>
+{
+public:
+    /**
+     * @brief Construct a new AccountSetBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    AccountSetBuilder(SF_ACCOUNT::type::value_type account,
+                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<AccountSetBuilder>(ttACCOUNT_SET, account, sequence, fee)
+    {
+    }
+
+    /**
+     * @brief Construct a AccountSetBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    AccountSetBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttACCOUNT_SET)
+        {
+            throw std::runtime_error("Invalid transaction type for AccountSetBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /** @brief Transaction-specific field setters */
+
+    /**
+     * @brief Set sfEmailHash (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountSetBuilder&
+    setEmailHash(std::decay_t<typename SF_UINT128::type::value_type> const& value)
+    {
+        object_[sfEmailHash] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfWalletLocator (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountSetBuilder&
+    setWalletLocator(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfWalletLocator] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfWalletSize (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountSetBuilder&
+    setWalletSize(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfWalletSize] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfMessageKey (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountSetBuilder&
+    setMessageKey(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfMessageKey] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDomain (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountSetBuilder&
+    setDomain(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfDomain] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfTransferRate (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountSetBuilder&
+    setTransferRate(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfTransferRate] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSetFlag (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountSetBuilder&
+    setSetFlag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfSetFlag] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfClearFlag (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountSetBuilder&
+    setClearFlag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfClearFlag] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfTickSize (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountSetBuilder&
+    setTickSize(std::decay_t<typename SF_UINT8::type::value_type> const& value)
+    {
+        object_[sfTickSize] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfNFTokenMinter (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AccountSetBuilder&
+    setNFTokenMinter(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfNFTokenMinter] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the AccountSet wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    AccountSet
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return AccountSet{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/Batch.h

@@ -0,0 +1,164 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class BatchBuilder;
+
+/**
+ * @brief Transaction: Batch
+ *
+ * Type: ttBATCH (71)
+ * Delegable: Delegation::notDelegable
+ * Amendment: featureBatch
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use BatchBuilder to construct new transactions.
+ */
+class Batch : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttBATCH;
+
+    /**
+     * @brief Construct a Batch transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit Batch(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for Batch");
+        }
+    }
+
+    // Transaction-specific field getters
+    /**
+     * @brief Get sfRawTransactions (soeREQUIRED)
+     * @note This is an untyped field.
+     * @return The field value.
+     */
+    [[nodiscard]]
+    STArray const&
+    getRawTransactions() const
+    {
+        return this->tx_->getFieldArray(sfRawTransactions);
+    }
+    /**
+     * @brief Get sfBatchSigners (soeOPTIONAL)
+     * @note This is an untyped field.
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    std::optional<std::reference_wrapper<STArray const>>
+    getBatchSigners() const
+    {
+        if (this->tx_->isFieldPresent(sfBatchSigners))
+            return this->tx_->getFieldArray(sfBatchSigners);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfBatchSigners is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasBatchSigners() const
+    {
+        return this->tx_->isFieldPresent(sfBatchSigners);
+    }
+};
+
+/**
+ * @brief Builder for Batch transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses Json::Value internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class BatchBuilder : public TransactionBuilderBase<BatchBuilder>
+{
+public:
+    /**
+     * @brief Construct a new BatchBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param rawTransactions The sfRawTransactions field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    BatchBuilder(SF_ACCOUNT::type::value_type account,
+                     STArray const& rawTransactions,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<BatchBuilder>(ttBATCH, account, sequence, fee)
+    {
+        setRawTransactions(rawTransactions);
+    }
+
+    /**
+     * @brief Construct a BatchBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    BatchBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttBATCH)
+        {
+            throw std::runtime_error("Invalid transaction type for BatchBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /** @brief Transaction-specific field setters */
+
+    /**
+     * @brief Set sfRawTransactions (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    BatchBuilder&
+    setRawTransactions(STArray const& value)
+    {
+        object_.setFieldArray(sfRawTransactions, value);
+        return *this;
+    }
+
+    /**
+     * @brief Set sfBatchSigners (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    BatchBuilder&
+    setBatchSigners(STArray const& value)
+    {
+        object_.setFieldArray(sfBatchSigners, value);
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the Batch wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    Batch
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return Batch{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/CheckCancel.h

@@ -0,0 +1,129 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class CheckCancelBuilder;
+
+/**
+ * @brief Transaction: CheckCancel
+ *
+ * Type: ttCHECK_CANCEL (18)
+ * Delegable: Delegation::delegable
+ * Amendment: uint256{}
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use CheckCancelBuilder to construct new transactions.
+ */
+class CheckCancel : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttCHECK_CANCEL;
+
+    /**
+     * @brief Construct a CheckCancel transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit CheckCancel(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for CheckCancel");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfCheckID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getCheckID() const
+    {
+        return this->tx_->at(sfCheckID);
+    }
+};
+
+/**
+ * @brief Builder for CheckCancel transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses Json::Value internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class CheckCancelBuilder : public TransactionBuilderBase<CheckCancelBuilder>
+{
+public:
+    /**
+     * @brief Construct a new CheckCancelBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param checkID The sfCheckID field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    CheckCancelBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_UINT256::type::value_type> const& checkID,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<CheckCancelBuilder>(ttCHECK_CANCEL, account, sequence, fee)
+    {
+        setCheckID(checkID);
+    }
+
+    /**
+     * @brief Construct a CheckCancelBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    CheckCancelBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttCHECK_CANCEL)
+        {
+            throw std::runtime_error("Invalid transaction type for CheckCancelBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /** @brief Transaction-specific field setters */
+
+    /**
+     * @brief Set sfCheckID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    CheckCancelBuilder&
+    setCheckID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfCheckID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the CheckCancel wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    CheckCancel
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return CheckCancel{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/CheckCash.h

@@ -0,0 +1,203 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class CheckCashBuilder;
+
+/**
+ * @brief Transaction: CheckCash
+ *
+ * Type: ttCHECK_CASH (17)
+ * Delegable: Delegation::delegable
+ * Amendment: uint256{}
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use CheckCashBuilder to construct new transactions.
+ */
+class CheckCash : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttCHECK_CASH;
+
+    /**
+     * @brief Construct a CheckCash transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit CheckCash(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for CheckCash");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfCheckID (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getCheckID() const
+    {
+        return this->tx_->at(sfCheckID);
+    }
+
+    /**
+     * @brief Get sfAmount (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getAmount() const
+    {
+        if (hasAmount())
+        {
+            return this->tx_->at(sfAmount);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfAmount is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasAmount() const
+    {
+        return this->tx_->isFieldPresent(sfAmount);
+    }
+
+    /**
+     * @brief Get sfDeliverMin (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getDeliverMin() const
+    {
+        if (hasDeliverMin())
+        {
+            return this->tx_->at(sfDeliverMin);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfDeliverMin is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasDeliverMin() const
+    {
+        return this->tx_->isFieldPresent(sfDeliverMin);
+    }
+};
+
+/**
+ * @brief Builder for CheckCash transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses Json::Value internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class CheckCashBuilder : public TransactionBuilderBase<CheckCashBuilder>
+{
+public:
+    /**
+     * @brief Construct a new CheckCashBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param checkID The sfCheckID field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    CheckCashBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_UINT256::type::value_type> const& checkID,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<CheckCashBuilder>(ttCHECK_CASH, account, sequence, fee)
+    {
+        setCheckID(checkID);
+    }
+
+    /**
+     * @brief Construct a CheckCashBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    CheckCashBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttCHECK_CASH)
+        {
+            throw std::runtime_error("Invalid transaction type for CheckCashBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /** @brief Transaction-specific field setters */
+
+    /**
+     * @brief Set sfCheckID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    CheckCashBuilder&
+    setCheckID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfCheckID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfAmount (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    CheckCashBuilder&
+    setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDeliverMin (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    CheckCashBuilder&
+    setDeliverMin(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfDeliverMin] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the CheckCash wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    CheckCash
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return CheckCash{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/CheckCreate.h

@@ -0,0 +1,264 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class CheckCreateBuilder;
+
+/**
+ * @brief Transaction: CheckCreate
+ *
+ * Type: ttCHECK_CREATE (16)
+ * Delegable: Delegation::delegable
+ * Amendment: uint256{}
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use CheckCreateBuilder to construct new transactions.
+ */
+class CheckCreate : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttCHECK_CREATE;
+
+    /**
+     * @brief Construct a CheckCreate transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit CheckCreate(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for CheckCreate");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfDestination (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getDestination() const
+    {
+        return this->tx_->at(sfDestination);
+    }
+
+    /**
+     * @brief Get sfSendMax (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getSendMax() const
+    {
+        return this->tx_->at(sfSendMax);
+    }
+
+    /**
+     * @brief Get sfExpiration (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getExpiration() const
+    {
+        if (hasExpiration())
+        {
+            return this->tx_->at(sfExpiration);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfExpiration is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasExpiration() const
+    {
+        return this->tx_->isFieldPresent(sfExpiration);
+    }
+
+    /**
+     * @brief Get sfDestinationTag (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getDestinationTag() const
+    {
+        if (hasDestinationTag())
+        {
+            return this->tx_->at(sfDestinationTag);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfDestinationTag is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasDestinationTag() const
+    {
+        return this->tx_->isFieldPresent(sfDestinationTag);
+    }
+
+    /**
+     * @brief Get sfInvoiceID (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getInvoiceID() const
+    {
+        if (hasInvoiceID())
+        {
+            return this->tx_->at(sfInvoiceID);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfInvoiceID is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasInvoiceID() const
+    {
+        return this->tx_->isFieldPresent(sfInvoiceID);
+    }
+};
+
+/**
+ * @brief Builder for CheckCreate transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses Json::Value internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class CheckCreateBuilder : public TransactionBuilderBase<CheckCreateBuilder>
+{
+public:
+    /**
+     * @brief Construct a new CheckCreateBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param destination The sfDestination field value.
+     * @param sendMax The sfSendMax field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    CheckCreateBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_ACCOUNT::type::value_type> const& destination,                     std::decay_t<typename SF_AMOUNT::type::value_type> const& sendMax,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<CheckCreateBuilder>(ttCHECK_CREATE, account, sequence, fee)
+    {
+        setDestination(destination);
+        setSendMax(sendMax);
+    }
+
+    /**
+     * @brief Construct a CheckCreateBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    CheckCreateBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttCHECK_CREATE)
+        {
+            throw std::runtime_error("Invalid transaction type for CheckCreateBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /** @brief Transaction-specific field setters */
+
+    /**
+     * @brief Set sfDestination (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    CheckCreateBuilder&
+    setDestination(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfDestination] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfSendMax (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    CheckCreateBuilder&
+    setSendMax(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfSendMax] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfExpiration (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    CheckCreateBuilder&
+    setExpiration(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfExpiration] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfDestinationTag (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    CheckCreateBuilder&
+    setDestinationTag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfDestinationTag] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfInvoiceID (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    CheckCreateBuilder&
+    setInvoiceID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfInvoiceID] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the CheckCreate wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    CheckCreate
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return CheckCreate{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/Clawback.h

@@ -0,0 +1,168 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class ClawbackBuilder;
+
+/**
+ * @brief Transaction: Clawback
+ *
+ * Type: ttCLAWBACK (30)
+ * Delegable: Delegation::delegable
+ * Amendment: featureClawback
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use ClawbackBuilder to construct new transactions.
+ */
+class Clawback : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttCLAWBACK;
+
+    /**
+     * @brief Construct a Clawback transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit Clawback(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for Clawback");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfAmount (soeREQUIRED)
+     * @note This field supports MPT (Multi-Purpose Token) amounts.
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getAmount() const
+    {
+        return this->tx_->at(sfAmount);
+    }
+
+    /**
+     * @brief Get sfHolder (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getHolder() const
+    {
+        if (hasHolder())
+        {
+            return this->tx_->at(sfHolder);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfHolder is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasHolder() const
+    {
+        return this->tx_->isFieldPresent(sfHolder);
+    }
+};
+
+/**
+ * @brief Builder for Clawback transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses Json::Value internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class ClawbackBuilder : public TransactionBuilderBase<ClawbackBuilder>
+{
+public:
+    /**
+     * @brief Construct a new ClawbackBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param amount The sfAmount field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    ClawbackBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_AMOUNT::type::value_type> const& amount,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<ClawbackBuilder>(ttCLAWBACK, account, sequence, fee)
+    {
+        setAmount(amount);
+    }
+
+    /**
+     * @brief Construct a ClawbackBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    ClawbackBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttCLAWBACK)
+        {
+            throw std::runtime_error("Invalid transaction type for ClawbackBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /** @brief Transaction-specific field setters */
+
+    /**
+     * @brief Set sfAmount (soeREQUIRED)
+     * @note This field supports MPT (Multi-Purpose Token) amounts.
+     * @return Reference to this builder for method chaining.
+     */
+    ClawbackBuilder&
+    setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfAmount] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfHolder (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    ClawbackBuilder&
+    setHolder(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfHolder] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the Clawback wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    Clawback
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return Clawback{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/CredentialAccept.h

@@ -0,0 +1,153 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class CredentialAcceptBuilder;
+
+/**
+ * @brief Transaction: CredentialAccept
+ *
+ * Type: ttCREDENTIAL_ACCEPT (59)
+ * Delegable: Delegation::delegable
+ * Amendment: featureCredentials
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use CredentialAcceptBuilder to construct new transactions.
+ */
+class CredentialAccept : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttCREDENTIAL_ACCEPT;
+
+    /**
+     * @brief Construct a CredentialAccept transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit CredentialAccept(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for CredentialAccept");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfIssuer (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getIssuer() const
+    {
+        return this->tx_->at(sfIssuer);
+    }
+
+    /**
+     * @brief Get sfCredentialType (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_VL::type::value_type
+    getCredentialType() const
+    {
+        return this->tx_->at(sfCredentialType);
+    }
+};
+
+/**
+ * @brief Builder for CredentialAccept transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses Json::Value internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class CredentialAcceptBuilder : public TransactionBuilderBase<CredentialAcceptBuilder>
+{
+public:
+    /**
+     * @brief Construct a new CredentialAcceptBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param issuer The sfIssuer field value.
+     * @param credentialType The sfCredentialType field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    CredentialAcceptBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_ACCOUNT::type::value_type> const& issuer,                     std::decay_t<typename SF_VL::type::value_type> const& credentialType,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<CredentialAcceptBuilder>(ttCREDENTIAL_ACCEPT, account, sequence, fee)
+    {
+        setIssuer(issuer);
+        setCredentialType(credentialType);
+    }
+
+    /**
+     * @brief Construct a CredentialAcceptBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    CredentialAcceptBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttCREDENTIAL_ACCEPT)
+        {
+            throw std::runtime_error("Invalid transaction type for CredentialAcceptBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /** @brief Transaction-specific field setters */
+
+    /**
+     * @brief Set sfIssuer (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    CredentialAcceptBuilder&
+    setIssuer(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfIssuer] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfCredentialType (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    CredentialAcceptBuilder&
+    setCredentialType(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfCredentialType] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the CredentialAccept wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    CredentialAccept
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return CredentialAccept{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/CredentialCreate.h

@@ -0,0 +1,227 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+class CredentialCreateBuilder;
+
+/**
+ * @brief Transaction: CredentialCreate
+ *
+ * Type: ttCREDENTIAL_CREATE (58)
+ * Delegable: Delegation::delegable
+ * Amendment: featureCredentials
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use CredentialCreateBuilder to construct new transactions.
+ */
+class CredentialCreate : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttCREDENTIAL_CREATE;
+
+    /**
+     * @brief Construct a CredentialCreate transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit CredentialCreate(std::shared_ptr<STTx const> tx)
+        : TransactionBase(std::move(tx))
+    {
+        // Verify transaction type
+        if (tx_->getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for CredentialCreate");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * @brief Get sfSubject (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getSubject() const
+    {
+        return this->tx_->at(sfSubject);
+    }
+
+    /**
+     * @brief Get sfCredentialType (soeREQUIRED)
+     * @return The field value.
+     */
+    [[nodiscard]]
+    SF_VL::type::value_type
+    getCredentialType() const
+    {
+        return this->tx_->at(sfCredentialType);
+    }
+
+    /**
+     * @brief Get sfExpiration (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getExpiration() const
+    {
+        if (hasExpiration())
+        {
+            return this->tx_->at(sfExpiration);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfExpiration is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasExpiration() const
+    {
+        return this->tx_->isFieldPresent(sfExpiration);
+    }
+
+    /**
+     * @brief Get sfURI (soeOPTIONAL)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getURI() const
+    {
+        if (hasURI())
+        {
+            return this->tx_->at(sfURI);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfURI is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasURI() const
+    {
+        return this->tx_->isFieldPresent(sfURI);
+    }
+};
+
+/**
+ * @brief Builder for CredentialCreate transactions.
+ *
+ * Provides a fluent interface for constructing transactions with method chaining.
+ * Uses Json::Value internally for flexible transaction construction.
+ * Inherits common field setters from TransactionBuilderBase.
+ */
+class CredentialCreateBuilder : public TransactionBuilderBase<CredentialCreateBuilder>
+{
+public:
+    /**
+     * @brief Construct a new CredentialCreateBuilder with required fields.
+     * @param account The account initiating the transaction.
+     * @param subject The sfSubject field value.
+     * @param credentialType The sfCredentialType field value.
+     * @param sequence Optional sequence number for the transaction.
+     * @param fee Optional fee for the transaction.
+     */
+    CredentialCreateBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_ACCOUNT::type::value_type> const& subject,                     std::decay_t<typename SF_VL::type::value_type> const& credentialType,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<CredentialCreateBuilder>(ttCREDENTIAL_CREATE, account, sequence, fee)
+    {
+        setSubject(subject);
+        setCredentialType(credentialType);
+    }
+
+    /**
+     * @brief Construct a CredentialCreateBuilder from an existing STTx object.
+     * @param tx The existing transaction to copy from.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    CredentialCreateBuilder(std::shared_ptr<STTx const> tx)
+    {
+        if (tx->getTxnType() != ttCREDENTIAL_CREATE)
+        {
+            throw std::runtime_error("Invalid transaction type for CredentialCreateBuilder");
+        }
+        object_ = *tx;
+    }
+
+    /** @brief Transaction-specific field setters */
+
+    /**
+     * @brief Set sfSubject (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    CredentialCreateBuilder&
+    setSubject(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfSubject] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfCredentialType (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    CredentialCreateBuilder&
+    setCredentialType(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfCredentialType] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfExpiration (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    CredentialCreateBuilder&
+    setExpiration(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfExpiration] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfURI (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    CredentialCreateBuilder&
+    setURI(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfURI] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Build and return the CredentialCreate wrapper.
+     * @param publicKey The public key for signing.
+     * @param secretKey The secret key for signing.
+     * @return The constructed transaction wrapper.
+     */
+    CredentialCreate
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return CredentialCreate{std::make_shared<STTx>(std::move(object_))};
+    }
+};
+
+}  // namespace xrpl::transactions