Fix levelisation error

Signed-off-by: JCW <a1q123456@users.noreply.github.com>

.clang-tidy

@@ -10,6 +10,7 @@ Checks: "-*,
   bugprone-copy-constructor-init,
   bugprone-dangling-handle,
   bugprone-dynamic-static-initializers,
+  bugprone-empty-catch,
   bugprone-fold-init-type,
   bugprone-forward-declaration-namespace,
   bugprone-inaccurate-erase,
@@ -23,6 +24,7 @@ Checks: "-*,
   bugprone-misplaced-operator-in-strlen-in-alloc,
   bugprone-misplaced-pointer-arithmetic-in-alloc,
   bugprone-misplaced-widening-cast,
+  bugprone-move-forwarding-reference,
   bugprone-multi-level-implicit-pointer-conversion,
   bugprone-multiple-new-in-one-expression,
   bugprone-multiple-statement-macro,
@@ -31,10 +33,12 @@ Checks: "-*,
   bugprone-parent-virtual-call,
   bugprone-posix-return,
   bugprone-redundant-branch-condition,
+  bugprone-return-const-ref-from-parameter,
   bugprone-shared-ptr-array-mismatch,
   bugprone-signal-handler,
   bugprone-signed-char-misuse,
   bugprone-sizeof-container,
+  bugprone-sizeof-expression,
   bugprone-spuriously-wake-up-functions,
   bugprone-standalone-empty,
   bugprone-string-constructor,
@@ -81,17 +85,14 @@ Checks: "-*,
   performance-trivially-destructible
   "
 # ---
-# checks that have some issues that need to be resolved:
+# more checks that have some issues that need to be resolved:
 #
-# bugprone-empty-catch,
 # bugprone-crtp-constructor-accessibility,
 # bugprone-inc-dec-in-conditions,
 # bugprone-reserved-identifier,
 # bugprone-move-forwarding-reference,
 # bugprone-unused-local-non-trivial-variable,
-# bugprone-return-const-ref-from-parameter,
 # bugprone-switch-missing-default-case,
-# bugprone-sizeof-expression,
 # bugprone-suspicious-stringview-data-usage,
 # bugprone-suspicious-missing-comma,
 # bugprone-pointer-arithmetic-on-polymorphic-object,

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

@@ -19,6 +19,7 @@ libxrpl.nodestore > xrpl.protocol
 libxrpl.protocol > xrpl.basics
 libxrpl.protocol > xrpl.json
 libxrpl.protocol > xrpl.protocol
+libxrpl.protocol_autogen > xrpl.protocol_autogen
 libxrpl.rdb > xrpl.basics
 libxrpl.rdb > xrpl.rdb
 libxrpl.resource > xrpl.basics
@@ -190,6 +191,8 @@ xrpl.nodestore > xrpl.basics
 xrpl.nodestore > xrpl.protocol
 xrpl.protocol > xrpl.basics
 xrpl.protocol > xrpl.json
+xrpl.protocol_autogen > xrpl.json
+xrpl.protocol_autogen > xrpl.protocol
 xrpl.rdb > xrpl.basics
 xrpl.rdb > xrpl.core
 xrpl.rdb > xrpl.protocol

.github/workflows/pre-commit.yml

@@ -11,7 +11,7 @@ on:
 jobs:
   # Call the workflow in the XRPLF/actions repo that runs the pre-commit hooks.
   run-hooks:
-    uses: XRPLF/actions/.github/workflows/pre-commit.yml@320be44621ca2a080f05aeb15817c44b84518108
+    uses: XRPLF/actions/.github/workflows/pre-commit.yml@56de1bdf19639e009639a50b8d17c28ca954f267
     with:
       runs_on: ubuntu-latest
       container: '{ "image": "ghcr.io/xrplf/ci/tools-rippled-pre-commit:sha-41ec7c1" }'

.github/workflows/publish-docs.yml

@@ -40,15 +40,18 @@ env:
   NPROC_SUBTRACT: ${{ github.event.repository.private && '1' || '2' }}
 
 jobs:
-  publish:
+  build:
     runs-on: ubuntu-latest
     container: ghcr.io/xrplf/ci/tools-rippled-documentation:sha-a8c7be1
-    permissions:
-      contents: write
     steps:
       - name: Checkout repository
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
+      - name: Prepare runner
+        uses: XRPLF/actions/prepare-runner@2cbf481018d930656e9276fcc20dc0e3a0be5b6d
+        with:
+          enable_ccache: false
+
       - name: Get number of processors
         uses: XRPLF/actions/get-nproc@cf0433aa74563aead044a1e395610c96d65a37cf
         id: nproc
@@ -78,9 +81,23 @@ jobs:
           cmake -Donly_docs=ON ..
           cmake --build . --target docs --parallel ${BUILD_NPROC}
 
-      - name: Publish documentation
+      - name: Create documentation artifact
         if: ${{ github.event_name == 'push' }}
-        uses: peaceiris/actions-gh-pages@4f9cc6602d3f66b9c108549d475ec49e8ef4d45e # v4.0.0
+        uses: actions/upload-pages-artifact@7b1f4a764d45c48632c6b24a0339c27f5614fb0b # v4.0.0
         with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          publish_dir: ${{ env.BUILD_DIR }}/docs/html
+          path: ${{ env.BUILD_DIR }}/docs/html
+
+  deploy:
+    if: ${{ github.event_name == 'push' }}
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      pages: write
+      id-token: write
+    environment:
+      name: github-pages
+      url: ${{ steps.deploy.outputs.page_url }}
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deploy
+        uses: actions/deploy-pages@d6db90164ac5ed86f2b6aed7e0febac5b3c0c03e # v4.0.5

.github/workflows/reusable-build-test-config.yml

@@ -177,7 +177,7 @@ jobs:
 
       - name: Upload the binary (Linux)
         if: ${{ github.repository_owner == 'XRPLF' && runner.os == 'Linux' }}
-        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: xrpld-${{ inputs.config_name }}
           path: ${{ env.BUILD_DIR }}/xrpld

.github/workflows/reusable-clang-tidy-files.yml

@@ -84,7 +84,7 @@ jobs:
 
       - name: Upload clang-tidy output
         if: steps.run_clang_tidy.outcome != 'success'
-        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: clang-tidy-results
           path: clang-tidy-output.txt

.gitignore

@@ -80,3 +80,6 @@ DerivedData
 
 # clangd cache
 /.cache
+
+# python cache
+__pycache__

.pre-commit-config.yaml

@@ -14,17 +14,21 @@ repos:
     rev: 3e8a8703264a2f4a69428a0aa4dcb512790b2c8c # frozen: v6.0.0
     hooks:
       - id: trailing-whitespace
+        exclude: ^include/xrpl/protocol_autogen/(transactions|ledger_objects)/
       - id: end-of-file-fixer
+        exclude: ^include/xrpl/protocol_autogen/(transactions|ledger_objects)/
       - id: mixed-line-ending
+        exclude: ^include/xrpl/protocol_autogen/(transactions|ledger_objects)/
       - id: check-merge-conflict
         args: [--assume-in-merge]
 
   - repo: https://github.com/pre-commit/mirrors-clang-format
-    rev: 75ca4ad908dc4a99f57921f29b7e6c1521e10b26 # frozen: v21.1.8
+    rev: cd481d7b0bfb5c7b3090c21846317f9a8262e891 # frozen: v22.1.0
     hooks:
       - id: clang-format
         args: [--style=file]
         "types_or": [c++, c, proto]
+        exclude: ^include/xrpl/protocol_autogen/(transactions|ledger_objects)/
 
   - repo: https://github.com/cheshirekow/cmake-format-precommit
     rev: e2c2116d86a80e72e7146a06e68b7c228afc6319 # frozen: v0.6.13
@@ -33,20 +37,20 @@ repos:
         additional_dependencies: [PyYAML]
 
   - repo: https://github.com/rbubley/mirrors-prettier
-    rev: 5ba47274f9b181bce26a5150a725577f3c336011 # frozen: v3.6.2
+    rev: c2bc67fe8f8f549cc489e00ba8b45aa18ee713b1 # frozen: v3.8.1
     hooks:
       - id: prettier
 
   - repo: https://github.com/psf/black-pre-commit-mirror
-    rev: 831207fd435b47aeffdf6af853097e64322b4d44 # frozen: v25.12.0
+    rev: ea488cebbfd88a5f50b8bd95d5c829d0bb76feb8 # frozen: 26.1.0
     hooks:
       - id: black
 
   - repo: https://github.com/streetsidesoftware/cspell-cli
-    rev: 1cfa010f078c354f3ffb8413616280cc28f5ba21 # frozen: v9.4.0
+    rev: a42085ade523f591dca134379a595e7859986445 # frozen: v9.7.0
     hooks:
       - id: cspell # Spell check changed files
-        exclude: .config/cspell.config.yaml
+        exclude: (.config/cspell.config.yaml|^include/xrpl/protocol_autogen/(transactions|ledger_objects)/)
       - id: cspell # Spell check the commit message
         name: check commit message spelling
         args:
@@ -61,7 +65,15 @@ repos:
     hooks:
       - id: nix-fmt
         name: Format Nix files
-        entry: nix --extra-experimental-features 'nix-command flakes' fmt
+        entry: |
+          bash -c '
+            if command -v nix &> /dev/null || [ "$GITHUB_ACTIONS" = "true" ]; then
+              nix --extra-experimental-features "nix-command flakes" fmt "$@"
+            else
+              echo "Skipping nix-fmt: nix not installed and not in GitHub Actions"
+              exit 0
+            fi
+          ' --
         language: system
         types:
           - nix

API-CHANGELOG.md

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

CMakeLists.txt

@@ -36,26 +36,6 @@ endif ()
 # Enable ccache to speed up builds.
 include(Ccache)
 
-# make GIT_COMMIT_HASH define available to all sources
-find_package(Git)
-if (Git_FOUND)
-    execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git rev-parse
-                            HEAD OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE gch)
-    if (gch)
-        set(GIT_COMMIT_HASH "${gch}")
-        message(STATUS gch: ${GIT_COMMIT_HASH})
-        add_definitions(-DGIT_COMMIT_HASH="${GIT_COMMIT_HASH}")
-    endif ()
-
-    execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git rev-parse
-                            --abbrev-ref HEAD OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE gb)
-    if (gb)
-        set(GIT_BRANCH "${gb}")
-        message(STATUS gb: ${GIT_BRANCH})
-        add_definitions(-DGIT_BRANCH="${GIT_BRANCH}")
-    endif ()
-endif () # git
-
 if (thread_safety_analysis)
     add_compile_options(-Wthread-safety -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
                         -DXRPL_ENABLE_THREAD_SAFETY_ANNOTATIONS)

cmake/GitInfo.cmake

@@ -0,0 +1,21 @@
+include_guard()
+
+set(GIT_BUILD_BRANCH "")
+set(GIT_COMMIT_HASH "")
+
+find_package(Git)
+if (NOT Git_FOUND)
+    message(WARNING "Git not found. Git branch and commit hash will be empty.")
+    return()
+endif ()
+
+set(GIT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/.git)
+
+execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${GIT_DIRECTORY} rev-parse --abbrev-ref HEAD
+                OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE GIT_BUILD_BRANCH)
+
+execute_process(COMMAND ${GIT_EXECUTABLE} --git-dir=${GIT_DIRECTORY} rev-parse HEAD
+                OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE GIT_COMMIT_HASH)
+
+message(STATUS "Git branch: ${GIT_BUILD_BRANCH}")
+message(STATUS "Git commit hash: ${GIT_COMMIT_HASH}")

cmake/XrplCore.cmake

@@ -58,6 +58,12 @@ include(target_link_modules)
 add_module(xrpl beast)
 target_link_libraries(xrpl.libxrpl.beast PUBLIC xrpl.imports.main)
 
+include(GitInfo)
+add_module(xrpl git)
+target_compile_definitions(xrpl.libxrpl.git PRIVATE GIT_COMMIT_HASH="${GIT_COMMIT_HASH}"
+                                                    GIT_BUILD_BRANCH="${GIT_BUILD_BRANCH}")
+target_link_libraries(xrpl.libxrpl.git PUBLIC xrpl.imports.main)
+
 # Level 02
 add_module(xrpl basics)
 target_link_libraries(xrpl.libxrpl.basics PUBLIC xrpl.libxrpl.beast)
@@ -71,18 +77,27 @@ target_link_libraries(xrpl.libxrpl.crypto PUBLIC xrpl.libxrpl.basics)
 
 # Level 04
 add_module(xrpl protocol)
-target_link_libraries(xrpl.libxrpl.protocol PUBLIC xrpl.libxrpl.crypto xrpl.libxrpl.json)
+target_link_libraries(xrpl.libxrpl.protocol PUBLIC xrpl.libxrpl.crypto xrpl.libxrpl.git
+                                                   xrpl.libxrpl.json)
 
 # Level 05
-add_module(xrpl core)
-target_link_libraries(xrpl.libxrpl.core PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json
-                                               xrpl.libxrpl.protocol)
+## Set up code generation for protocol_autogen module
+include(XrplProtocolAutogen)
+setup_protocol_autogen()
+
+add_module(xrpl protocol_autogen)
+target_link_libraries(xrpl.libxrpl.protocol_autogen PUBLIC xrpl.libxrpl.protocol)
 
 # Level 06
+add_module(xrpl core)
+target_link_libraries(xrpl.libxrpl.core PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json
+                                               xrpl.libxrpl.protocol xrpl.libxrpl.protocol_autogen)
+
+# Level 07
 add_module(xrpl resource)
 target_link_libraries(xrpl.libxrpl.resource PUBLIC xrpl.libxrpl.protocol)
 
-# Level 07
+# Level 08
 add_module(xrpl net)
 target_link_libraries(xrpl.libxrpl.net PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json
                                               xrpl.libxrpl.protocol xrpl.libxrpl.resource)
@@ -111,6 +126,7 @@ target_link_libraries(
     PUBLIC xrpl.libxrpl.basics
            xrpl.libxrpl.json
            xrpl.libxrpl.protocol
+           xrpl.libxrpl.protocol_autogen
            xrpl.libxrpl.rdb
            xrpl.libxrpl.server
            xrpl.libxrpl.shamap
@@ -135,11 +151,13 @@ target_link_modules(
     conditions
     core
     crypto
+    git
     json
     ledger
     net
     nodestore
     protocol
+    protocol_autogen
     rdb
     resource
     server

cmake/XrplInstall.cmake

@@ -23,12 +23,14 @@ install(TARGETS common
                 xrpl.libxrpl.conditions
                 xrpl.libxrpl.core
                 xrpl.libxrpl.crypto
+                xrpl.libxrpl.git
                 xrpl.libxrpl.json
                 xrpl.libxrpl.rdb
                 xrpl.libxrpl.ledger
                 xrpl.libxrpl.net
                 xrpl.libxrpl.nodestore
                 xrpl.libxrpl.protocol
+                xrpl.libxrpl.protocol_autogen
                 xrpl.libxrpl.resource
                 xrpl.libxrpl.server
                 xrpl.libxrpl.shamap

cmake/XrplProtocolAutogen.cmake

@@ -0,0 +1,155 @@
+#[===================================================================[
+   Protocol Autogen - Code generation for protocol wrapper classes
+#]===================================================================]
+
+# Options for code generation
+set(CODEGEN_VENV_DIR
+    ""
+    CACHE PATH
+          "Path to Python virtual environment for code generation. If provided, automatic venv setup is skipped."
+)
+
+# Function to set up code generation for protocol_autogen module
+# This runs at configure time to generate C++ wrapper classes from macro files
+function (setup_protocol_autogen)
+    # Directory paths
+    set(MACRO_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include/xrpl/protocol/detail")
+    set(AUTOGEN_HEADER_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include/xrpl/protocol_autogen")
+    set(SCRIPTS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/scripts")
+
+    # Input macro files
+    set(TRANSACTIONS_MACRO "${MACRO_DIR}/transactions.macro")
+    set(LEDGER_ENTRIES_MACRO "${MACRO_DIR}/ledger_entries.macro")
+    set(SFIELDS_MACRO "${MACRO_DIR}/sfields.macro")
+
+    # Python scripts
+    set(GENERATE_TX_SCRIPT "${SCRIPTS_DIR}/generate_tx_classes.py")
+    set(GENERATE_LEDGER_SCRIPT "${SCRIPTS_DIR}/generate_ledger_classes.py")
+    set(REQUIREMENTS_FILE "${SCRIPTS_DIR}/requirements.txt")
+
+    # Create output directories
+    file(MAKE_DIRECTORY "${AUTOGEN_HEADER_DIR}/transactions")
+    file(MAKE_DIRECTORY "${AUTOGEN_HEADER_DIR}/ledger_objects")
+
+    # Find Python3 - check if already found by Conan or find it ourselves
+    if (NOT Python3_EXECUTABLE)
+        find_package(Python3 COMPONENTS Interpreter QUIET)
+    endif ()
+
+    if (NOT Python3_EXECUTABLE)
+        # Try finding python3 executable directly
+        find_program(Python3_EXECUTABLE NAMES python3 python)
+    endif ()
+
+    if (NOT Python3_EXECUTABLE)
+        message(FATAL_ERROR "Python3 not found. Code generation cannot proceed.")
+        return()
+    endif ()
+
+    message(STATUS "Using Python3 for code generation: ${Python3_EXECUTABLE}")
+
+    # Set up Python virtual environment for code generation
+    if (CODEGEN_VENV_DIR)
+        # User-provided venv - skip automatic setup
+        set(VENV_DIR "${CODEGEN_VENV_DIR}")
+        message(STATUS "Using user-provided Python venv: ${VENV_DIR}")
+    else ()
+        # Use default venv in build directory
+        set(VENV_DIR "${CMAKE_CURRENT_BINARY_DIR}/codegen_venv")
+    endif ()
+
+    # Determine the Python executable path in the venv
+    if (WIN32)
+        set(VENV_PYTHON "${VENV_DIR}/Scripts/python.exe")
+        set(VENV_PIP "${VENV_DIR}/Scripts/pip.exe")
+    else ()
+        set(VENV_PYTHON "${VENV_DIR}/bin/python")
+        set(VENV_PIP "${VENV_DIR}/bin/pip")
+    endif ()
+
+    # Only auto-setup venv if not user-provided
+    if (NOT CODEGEN_VENV_DIR)
+        # Check if venv needs to be created or updated
+        set(VENV_NEEDS_UPDATE FALSE)
+        if (NOT EXISTS "${VENV_PYTHON}")
+            set(VENV_NEEDS_UPDATE TRUE)
+            message(STATUS "Creating Python virtual environment for code generation...")
+        elseif ("${REQUIREMENTS_FILE}" IS_NEWER_THAN "${VENV_DIR}/.requirements_installed")
+            set(VENV_NEEDS_UPDATE TRUE)
+            message(STATUS "Updating Python virtual environment (requirements changed)...")
+        endif ()
+
+        # Create/update virtual environment if needed
+        if (VENV_NEEDS_UPDATE)
+            message(STATUS "Setting up Python virtual environment at ${VENV_DIR}")
+            execute_process(COMMAND ${Python3_EXECUTABLE} -m venv "${VENV_DIR}"
+                            RESULT_VARIABLE VENV_RESULT ERROR_VARIABLE VENV_ERROR)
+            if (NOT VENV_RESULT EQUAL 0)
+                message(FATAL_ERROR "Failed to create virtual environment: ${VENV_ERROR}")
+            endif ()
+
+            message(STATUS "Installing Python dependencies...")
+            execute_process(COMMAND ${VENV_PIP} install --upgrade pip
+                            RESULT_VARIABLE PIP_UPGRADE_RESULT OUTPUT_QUIET
+                            ERROR_VARIABLE PIP_UPGRADE_ERROR)
+            if (NOT PIP_UPGRADE_RESULT EQUAL 0)
+                message(WARNING "Failed to upgrade pip: ${PIP_UPGRADE_ERROR}")
+            endif ()
+
+            execute_process(COMMAND ${VENV_PIP} install -r "${REQUIREMENTS_FILE}"
+                            RESULT_VARIABLE PIP_INSTALL_RESULT ERROR_VARIABLE PIP_INSTALL_ERROR)
+            if (NOT PIP_INSTALL_RESULT EQUAL 0)
+                message(FATAL_ERROR "Failed to install Python dependencies: ${PIP_INSTALL_ERROR}")
+            endif ()
+
+            # Mark requirements as installed
+            file(TOUCH "${VENV_DIR}/.requirements_installed")
+            message(STATUS "Python virtual environment ready")
+        endif ()
+    endif ()
+
+    # Generate transaction classes at configure time
+    message(STATUS "Generating transaction classes from transactions.macro...")
+    execute_process(COMMAND ${VENV_PYTHON} "${GENERATE_TX_SCRIPT}" "${TRANSACTIONS_MACRO}"
+                            --header-dir "${AUTOGEN_HEADER_DIR}/transactions" --sfields-macro
+                            "${SFIELDS_MACRO}"
+                    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+                    RESULT_VARIABLE TX_GEN_RESULT
+                    OUTPUT_VARIABLE TX_GEN_OUTPUT
+                    ERROR_VARIABLE TX_GEN_ERROR)
+    if (NOT TX_GEN_RESULT EQUAL 0)
+        message(FATAL_ERROR "Failed to generate transaction classes:\n${TX_GEN_ERROR}")
+    else ()
+        message(STATUS "Transaction classes generated successfully")
+    endif ()
+
+    # Generate ledger entry classes at configure time
+    message(STATUS "Generating ledger entry classes from ledger_entries.macro...")
+    execute_process(COMMAND ${VENV_PYTHON} "${GENERATE_LEDGER_SCRIPT}" "${LEDGER_ENTRIES_MACRO}"
+                            --header-dir "${AUTOGEN_HEADER_DIR}/ledger_objects" --sfields-macro
+                            "${SFIELDS_MACRO}"
+                    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+                    RESULT_VARIABLE LEDGER_GEN_RESULT
+                    OUTPUT_VARIABLE LEDGER_GEN_OUTPUT
+                    ERROR_VARIABLE LEDGER_GEN_ERROR)
+    if (NOT LEDGER_GEN_RESULT EQUAL 0)
+        message(FATAL_ERROR "Failed to generate ledger entry classes:\n${LEDGER_GEN_ERROR}")
+    else ()
+        message(STATUS "Ledger entry classes generated successfully")
+    endif ()
+
+    # Register dependencies so CMake reconfigures when these files change
+    set_property(DIRECTORY
+                 APPEND
+                 PROPERTY CMAKE_CONFIGURE_DEPENDS
+                          "${TRANSACTIONS_MACRO}"
+                          "${LEDGER_ENTRIES_MACRO}"
+                          "${SFIELDS_MACRO}"
+                          "${GENERATE_TX_SCRIPT}"
+                          "${GENERATE_LEDGER_SCRIPT}"
+                          "${SCRIPTS_DIR}/macro_parser_common.py"
+                          "${SCRIPTS_DIR}/templates/Transaction.h.mako"
+                          "${SCRIPTS_DIR}/templates/LedgerEntry.h.mako"
+                          "${REQUIREMENTS_FILE}")
+
+endfunction ()

cspell.config.yaml

@@ -71,7 +71,6 @@ words:
   - coldwallet
   - compr
   - conanfile
-  - cppcoro
   - conanrun
   - confs
   - connectability
@@ -102,11 +101,9 @@ words:
   - Falco
   - finalizers
   - firewalled
-  - fcontext
   - fmtdur
   - fsanitize
   - funclets
-  - gantt
   - gcov
   - gcovr
   - ghead
@@ -179,6 +176,8 @@ words:
   - nixfmt
   - nixos
   - nixpkgs
+  - NOLINT
+  - NOLINTNEXTLINE
   - nonxrp
   - noripple
   - nudb
@@ -188,7 +187,6 @@ words:
   - ostr
   - pargs
   - partitioner
-  - pratik
   - paychan
   - paychans
   - permdex
@@ -210,7 +208,6 @@ words:
   - queuable
   - Raphson
   - replayer
-  - repost
   - rerere
   - retriable
   - RIPD
@@ -241,7 +238,6 @@ words:
   - soci
   - socidb
   - sslws
-  - stackful
   - statsd
   - STATSDCOLLECTOR
   - stissue

include/xrpl/beast/core/SemanticVersion.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <string>
+#include <string_view>
 #include <vector>
 
 namespace beast {
@@ -26,14 +27,14 @@ public:
 
     SemanticVersion();
 
-    SemanticVersion(std::string const& version);
+    SemanticVersion(std::string_view version);
 
     /** Parse a semantic version string.
         The parsing is as strict as possible.
         @return `true` if the string was parsed.
     */
     bool
-    parse(std::string const& input);
+    parse(std::string_view input);
 
     /** Produce a string from semantic version components. */
     std::string

include/xrpl/core/CoroTask.h

@@ -1,687 +0,0 @@
-#pragma once
-
-#include <coroutine>
-#include <exception>
-#include <utility>
-#include <variant>
-
-namespace xrpl {
-
-template <typename T = void>
-class CoroTask;
-
-/**
- * CoroTask<void> -- coroutine return type for void-returning coroutines.
- *
- * Class / Dependency Diagram
- * ==========================
- *
- *   CoroTask<void>
- *   +-----------------------------------------------+
- *   | - handle_ : Handle (coroutine_handle<promise>) |
- *   +-----------------------------------------------+
- *   | + handle(), done()                             |
- *   | + await_ready/suspend/resume  (Awaiter iface)  |
- *   +-----------------------------------------------+
- *            |  owns
- *            v
- *   promise_type
- *   +-----------------------------------------------+
- *   | - exception_    : std::exception_ptr           |
- *   | - continuation_ : std::coroutine_handle<>      |
- *   +-----------------------------------------------+
- *   | + get_return_object() -> CoroTask              |
- *   | + initial_suspend()   -> suspend_always (lazy) |
- *   | + final_suspend()     -> FinalAwaiter          |
- *   | + return_void()                                |
- *   | + unhandled_exception()                        |
- *   +-----------------------------------------------+
- *            |  returns at final_suspend
- *            v
- *   FinalAwaiter
- *   +-----------------------------------------------+
- *   | await_suspend(h):                              |
- *   |   if continuation_ set -> symmetric transfer   |
- *   |   else                 -> noop_coroutine        |
- *   +-----------------------------------------------+
- *
- * Design Notes
- * ------------
- * - Lazy start: initial_suspend returns suspend_always, so the coroutine
- *   body does not execute until the handle is explicitly resumed.
- * - Symmetric transfer: await_suspend returns a coroutine_handle instead
- *   of void/bool, allowing the scheduler to jump directly to the next
- *   coroutine without growing the call stack.
- * - Continuation chaining: when one CoroTask is co_await-ed inside
- *   another, the caller's handle is stored as continuation_ so
- *   FinalAwaiter can resume it when this task finishes.
- * - Move-only: the handle is exclusively owned; copy is deleted.
- *
- * Usage Examples
- * ==============
- *
- * 1. Basic void coroutine (the most common case in rippled):
- *
- *      CoroTask<void> doWork(std::shared_ptr<CoroTaskRunner> runner) {
- *          // do something
- *          co_await runner->suspend();   // yield control
- *          // resumed later via runner->post() or runner->resume()
- *          co_return;
- *      }
- *
- * 2. co_await-ing one CoroTask<void> from another (chaining):
- *
- *      CoroTask<void> inner() {
- *          // ...
- *          co_return;
- *      }
- *      CoroTask<void> outer() {
- *          co_await inner();   // continuation_ links outer -> inner
- *          co_return;          // FinalAwaiter resumes outer
- *      }
- *
- * 3. Exceptions propagate through co_await:
- *
- *      CoroTask<void> failing() {
- *          throw std::runtime_error("oops");
- *          co_return;
- *      }
- *      CoroTask<void> caller() {
- *          try { co_await failing(); }
- *          catch (std::runtime_error const&) { // caught here }
- *      }
- *
- * Caveats / Pitfalls
- * ==================
- *
- * BUG-RISK: Dangling references in coroutine parameters.
- *   Coroutine parameters are copied into the frame, but references
- *   are NOT -- they are stored as-is. If the referent goes out of scope
- *   before the coroutine finishes, you get use-after-free.
- *
- *      // BROKEN -- local dies before coroutine runs:
- *      CoroTask<void> bad(int& ref) { co_return; }
- *      void launch() {
- *          int local = 42;
- *          auto task = bad(local);  // frame stores &local
- *      }  // local destroyed; frame holds dangling ref
- *
- *      // FIX -- pass by value, or ensure lifetime via shared_ptr.
- *
- * BUG-RISK: GCC 14 corrupts reference captures in coroutine lambdas.
- *   When a lambda that returns CoroTask captures by reference ([&]),
- *   GCC 14 may generate a corrupted coroutine frame. Always capture
- *   by explicit pointer-to-value instead:
- *
- *      // BROKEN on GCC 14:
- *      jq.postCoroTask(t, n, [&](auto) -> CoroTask<void> { ... });
- *
- *      // FIX -- capture pointers explicitly:
- *      jq.postCoroTask(t, n, [ptr = &val](auto) -> CoroTask<void> { ... });
- *
- * BUG-RISK: Resuming a destroyed or completed CoroTask.
- *   Calling handle().resume() after the coroutine has already run to
- *   completion (done() == true) is undefined behavior. The CoroTaskRunner
- *   guards against this with an XRPL_ASSERT, but standalone usage of
- *   CoroTask must check done() before resuming.
- *
- * BUG-RISK: Moving a CoroTask that is being awaited.
- *   If task A is co_await-ed by task B (so A.continuation_ == B), moving
- *   or destroying A will invalidate the continuation link. Never move
- *   or reassign a CoroTask while it is mid-execution or being awaited.
- *
- * LIMITATION: CoroTask is fire-and-forget for the top-level owner.
- *   There is no built-in notification when the coroutine finishes.
- *   The caller must use external synchronization (e.g. CoroTaskRunner::join
- *   or a gate/condition_variable) to know when it is done.
- *
- * LIMITATION: No cancellation token.
- *   There is no way to cancel a suspended CoroTask from outside. The
- *   coroutine body must cooperatively check a flag (e.g. jq_.isStopping())
- *   after each co_await and co_return early if needed.
- *
- * LIMITATION: Stackless -- cannot suspend from nested non-coroutine calls.
- *   If a coroutine calls a regular function that wants to "yield", it
- *   cannot. Only the immediate coroutine body can use co_await.
- *   This is acceptable for rippled because all yield() sites are shallow.
- */
-template <>
-class CoroTask<void>
-{
-public:
-    struct promise_type;
-    using Handle = std::coroutine_handle<promise_type>;
-
-    /**
-     * Coroutine promise. Compiler uses this to manage coroutine state.
-     * Stores the exception (if any) and the continuation handle for
-     * symmetric transfer back to the awaiting coroutine.
-     */
-    struct promise_type
-    {
-        // Captured exception from the coroutine body, rethrown in
-        // await_resume() when this task is co_await-ed by a caller.
-        std::exception_ptr exception_;
-
-        // Handle to the coroutine that is co_await-ing this task.
-        // Set by await_suspend(). FinalAwaiter uses it for symmetric
-        // transfer back to the caller. Null if this is a top-level task.
-        std::coroutine_handle<> continuation_;
-
-        /**
-         * Create the CoroTask return object.
-         * Called by the compiler at coroutine creation.
-         */
-        CoroTask
-        get_return_object()
-        {
-            return CoroTask{Handle::from_promise(*this)};
-        }
-
-        /**
-         * Lazy start. The coroutine body does not execute until the
-         * handle is explicitly resumed (e.g. by CoroTaskRunner::resume).
-         */
-        std::suspend_always
-        initial_suspend() noexcept
-        {
-            return {};
-        }
-
-        /**
-         * Awaiter returned by final_suspend(). Uses symmetric transfer:
-         * if a continuation exists, transfers control directly to it
-         * (tail-call, no stack growth). Otherwise returns noop_coroutine
-         * so the coroutine frame stays alive for the owner to destroy.
-         */
-        struct FinalAwaiter
-        {
-            /**
-             * Always false. We need await_suspend to run for
-             * symmetric transfer.
-             */
-            bool
-            await_ready() noexcept
-            {
-                return false;
-            }
-
-            /**
-             * Symmetric transfer: returns the continuation handle so
-             * the compiler emits a tail-call instead of a nested resume.
-             * If no continuation is set, returns noop_coroutine to
-             * suspend at final_suspend without destroying the frame.
-             *
-             * @param h Handle to this completing coroutine
-             *
-             * @return Continuation handle, or noop_coroutine
-             */
-            std::coroutine_handle<>
-            await_suspend(Handle h) noexcept
-            {
-                if (auto cont = h.promise().continuation_)
-                    return cont;
-                return std::noop_coroutine();
-            }
-
-            void
-            await_resume() noexcept
-            {
-            }
-        };
-
-        /**
-         * Returns FinalAwaiter for symmetric transfer at coroutine end.
-         */
-        FinalAwaiter
-        final_suspend() noexcept
-        {
-            return {};
-        }
-
-        /**
-         * Called by the compiler for `co_return;` (void coroutine).
-         */
-        void
-        return_void()
-        {
-        }
-
-        /**
-         * Called by the compiler when an exception escapes the coroutine
-         * body. Captures it for later rethrowing in await_resume().
-         */
-        void
-        unhandled_exception()
-        {
-            exception_ = std::current_exception();
-        }
-    };
-
-    /**
-     * Default constructor. Creates an empty (null handle) task.
-     */
-    CoroTask() = default;
-
-    /**
-     * Takes ownership of a compiler-generated coroutine handle.
-     *
-     * @param h Coroutine handle to own
-     */
-    explicit CoroTask(Handle h) : handle_(h)
-    {
-    }
-
-    /**
-     * Destroys the coroutine frame if this task owns one.
-     */
-    ~CoroTask()
-    {
-        if (handle_)
-            handle_.destroy();
-    }
-
-    /**
-     * Move constructor. Transfers handle ownership, leaves other empty.
-     */
-    CoroTask(CoroTask&& other) noexcept : handle_(std::exchange(other.handle_, {}))
-    {
-    }
-
-    /**
-     * Move assignment. Destroys current frame (if any), takes other's.
-     */
-    CoroTask&
-    operator=(CoroTask&& other) noexcept
-    {
-        if (this != &other)
-        {
-            if (handle_)
-                handle_.destroy();
-            handle_ = std::exchange(other.handle_, {});
-        }
-        return *this;
-    }
-
-    CoroTask(CoroTask const&) = delete;
-    CoroTask&
-    operator=(CoroTask const&) = delete;
-
-    /**
-     * @return The underlying coroutine_handle
-     */
-    Handle
-    handle() const
-    {
-        return handle_;
-    }
-
-    /**
-     * @return true if the coroutine has run to completion (or thrown)
-     */
-    bool
-    done() const
-    {
-        return handle_ && handle_.done();
-    }
-
-    // -- Awaiter interface: allows `co_await someCoroTask;` --
-
-    /**
-     * Always false. This task is lazy, so co_await always suspends
-     * the caller to set up the continuation link.
-     */
-    bool
-    await_ready() const noexcept
-    {
-        return false;
-    }
-
-    /**
-     * Stores the caller's handle as our continuation, then returns
-     * our handle for symmetric transfer (caller suspends, we resume).
-     *
-     * @param caller Handle of the coroutine doing co_await on us
-     *
-     * @return Our handle for symmetric transfer
-     */
-    std::coroutine_handle<>
-    await_suspend(std::coroutine_handle<> caller) noexcept
-    {
-        handle_.promise().continuation_ = caller;
-        return handle_;  // Symmetric transfer
-    }
-
-    /**
-     * Called when the caller resumes after co_await. Rethrows any
-     * exception captured by unhandled_exception().
-     */
-    void
-    await_resume()
-    {
-        if (auto& ep = handle_.promise().exception_)
-            std::rethrow_exception(ep);
-    }
-
-private:
-    // Exclusively-owned coroutine handle. Null after move or default
-    // construction. Destroyed in the destructor.
-    Handle handle_;
-};
-
-/**
- * CoroTask<T> -- coroutine return type for value-returning coroutines.
- *
- * Class / Dependency Diagram
- * ==========================
- *
- *   CoroTask<T>
- *   +-----------------------------------------------+
- *   | - handle_ : Handle (coroutine_handle<promise>) |
- *   +-----------------------------------------------+
- *   | + handle(), done()                             |
- *   | + await_ready/suspend/resume  (Awaiter iface)  |
- *   +-----------------------------------------------+
- *            |  owns
- *            v
- *   promise_type
- *   +-----------------------------------------------+
- *   | - result_       : variant<monostate, T,        |
- *   |                           exception_ptr>       |
- *   | - continuation_ : std::coroutine_handle<>      |
- *   +-----------------------------------------------+
- *   | + get_return_object() -> CoroTask              |
- *   | + initial_suspend()   -> suspend_always (lazy) |
- *   | + final_suspend()     -> FinalAwaiter          |
- *   | + return_value(T)     -> stores in result_[1]  |
- *   | + unhandled_exception -> stores in result_[2]  |
- *   +-----------------------------------------------+
- *            |  returns at final_suspend
- *            v
- *   FinalAwaiter  (same symmetric-transfer pattern as CoroTask<void>)
- *
- * Value Extraction
- * ----------------
- * await_resume() inspects the variant:
- *   - index 2 (exception_ptr) -> rethrow
- *   - index 1 (T)             -> return value via move
- *
- * Usage Examples
- * ==============
- *
- * 1. Simple value return:
- *
- *      CoroTask<int> computeAnswer() { co_return 42; }
- *
- *      CoroTask<void> caller() {
- *          int v = co_await computeAnswer();  // v == 42
- *      }
- *
- * 2. Chaining value-returning coroutines:
- *
- *      CoroTask<int> add(int a, int b) { co_return a + b; }
- *      CoroTask<int> doubleSum(int a, int b) {
- *          int s = co_await add(a, b);
- *          co_return s * 2;
- *      }
- *
- * 3. Exception propagation from inner to outer:
- *
- *      CoroTask<int> failing() {
- *          throw std::runtime_error("bad");
- *          co_return 0;  // never reached
- *      }
- *      CoroTask<void> caller() {
- *          try {
- *              int v = co_await failing();  // throws here
- *          } catch (std::runtime_error const& e) {
- *              // e.what() == "bad"
- *          }
- *      }
- *
- * Caveats / Pitfalls (in addition to CoroTask<void> caveats above)
- * ================================================================
- *
- * BUG-RISK: await_resume() moves the value out of the variant.
- *   Calling co_await on the same CoroTask<T> instance twice is undefined
- *   behavior -- the second call will see a moved-from T. CoroTask is
- *   single-shot: one co_return, one co_await.
- *
- * BUG-RISK: T must be move-constructible.
- *   return_value(T) takes by value and moves into the variant.
- *   Types that are not movable cannot be used as T.
- *
- * LIMITATION: No co_yield support.
- *   CoroTask<T> only supports a single co_return. It does not implement
- *   yield_value(), so using co_yield inside a CoroTask<T> coroutine is a
- *   compile error. For streaming values, a different return type
- *   (e.g. Generator<T>) would be needed.
- *
- * LIMITATION: Result is only accessible via co_await.
- *   There is no .get() or .result() method. The value can only be
- *   extracted by co_await-ing the CoroTask<T> from inside another
- *   coroutine. For extracting results in non-coroutine code, pass a
- *   pointer to the caller and write through it (as the tests do).
- */
-template <typename T>
-class CoroTask
-{
-public:
-    struct promise_type;
-    using Handle = std::coroutine_handle<promise_type>;
-
-    /**
-     * Coroutine promise for value-returning coroutines.
-     * Stores the result as a variant: monostate (not yet set),
-     * T (co_return value), or exception_ptr (unhandled exception).
-     */
-    struct promise_type
-    {
-        // Tri-state result:
-        //   index 0 (monostate) -- coroutine has not yet completed
-        //   index 1 (T)         -- co_return value stored here
-        //   index 2 (exception) -- unhandled exception captured here
-        std::variant<std::monostate, T, std::exception_ptr> result_;
-
-        // Handle to the coroutine co_await-ing this task. Used by
-        // FinalAwaiter for symmetric transfer. Null for top-level tasks.
-        std::coroutine_handle<> continuation_;
-
-        /**
-         * Create the CoroTask return object.
-         * Called by the compiler at coroutine creation.
-         */
-        CoroTask
-        get_return_object()
-        {
-            return CoroTask{Handle::from_promise(*this)};
-        }
-
-        /**
-         * Lazy start. Coroutine body does not run until explicitly resumed.
-         */
-        std::suspend_always
-        initial_suspend() noexcept
-        {
-            return {};
-        }
-
-        /**
-         * Symmetric-transfer awaiter at coroutine completion.
-         * Same pattern as CoroTask<void>::FinalAwaiter.
-         */
-        struct FinalAwaiter
-        {
-            bool
-            await_ready() noexcept
-            {
-                return false;
-            }
-
-            /**
-             * Returns continuation for symmetric transfer, or
-             * noop_coroutine if this is a top-level task.
-             *
-             * @param h Handle to this completing coroutine
-             *
-             * @return Continuation handle, or noop_coroutine
-             */
-            std::coroutine_handle<>
-            await_suspend(Handle h) noexcept
-            {
-                if (auto cont = h.promise().continuation_)
-                    return cont;
-                return std::noop_coroutine();
-            }
-
-            void
-            await_resume() noexcept
-            {
-            }
-        };
-
-        FinalAwaiter
-        final_suspend() noexcept
-        {
-            return {};
-        }
-
-        /**
-         * Called by the compiler for `co_return value;`.
-         * Moves the value into result_ at index 1.
-         *
-         * @param value The value to store
-         */
-        void
-        return_value(T value)
-        {
-            result_.template emplace<1>(std::move(value));
-        }
-
-        /**
-         * Captures unhandled exceptions at index 2 of result_.
-         * Rethrown later in await_resume().
-         */
-        void
-        unhandled_exception()
-        {
-            result_.template emplace<2>(std::current_exception());
-        }
-    };
-
-    /**
-     * Default constructor. Creates an empty (null handle) task.
-     */
-    CoroTask() = default;
-
-    /**
-     * Takes ownership of a compiler-generated coroutine handle.
-     *
-     * @param h Coroutine handle to own
-     */
-    explicit CoroTask(Handle h) : handle_(h)
-    {
-    }
-
-    /**
-     * Destroys the coroutine frame if this task owns one.
-     */
-    ~CoroTask()
-    {
-        if (handle_)
-            handle_.destroy();
-    }
-
-    /**
-     * Move constructor. Transfers handle ownership, leaves other empty.
-     */
-    CoroTask(CoroTask&& other) noexcept : handle_(std::exchange(other.handle_, {}))
-    {
-    }
-
-    /**
-     * Move assignment. Destroys current frame (if any), takes other's.
-     */
-    CoroTask&
-    operator=(CoroTask&& other) noexcept
-    {
-        if (this != &other)
-        {
-            if (handle_)
-                handle_.destroy();
-            handle_ = std::exchange(other.handle_, {});
-        }
-        return *this;
-    }
-
-    CoroTask(CoroTask const&) = delete;
-    CoroTask&
-    operator=(CoroTask const&) = delete;
-
-    /**
-     * @return The underlying coroutine_handle
-     */
-    Handle
-    handle() const
-    {
-        return handle_;
-    }
-
-    /**
-     * @return true if the coroutine has run to completion (or thrown)
-     */
-    bool
-    done() const
-    {
-        return handle_ && handle_.done();
-    }
-
-    // -- Awaiter interface: allows `T val = co_await someCoroTask;` --
-
-    /**
-     * Always false. co_await always suspends to set up continuation.
-     */
-    bool
-    await_ready() const noexcept
-    {
-        return false;
-    }
-
-    /**
-     * Stores caller as continuation, returns our handle for
-     * symmetric transfer.
-     *
-     * @param caller Handle of the coroutine doing co_await on us
-     *
-     * @return Our handle for symmetric transfer
-     */
-    std::coroutine_handle<>
-    await_suspend(std::coroutine_handle<> caller) noexcept
-    {
-        handle_.promise().continuation_ = caller;
-        return handle_;
-    }
-
-    /**
-     * Extracts the result: rethrows if exception, otherwise moves
-     * the T value out of the variant. Single-shot: calling twice
-     * on the same task is undefined (moved-from T).
-     *
-     * @return The co_return-ed value
-     */
-    T
-    await_resume()
-    {
-        auto& result = handle_.promise().result_;
-        if (auto* ep = std::get_if<2>(&result))
-            std::rethrow_exception(*ep);
-        return std::get<1>(std::move(result));
-    }
-
-private:
-    // Exclusively-owned coroutine handle. Null after move or default
-    // construction. Destroyed in the destructor.
-    Handle handle_;
-};
-
-}  // namespace xrpl

include/xrpl/core/CoroTaskRunner.ipp

@@ -1,329 +0,0 @@
-#pragma once
-
-/**
- * @file CoroTaskRunner.ipp
- *
- * CoroTaskRunner inline implementation.
- *
- * This file contains the business logic for managing C++20 coroutines
- * on the JobQueue. It is included at the bottom of JobQueue.h.
- *
- * Data Flow: suspend / post / resume cycle
- * =========================================
- *
- *         coroutine body                 CoroTaskRunner              JobQueue
- *         --------------                 --------------              --------
- *              |
- *    co_await runner->suspend()
- *              |
- *              +--- await_suspend ------> onSuspend()
- *              |                            ++nSuspend_ ------------> nSuspend_
- *              |                          [coroutine is now suspended]
- *              |
- *              .    (externally or by JobQueueAwaiter)
- *              .
- *              +--- (caller calls) -----> post()
- *              |                            ++runCount_
- *              |                            addJob(resume) ----------> job enqueued
- *              |                                                        |
- *              |                                                      [worker picks up]
- *              |                                                        |
- *              +--- <----- resume() <-----------------------------------+
- *              |             --nSuspend_ ------> nSuspend_
- *              |             swap in LocalValues (lvs_)
- *              |             task_.handle().resume()
- *              |                |
- *              |    [coroutine body continues here]
- *              |                |
- *              |             swap out LocalValues
- *              |             --runCount_
- *              |             cv_.notify_all()
- *              v
- *
- * Thread Safety
- * =============
- * - mutex_     : guards task_.handle().resume() so that post()-before-suspend
- *                races cannot resume the coroutine while it is still running.
- *                (See the race condition discussion in JobQueue.h)
- * - mutex_run_ : guards runCount_ counter; used by join() to wait until
- *                all in-flight resume operations complete.
- * - jq_.m_mutex: guards nSuspend_ increments/decrements.
- *
- * Common Mistakes When Modifying This File
- * =========================================
- *
- * 1. Changing lock ordering.
- *    resume() acquires locks in this order: jq_.m_mutex -> mutex_ -> mutex_run_.
- *    post() acquires only mutex_run_. Any new code path that touches these
- *    mutexes must follow the same order to avoid deadlocks.
- *
- * 2. Removing the shared_from_this() capture in post().
- *    The lambda passed to addJob captures [this, sp = shared_from_this()].
- *    If you remove sp, 'this' can be destroyed before the job runs,
- *    causing use-after-free. The sp capture is load-bearing.
- *
- * 3. Forgetting to decrement nSuspend_ on a new code path.
- *    Every ++nSuspend_ must have a matching --nSuspend_. If you add a new
- *    suspension path (e.g. a new awaiter) and forget to decrement on resume
- *    or on failure, JobQueue::stop() will hang.
- *
- * 4. Calling task_.handle().resume() without holding mutex_.
- *    This allows a race where the coroutine runs on two threads
- *    simultaneously. Always hold mutex_ around resume().
- *
- * 5. Swapping LocalValues outside of the mutex_ critical section.
- *    The swap-in and swap-out of LocalValues must bracket the resume()
- *    call. If you move the swap-out before the lock_guard(mutex_) is
- *    released, you break LocalValue isolation for any code that runs
- *    after the coroutine suspends but before the lock is dropped.
- */
-//
-
-namespace xrpl {
-
-/**
- * Construct a CoroTaskRunner. Sets runCount_ to 0; does not
- * create the coroutine. Call init() afterwards.
- *
- * @param jq   The JobQueue this coroutine will run on
- * @param type Job type for scheduling priority
- * @param name Human-readable name for logging
- */
-inline JobQueue::CoroTaskRunner::CoroTaskRunner(
-    create_t,
-    JobQueue& jq,
-    JobType type,
-    std::string const& name)
-    : jq_(jq), type_(type), name_(name), runCount_(0)
-{
-}
-
-/**
- * Initialize with a coroutine-returning callable.
- * Stores the callable on the heap (FuncStore) so it outlives the
- * coroutine frame. Coroutine frames store a reference to the
- * callable's implicit object parameter (the lambda). If the callable
- * is a temporary, that reference dangles after the caller returns.
- * Keeping the callable alive here ensures the coroutine's captures
- * remain valid.
- *
- * @param f Callable: CoroTask<void>(shared_ptr<CoroTaskRunner>)
- */
-template <class F>
-void
-JobQueue::CoroTaskRunner::init(F&& f)
-{
-    using Fn = std::decay_t<F>;
-    auto store = std::make_unique<FuncStore<Fn>>(std::forward<F>(f));
-    task_ = store->func(shared_from_this());
-    storedFunc_ = std::move(store);
-}
-
-/**
- * Destructor. Waits for any in-flight resume() to complete, then
- * asserts (debug) that the coroutine has finished or
- * expectEarlyExit() was called.
- *
- * The join() call is necessary because with async dispatch the
- * coroutine runs on a worker thread. The gate signal (which wakes
- * the test thread) can arrive before resume() has set finished_.
- * join() synchronizes via mutex_run_, establishing a happens-before
- * edge: finished_ = true → unlock(mutex_run_) in resume() →
- * lock(mutex_run_) in join() → read finished_.
- */
-inline JobQueue::CoroTaskRunner::~CoroTaskRunner()
-{
-#ifndef NDEBUG
-    join();
-    XRPL_ASSERT(finished_, "xrpl::JobQueue::CoroTaskRunner::~CoroTaskRunner : is finished");
-#endif
-}
-
-/**
- * Increment the JobQueue's suspended-coroutine count (nSuspend_).
- */
-inline void
-JobQueue::CoroTaskRunner::onSuspend()
-{
-    std::lock_guard lock(jq_.m_mutex);
-    ++jq_.nSuspend_;
-}
-
-/**
- * Decrement nSuspend_ without resuming.
- */
-inline void
-JobQueue::CoroTaskRunner::onUndoSuspend()
-{
-    std::lock_guard lock(jq_.m_mutex);
-    --jq_.nSuspend_;
-}
-
-/**
- * Return a SuspendAwaiter whose await_suspend() increments nSuspend_
- * before the coroutine actually suspends. The caller must later call
- * post() or resume() to continue execution.
- *
- * @return Awaiter for use with `co_await runner->suspend()`
- */
-inline auto
-JobQueue::CoroTaskRunner::suspend()
-{
-    /**
-     * Custom awaiter for suspend(). Always suspends (await_ready
-     * returns false) and increments nSuspend_ in await_suspend().
-     */
-    struct SuspendAwaiter
-    {
-        CoroTaskRunner& runner_;  // The runner that owns this coroutine.
-
-        /**
-         * Always returns false so the coroutine suspends.
-         */
-        bool
-        await_ready() const noexcept
-        {
-            return false;
-        }
-
-        /**
-         * Called when the coroutine suspends. Increments nSuspend_
-         * so the JobQueue knows a coroutine is waiting.
-         */
-        void
-        await_suspend(std::coroutine_handle<>) const
-        {
-            runner_.onSuspend();
-        }
-
-        void
-        await_resume() const noexcept
-        {
-        }
-    };
-    return SuspendAwaiter{*this};
-}
-
-/**
- * Schedule coroutine resumption as a job on the JobQueue.
- * A shared_ptr capture (sp) prevents this CoroTaskRunner from being
- * destroyed while the job is queued but not yet executed.
- *
- * @return false if the JobQueue rejected the job (shutting down)
- */
-inline bool
-JobQueue::CoroTaskRunner::post()
-{
-    {
-        std::lock_guard lk(mutex_run_);
-        ++runCount_;
-    }
-
-    // sp prevents 'this' from being destroyed while the job is pending
-    if (jq_.addJob(type_, name_, [this, sp = shared_from_this()]() { resume(); }))
-    {
-        return true;
-    }
-
-    // The coroutine will not run. Undo the runCount_ increment.
-    std::lock_guard lk(mutex_run_);
-    --runCount_;
-    cv_.notify_all();
-    return false;
-}
-
-/**
- * Resume the coroutine on the current thread.
- *
- * Steps:
- *   1. Decrement nSuspend_ (under jq_.m_mutex)
- *   2. Swap in this coroutine's LocalValues for thread-local isolation
- *   3. Resume the coroutine handle (under mutex_)
- *   4. Swap out LocalValues, restoring the thread's previous state
- *   5. Decrement runCount_ and notify join() waiters
- *
- * Note: runCount_ is NOT incremented here — post() already did that.
- * This ensures join() stays blocked for the entire post→resume lifetime.
- */
-inline void
-JobQueue::CoroTaskRunner::resume()
-{
-    {
-        std::lock_guard lock(jq_.m_mutex);
-        --jq_.nSuspend_;
-    }
-    auto saved = detail::getLocalValues().release();
-    detail::getLocalValues().reset(&lvs_);
-    std::lock_guard lock(mutex_);
-    XRPL_ASSERT(!task_.done(), "xrpl::JobQueue::CoroTaskRunner::resume : task is not done");
-    task_.handle().resume();
-    detail::getLocalValues().release();
-    detail::getLocalValues().reset(saved);
-    if (task_.done())
-    {
-#ifndef NDEBUG
-        finished_ = true;
-#endif
-        // Break the shared_ptr cycle: frame -> shared_ptr<runner> -> this.
-        // Use std::move (not task_ = {}) so task_.handle_ is null BEFORE the
-        // frame is destroyed. operator= would destroy the frame while handle_
-        // still holds the old value -- a re-entrancy hazard on GCC-12 if
-        // frame destruction triggers runner cleanup.
-        [[maybe_unused]] auto completed = std::move(task_);
-    }
-    std::lock_guard lk(mutex_run_);
-    --runCount_;
-    cv_.notify_all();
-}
-
-/**
- * @return true if the coroutine has not yet run to completion
- */
-inline bool
-JobQueue::CoroTaskRunner::runnable() const
-{
-    // After normal completion, task_ is reset to break the shared_ptr cycle
-    // (handle_ becomes null). A null handle means the coroutine is done.
-    return task_.handle() && !task_.done();
-}
-
-/**
- * Handle early termination when the coroutine never ran (e.g. JobQueue
- * is stopping). Decrements nSuspend_ and destroys the coroutine frame
- * to break the shared_ptr cycle: frame -> lambda -> runner -> frame.
- */
-inline void
-JobQueue::CoroTaskRunner::expectEarlyExit()
-{
-#ifndef NDEBUG
-    if (!finished_)
-#endif
-    {
-        std::lock_guard lock(jq_.m_mutex);
-        --jq_.nSuspend_;
-#ifndef NDEBUG
-        finished_ = true;
-#endif
-    }
-    // Break the shared_ptr cycle: frame -> shared_ptr<runner> -> this.
-    // The coroutine is at initial_suspend and never ran user code, so
-    // destroying it is safe. Use std::move (not task_ = {}) so
-    // task_.handle_ is null before the frame is destroyed.
-    {
-        [[maybe_unused]] auto completed = std::move(task_);
-    }
-    storedFunc_.reset();
-}
-
-/**
- * Block until all pending/active resume operations complete.
- * Uses cv_ + mutex_run_ to wait until runCount_ reaches 0.
- */
-inline void
-JobQueue::CoroTaskRunner::join()
-{
-    std::unique_lock<std::mutex> lk(mutex_run_);
-    cv_.wait(lk, [this]() { return runCount_ == 0; });
-}
-
-}  // namespace xrpl

include/xrpl/core/JobQueue.h

@@ -2,7 +2,6 @@
 
 #include <xrpl/basics/LocalValue.h>
 #include <xrpl/core/ClosureCounter.h>
-#include <xrpl/core/CoroTask.h>
 #include <xrpl/core/JobTypeData.h>
 #include <xrpl/core/JobTypes.h>
 #include <xrpl/core/detail/Workers.h>
@@ -10,7 +9,6 @@
 
 #include <boost/coroutine/all.hpp>
 
-#include <coroutine>
 #include <set>
 
 namespace xrpl {
@@ -121,395 +119,6 @@ public:
         join();
     };
 
-    /** C++20 coroutine lifecycle manager. Replaces Coro for new code.
-     *
-     *  Class / Inheritance / Dependency Diagram
-     *  =========================================
-     *
-     *  std::enable_shared_from_this<CoroTaskRunner>
-     *            ^
-     *            | (public inheritance)
-     *            |
-     *  CoroTaskRunner
-     *  +---------------------------------------------------+
-     *  | - lvs_         : detail::LocalValues               |
-     *  | - jq_          : JobQueue&                         |
-     *  | - type_        : JobType                           |
-     *  | - name_        : std::string                       |
-     *  | - runCount_    : int         (in-flight resumes)    |
-     *  | - mutex_       : std::mutex      (coroutine guard) |
-     *  | - mutex_run_   : std::mutex      (join guard)      |
-     *  | - cv_          : condition_variable                 |
-     *  | - task_        : CoroTask<void>                    |
-     *  | - storedFunc_  : unique_ptr<FuncBase> (type-erased)|
-     *  +---------------------------------------------------+
-     *  | + init(F&&)         : set up coroutine callable    |
-     *  | + onSuspend()       : ++jq_.nSuspend_              |
-     *  | + onUndoSuspend()   : --jq_.nSuspend_              |
-     *  | + suspend()         : returns SuspendAwaiter       |
-     *  | + post()            : schedule resume on JobQueue  |
-     *  | + resume()          : resume coroutine on caller   |
-     *  | + runnable()        : !task_.done()                |
-     *  | + expectEarlyExit() : teardown for failed post     |
-     *  | + join()            : block until not running       |
-     *  +---------------------------------------------------+
-     *          |                          |
-     *          | owns                     | references
-     *          v                          v
-     *    CoroTask<void>             JobQueue
-     *    (coroutine frame)          (thread pool + nSuspend_)
-     *
-     *    FuncBase / FuncStore<F>    (type-erased heap storage
-     *                                for the coroutine lambda)
-     *
-     *  Coroutine Lifecycle (Control Flow)
-     *  ===================================
-     *
-     *  Caller thread              JobQueue worker thread
-     *  -------------              ----------------------
-     *  postCoroTask(f)
-     *    |
-     *    +-- check stopping_ (reject if JQ shutting down)
-     *    +-- ++nSuspend_  (lazy start counts as suspended)
-     *    +-- make_shared<CoroTaskRunner>
-     *    +-- init(f)
-     *    |     +-- store lambda on heap (FuncStore)
-     *    |     +-- task_ = f(shared_from_this())
-     *    |           [coroutine created, suspended at initial_suspend]
-     *    +-- post()
-     *    |     +-- ++runCount_
-     *    |     +-- addJob(type_, [resume]{})
-     *    |                                    resume()
-     *    |                                      |
-     *    |                                      +-- --nSuspend_
-     *    |                                      +-- swap in LocalValues
-     *    |                                      +-- task_.handle().resume()
-     *    |                                      |     [coroutine body runs]
-     *    |                                      |     ...
-     *    |                                      |     co_await suspend()
-     *    |                                      |       +-- ++nSuspend_
-     *    |                                      |       [coroutine suspends]
-     *    |                                      +-- swap out LocalValues
-     *    |                                      +-- --runCount_
-     *    |                                      +-- cv_.notify_all()
-     *    |
-     *  post()  <-- called externally or by JobQueueAwaiter
-     *    +-- ++runCount_
-     *    +-- addJob(type_, [resume]{})
-     *                                         resume()
-     *                                           |
-     *                                           +-- [coroutine body continues]
-     *                                           +-- co_return
-     *                                           +-- --runCount_
-     *                                           +-- cv_.notify_all()
-     *  join()
-     *    +-- cv_.wait([]{runCount_ == 0})
-     *    +-- [done]
-     *
-     *  Usage Examples
-     *  ==============
-     *
-     *  1. Fire-and-forget coroutine (most common pattern):
-     *
-     *      jq.postCoroTask(jtCLIENT, "MyWork",
-     *          [](auto runner) -> CoroTask<void> {
-     *              doSomeWork();
-     *              co_await runner->suspend();  // yield to other jobs
-     *              doMoreWork();
-     *              co_return;
-     *          });
-     *
-     *  2. Manually controlling suspend / resume (external trigger):
-     *
-     *      auto runner = jq.postCoroTask(jtCLIENT, "ExtTrigger",
-     *          [&result](auto runner) -> CoroTask<void> {
-     *              startAsyncOperation(callback);
-     *              co_await runner->suspend();
-     *              // callback called runner->post() to get here
-     *              result = collectResult();
-     *              co_return;
-     *          });
-     *      // ... later, from the callback:
-     *      runner->post();   // reschedule the coroutine on the JobQueue
-     *
-     *  3. Using JobQueueAwaiter for automatic suspend + repost:
-     *
-     *      jq.postCoroTask(jtCLIENT, "AutoRepost",
-     *          [](auto runner) -> CoroTask<void> {
-     *              step1();
-     *              co_await JobQueueAwaiter{runner};  // yield + auto-repost
-     *              step2();
-     *              co_await JobQueueAwaiter{runner};
-     *              step3();
-     *              co_return;
-     *          });
-     *
-     *  4. Checking shutdown after co_await (cooperative cancellation):
-     *
-     *      jq.postCoroTask(jtCLIENT, "Cancellable",
-     *          [&jq](auto runner) -> CoroTask<void> {
-     *              while (moreWork()) {
-     *                  co_await JobQueueAwaiter{runner};
-     *                  if (jq.isStopping())
-     *                      co_return;  // bail out cleanly
-     *                  processNextItem();
-     *              }
-     *              co_return;
-     *          });
-     *
-     *  Caveats / Pitfalls
-     *  ==================
-     *
-     *  BUG-RISK: Calling suspend() without a matching post()/resume().
-     *    After co_await runner->suspend(), the coroutine is parked and
-     *    nSuspend_ is incremented.  If nothing ever calls post() or
-     *    resume(), the coroutine is leaked and JobQueue::stop() will
-     *    hang forever waiting for nSuspend_ to reach zero.
-     *
-     *  BUG-RISK: Calling post() on an already-running coroutine.
-     *    post() schedules a resume() job.  If the coroutine has not
-     *    actually suspended yet (no co_await executed), the resume job
-     *    will try to call handle().resume() while the coroutine is still
-     *    running on another thread.  This is UB.  The mutex_ prevents
-     *    data corruption but the logic is wrong — always co_await
-     *    suspend() before calling post().  (The test testIncorrectOrder
-     *    shows this works only because mutex_ serializes the calls.)
-     *
-     *  BUG-RISK: Dropping the shared_ptr<CoroTaskRunner> before join().
-     *    The CoroTaskRunner destructor asserts (!finished_ is false).
-     *    If you let the last shared_ptr die while the coroutine is still
-     *    running or suspended, you get an assertion failure in debug and
-     *    UB in release.  Always call join() or expectEarlyExit() first.
-     *
-     *  BUG-RISK: Lambda captures outliving the coroutine frame.
-     *    The lambda passed to postCoroTask is heap-allocated (FuncStore)
-     *    to prevent dangling.  But objects captured by pointer still need
-     *    their own lifetime management.  If you capture a raw pointer to
-     *    a stack variable, and the stack frame exits before the coroutine
-     *    finishes, the pointer dangles.  Use shared_ptr or ensure the
-     *    pointed-to object outlives the coroutine.
-     *
-     *  BUG-RISK: Forgetting co_return in a void coroutine.
-     *    If the coroutine body falls off the end without co_return,
-     *    the compiler may silently treat it as co_return (per standard),
-     *    but some compilers warn.  Always write explicit co_return.
-     *
-     *  LIMITATION: CoroTaskRunner only supports CoroTask<void>.
-     *    The task_ member is CoroTask<void>.  To return values from
-     *    the top-level coroutine, write through a captured pointer
-     *    (as the tests demonstrate), or co_await inner CoroTask<T>
-     *    coroutines that return values.
-     *
-     *  LIMITATION: One coroutine per CoroTaskRunner.
-     *    init() must be called exactly once.  You cannot reuse a
-     *    CoroTaskRunner to run a second coroutine.  Create a new one
-     *    via postCoroTask() instead.
-     *
-     *  LIMITATION: No timeout on join().
-     *    join() blocks indefinitely.  If the coroutine is suspended
-     *    and never posted, join() will deadlock.  Use timed waits
-     *    on the gate pattern (condition_variable + wait_for) in tests.
-     */
-    class CoroTaskRunner : public std::enable_shared_from_this<CoroTaskRunner>
-    {
-    private:
-        // Per-coroutine thread-local storage. Swapped in before resume()
-        // and swapped out after, so each coroutine sees its own LocalValue
-        // state regardless of which worker thread executes it.
-        detail::LocalValues lvs_;
-
-        // Back-reference to the owning JobQueue. Used to post jobs,
-        // increment/decrement nSuspend_, and acquire jq_.m_mutex.
-        JobQueue& jq_;
-
-        // Job type passed to addJob() when posting this coroutine.
-        JobType type_;
-
-        // Human-readable name for this coroutine job (for logging).
-        std::string name_;
-
-        // Number of in-flight resume operations (pending + active).
-        // Incremented by post(), decremented when resume() finishes.
-        // Guarded by mutex_run_. join() blocks until this reaches 0.
-        //
-        // A counter (not a bool) is needed because post() can be called
-        // from within the coroutine body (e.g. via JobQueueAwaiter),
-        // enqueuing a second resume while the first is still running.
-        // A bool would be clobbered: R2.post() sets true, then R1's
-        // cleanup sets false — losing the fact that R2 is still pending.
-        int runCount_;
-
-        // Guards task_.handle().resume() to prevent the coroutine from
-        // running on two threads simultaneously. Handles the race where
-        // post() enqueues a resume before the coroutine has actually
-        // suspended (post-before-suspend pattern).
-        std::mutex mutex_;
-
-        // Guards runCount_. Used with cv_ for join() to wait
-        // until all pending/active resume operations complete.
-        std::mutex mutex_run_;
-
-        // Notified when runCount_ reaches zero, allowing
-        // join() waiters to wake up.
-        std::condition_variable cv_;
-
-        // The coroutine handle wrapper. Owns the coroutine frame.
-        // Set by init(), reset to empty by expectEarlyExit() on
-        // early termination.
-        CoroTask<void> task_;
-
-        /**
-         * Type-erased base for heap-stored callables.
-         * Prevents the coroutine lambda from being destroyed before
-         * the coroutine frame is done with it.
-         *
-         * @see FuncStore
-         */
-        struct FuncBase
-        {
-            virtual ~FuncBase() = default;
-        };
-
-        /**
-         * Concrete type-erased storage for a callable of type F.
-         * The coroutine frame stores a reference to the lambda's implicit
-         * object parameter. If the lambda is a temporary, that reference
-         * dangles after the call returns. FuncStore keeps it alive on
-         * the heap for the lifetime of the CoroTaskRunner.
-         */
-        template <class F>
-        struct FuncStore : FuncBase
-        {
-            F func;  // The stored callable (coroutine lambda).
-            explicit FuncStore(F&& f) : func(std::move(f))
-            {
-            }
-        };
-
-        // Heap-allocated callable storage. Set by init(), ensures the
-        // lambda outlives the coroutine frame that references it.
-        std::unique_ptr<FuncBase> storedFunc_;
-
-#ifndef NDEBUG
-        // Debug-only flag. True once the coroutine has completed or
-        // expectEarlyExit() was called. Asserted in the destructor
-        // to catch leaked runners.
-        bool finished_ = false;
-#endif
-
-    public:
-        /**
-         * Tag type for private construction. Prevents external code
-         * from constructing CoroTaskRunner directly. Use postCoroTask().
-         */
-        struct create_t
-        {
-            explicit create_t() = default;
-        };
-
-        /**
-         * Construct a CoroTaskRunner. Private by convention (create_t tag).
-         *
-         * @param jq   The JobQueue this coroutine will run on
-         * @param type Job type for scheduling priority
-         * @param name Human-readable name for logging
-         */
-        CoroTaskRunner(create_t, JobQueue&, JobType, std::string const&);
-
-        CoroTaskRunner(CoroTaskRunner const&) = delete;
-        CoroTaskRunner&
-        operator=(CoroTaskRunner const&) = delete;
-
-        /**
-         * Destructor. Asserts (debug) that the coroutine has finished
-         * or expectEarlyExit() was called.
-         */
-        ~CoroTaskRunner();
-
-        /**
-         * Initialize with a coroutine-returning callable.
-         * Must be called exactly once, after the object is managed by
-         * shared_ptr (because init uses shared_from_this internally).
-         * This is handled automatically by postCoroTask().
-         *
-         * @param f Callable: CoroTask<void>(shared_ptr<CoroTaskRunner>)
-         */
-        template <class F>
-        void
-        init(F&& f);
-
-        /**
-         * Increment the JobQueue's suspended-coroutine count (nSuspend_).
-         * Called when the coroutine is about to suspend. Every call
-         * must be balanced by a corresponding decrement (via resume()
-         * or onUndoSuspend()), or JobQueue::stop() will hang.
-         */
-        void
-        onSuspend();
-
-        /**
-         * Decrement nSuspend_ without resuming.
-         * Used to undo onSuspend() when a scheduled post() fails
-         * (e.g. JobQueue is stopping).
-         */
-        void
-        onUndoSuspend();
-
-        /**
-         * Suspend the coroutine.
-         * The awaiter's await_suspend() increments nSuspend_ before the
-         * coroutine actually suspends. The caller must later call post()
-         * or resume() to continue execution.
-         *
-         * @return An awaiter for use with `co_await runner->suspend()`
-         */
-        auto
-        suspend();
-
-        /**
-         * Schedule coroutine resumption as a job on the JobQueue.
-         * Captures shared_from_this() to prevent this runner from being
-         * destroyed while the job is queued.
-         *
-         * @return true if the job was accepted; false if the JobQueue
-         *         is stopping (caller must handle cleanup)
-         */
-        bool
-        post();
-
-        /**
-         * Resume the coroutine on the current thread.
-         * Decrements nSuspend_, swaps in LocalValues, resumes the
-         * coroutine handle, swaps out LocalValues, and notifies join()
-         * waiters. Lock ordering: mutex_run_ -> jq_.m_mutex -> mutex_.
-         */
-        void
-        resume();
-
-        /**
-         * @return true if the coroutine has not yet run to completion
-         */
-        bool
-        runnable() const;
-
-        /**
-         * Handle early termination when the coroutine never ran.
-         * Decrements nSuspend_ and destroys the coroutine frame to
-         * break the shared_ptr cycle (frame -> lambda -> runner -> frame).
-         * Called by postCoroTask() when post() fails.
-         */
-        void
-        expectEarlyExit();
-
-        /**
-         * Block until all pending/active resume operations complete.
-         * Uses cv_ + mutex_run_ to wait until runCount_ reaches 0.
-         * Warning: deadlocks if the coroutine is suspended and never posted.
-         */
-        void
-        join();
-    };
-
     using JobFunction = std::function<void()>;
 
     JobQueue(
@@ -556,19 +165,6 @@ public:
     std::shared_ptr<Coro>
     postCoro(JobType t, std::string const& name, F&& f);
 
-    /** Creates a C++20 coroutine and adds a job to the queue to run it.
-
-        @param t The type of job.
-        @param name Name of the job.
-        @param f Callable with signature
-            CoroTask<void>(std::shared_ptr<CoroTaskRunner>).
-
-        @return shared_ptr to posted CoroTaskRunner. nullptr if not successful.
-    */
-    template <class F>
-    std::shared_ptr<CoroTaskRunner>
-    postCoroTask(JobType t, std::string const& name, F&& f);
-
     /** Jobs waiting at this priority.
      */
     int
@@ -783,7 +379,6 @@ private:
 }  // namespace xrpl
 
 #include <xrpl/core/Coro.ipp>
-#include <xrpl/core/CoroTaskRunner.ipp>
 
 namespace xrpl {
 
@@ -806,69 +401,4 @@ JobQueue::postCoro(JobType t, std::string const& name, F&& f)
     return coro;
 }
 
-// postCoroTask — entry point for launching a C++20 coroutine on the JobQueue.
-//
-// Control Flow
-// ============
-//
-//   postCoroTask(t, name, f)
-//     |
-//     +-- 1. Check stopping_ — reject if JQ shutting down
-//     |
-//     +-- 2. ++nSuspend_   (mirrors Boost Coro ctor's implicit yield)
-//     |        The coroutine is "suspended" from the JobQueue's perspective
-//     |        even though it hasn't run yet — this keeps the JQ shutdown
-//     |        logic correct (it waits for nSuspend_ to reach 0).
-//     |
-//     +-- 3. Create CoroTaskRunner (shared_ptr, ref-counted)
-//     |
-//     +-- 4. runner->init(f)
-//     |        +-- Heap-allocate the lambda (FuncStore) to prevent
-//     |        |   dangling captures in the coroutine frame
-//     |        +-- task_ = f(shared_from_this())
-//     |              [coroutine created but NOT started — lazy initial_suspend]
-//     |
-//     +-- 5. runner->post()
-//     |        +-- addJob(type_, [resume]{})   → resume on worker thread
-//     |        +-- failure (JQ stopping):
-//     |              +-- runner->expectEarlyExit()
-//     |              |     --nSuspend_, destroy coroutine frame
-//     |              +-- return nullptr
-//
-// Why async post() instead of synchronous resume()?
-// ==================================================
-// The initial dispatch MUST use async post() so the coroutine body runs on
-// a JobQueue worker thread, not the caller's thread.  resume() swaps the
-// caller's thread-local LocalValues with the coroutine's private copy.
-// If the coroutine mutates LocalValues (e.g. thread_specific_storage test),
-// those mutations bleed back into the caller's thread-local state after the
-// swap-out, corrupting subsequent tests that share the same thread pool.
-// Async post() avoids this by running the coroutine on a worker thread whose
-// LocalValues are managed by the thread pool, not by the caller.
-//
-template <class F>
-std::shared_ptr<JobQueue::CoroTaskRunner>
-JobQueue::postCoroTask(JobType t, std::string const& name, F&& f)
-{
-    // Reject if the JQ is shutting down — matches addJob()'s stopping_ check.
-    // Must check before incrementing nSuspend_ to avoid leaving an orphan
-    // count that would cause stop() to hang.
-    if (stopping_)
-        return nullptr;
-
-    {
-        std::lock_guard lock(m_mutex);
-        ++nSuspend_;
-    }
-
-    auto runner = std::make_shared<CoroTaskRunner>(CoroTaskRunner::create_t{}, *this, t, name);
-    runner->init(std::forward<F>(f));
-    if (!runner->post())
-    {
-        runner->expectEarlyExit();
-        runner.reset();
-    }
-    return runner;
-}
-
 }  // namespace xrpl

include/xrpl/core/JobQueueAwaiter.h

@@ -1,174 +0,0 @@
-#pragma once
-
-#include <xrpl/core/JobQueue.h>
-
-#include <coroutine>
-#include <memory>
-
-namespace xrpl {
-
-/**
- * Awaiter that suspends and immediately reschedules on the JobQueue.
- * Equivalent to calling yield() followed by post() in the old Coro API.
- *
- * Usage:
- *     co_await JobQueueAwaiter{runner};
- *
- * What it waits for: The coroutine is re-queued as a job and resumes
- * when a worker thread picks it up.
- *
- * Which thread resumes: A JobQueue worker thread.
- *
- * What await_resume() returns: void.
- *
- * Dependency Diagram
- * ==================
- *
- *   JobQueueAwaiter
- *   +----------------------------------------------+
- *   | + runner : shared_ptr<CoroTaskRunner>         |
- *   +----------------------------------------------+
- *   | + await_ready()   -> false (always suspend)   |
- *   | + await_suspend() -> bool (suspend or cancel) |
- *   | + await_resume()  -> void                     |
- *   +----------------------------------------------+
- *          |                         |
- *          | uses                    | uses
- *          v                         v
- *   CoroTaskRunner              JobQueue
- *   .onSuspend()                (via runner->post() -> addJob)
- *   .onUndoSuspend()
- *   .post()
- *
- * Control Flow (await_suspend)
- * ============================
- *
- *   co_await JobQueueAwaiter{runner}
- *     |
- *     +-- await_ready() -> false
- *     +-- await_suspend(handle)
- *           |
- *           +-- runner->onSuspend()     // ++nSuspend_
- *           +-- runner->post()          // addJob to JobQueue
- *           |     |
- *           |     +-- success? return true   // coroutine stays suspended
- *           |     |                          // worker thread will call resume()
- *           |     +-- failure? (JQ stopping)
- *           |           +-- runner->onUndoSuspend()  // --nSuspend_
- *           |           +-- return false   // coroutine continues immediately
- *           |                              // so it can clean up and co_return
- *
- * Usage Examples
- * ==============
- *
- * 1. Yield and auto-repost (most common -- replaces yield() + post()):
- *
- *     CoroTask<void> handler(auto runner) {
- *         doPartA();
- *         co_await JobQueueAwaiter{runner};  // yield + repost
- *         doPartB();                         // runs on a worker thread
- *         co_return;
- *     }
- *
- * 2. Multiple yield points in a loop:
- *
- *     CoroTask<void> batchProcessor(auto runner) {
- *         for (auto& item : items) {
- *             process(item);
- *             co_await JobQueueAwaiter{runner};  // let other jobs run
- *         }
- *         co_return;
- *     }
- *
- * 3. Graceful shutdown -- checking after resume:
- *
- *     CoroTask<void> longTask(auto runner, JobQueue& jq) {
- *         while (hasWork()) {
- *             co_await JobQueueAwaiter{runner};
- *             // If JQ is stopping, await_suspend returns false and
- *             // the coroutine continues immediately without re-queuing.
- *             // Always check isStopping() to decide whether to proceed:
- *             if (jq.isStopping())
- *                 co_return;
- *             doNextChunk();
- *         }
- *         co_return;
- *     }
- *
- * Caveats / Pitfalls
- * ==================
- *
- * BUG-RISK: Using a stale or null runner.
- *   The runner shared_ptr must be valid and point to the CoroTaskRunner
- *   that owns the coroutine currently executing. Passing a runner from
- *   a different coroutine, or a default-constructed shared_ptr, is UB.
- *
- * BUG-RISK: Assuming resume happens on the same thread.
- *   After co_await JobQueueAwaiter, the coroutine resumes on whatever
- *   worker thread picks up the job. Do not rely on thread-local state
- *   unless it is managed through LocalValue (which CoroTaskRunner
- *   automatically swaps in/out).
- *
- * BUG-RISK: Ignoring the shutdown path.
- *   When the JobQueue is stopping, post() fails and await_suspend()
- *   returns false (coroutine does NOT actually suspend). The coroutine
- *   body continues immediately on the same thread. If your code after
- *   co_await assumes it was re-queued and is running on a worker thread,
- *   that assumption breaks during shutdown. Always handle the "JQ is
- *   stopping" case, either by checking jq.isStopping() or by letting
- *   the coroutine fall through to co_return naturally.
- *
- * DIFFERENCE from runner->suspend() + runner->post():
- *   JobQueueAwaiter combines both in one atomic operation. With the
- *   manual suspend()/post() pattern, there is a window between the
- *   two calls where an external event could race. JobQueueAwaiter
- *   removes that window -- onSuspend() and post() happen within the
- *   same await_suspend() call while the coroutine is guaranteed to
- *   be suspended. Prefer JobQueueAwaiter unless you need an external
- *   party to decide *when* to call post().
- */
-struct JobQueueAwaiter
-{
-    // The CoroTaskRunner that owns the currently executing coroutine.
-    std::shared_ptr<JobQueue::CoroTaskRunner> runner;
-
-    /**
-     * Always returns false so the coroutine suspends.
-     */
-    bool
-    await_ready() const noexcept
-    {
-        return false;
-    }
-
-    /**
-     * Increment nSuspend (equivalent to yield()) and schedule resume
-     * on the JobQueue (equivalent to post()). If the JobQueue is
-     * stopping, undoes the suspend count and returns false so the
-     * coroutine continues immediately and can clean up.
-     *
-     * @return true if coroutine should stay suspended (job posted);
-     *         false if coroutine should continue (JQ stopping)
-     */
-    bool
-    await_suspend(std::coroutine_handle<>)
-    {
-        runner->onSuspend();
-        if (!runner->post())
-        {
-            // JobQueue is stopping. Undo the suspend count and
-            // don't actually suspend — the coroutine continues
-            // immediately so it can clean up and co_return.
-            runner->onUndoSuspend();
-            return false;
-        }
-        return true;
-    }
-
-    void
-    await_resume() const noexcept
-    {
-    }
-};
-
-}  // namespace xrpl

include/xrpl/git/Git.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <string>
+
+namespace xrpl::git {
+
+std::string const&
+getCommitHash();
+
+std::string const&
+getBuildBranch();
+
+}  // namespace xrpl::git

include/xrpl/ledger/detail/RawStateTable.h

@@ -23,13 +23,13 @@ public:
     static constexpr size_t initialBufferSize = kilobytes(256);
 
     RawStateTable()
-        : monotonic_resource_{std::make_unique<boost::container::pmr::monotonic_buffer_resource>(
-              initialBufferSize)}
+        : monotonic_resource_{
+              std::make_unique<boost::container::pmr::monotonic_buffer_resource>(initialBufferSize)}
         , items_{monotonic_resource_.get()} {};
 
     RawStateTable(RawStateTable const& rhs)
-        : monotonic_resource_{std::make_unique<boost::container::pmr::monotonic_buffer_resource>(
-              initialBufferSize)}
+        : monotonic_resource_{
+              std::make_unique<boost::container::pmr::monotonic_buffer_resource>(initialBufferSize)}
         , items_{rhs.items_, monotonic_resource_.get()}
         , dropsDestroyed_{rhs.dropsDestroyed_} {};
 

include/xrpl/protocol/BuildInfo.h

@@ -49,7 +49,7 @@ getFullVersionString();
     @return the encoded version in a 64-bit integer
 */
 std::uint64_t
-encodeSoftwareVersion(char const* const versionStr);
+encodeSoftwareVersion(std::string_view versionStr);
 
 /** Returns this server's version packed in a 64-bit integer. */
 std::uint64_t

include/xrpl/protocol/KnownFormats.h

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

include/xrpl/protocol/LedgerFormats.h

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

include/xrpl/protocol/SOTemplate.h

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

include/xrpl/protocol/TxFlags.h

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

include/xrpl/protocol/TxFormats.h

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

include/xrpl/protocol/jss.h

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

include/xrpl/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(SLE const& sle) : sle_(sle)
+    {
+    }
+
+    /**
+     * @brief Validate the ledger entry
+     * @return true if validation passes, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    validate()
+    {
+        if (!sle_.isFieldPresent(sfLedgerEntryType))
+        {
+            return false;
+        }
+        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]]
+    SLE const&
+    getSle() const
+    {
+        return sle_;
+    }
+
+protected:
+    /** @brief The underlying serialized ledger entry being wrapped. */
+    SLE const& sle_;
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/LedgerEntryBuilderBase.h

@@ -0,0 +1,78 @@
+#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)
+    {
+        object_[sfLedgerEntryType] = ledgerEntryType;
+        object_[sfFlags] = flags;
+    }
+
+    /**
+     * @brief Validate the ledger entry
+     * @return true if validation passes, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    validate()
+    {
+        if (!object_.isFieldPresent(sfLedgerEntryType))
+        {
+            return false;
+        }
+        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,81 @@
+<!-- cspell:words pyparsing -->
+
+# 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_objects/`): 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,32 @@
+#pragma once
+
+#include <xrpl/protocol/SOTemplate.h>
+#include <xrpl/protocol/STObject.h>
+
+namespace xrpl::protocol_autogen {
+
+[[nodiscard]]
+bool
+validateSTObject(STObject const& obj, SOTemplate const& format)
+{
+    for (auto const& field : format)
+    {
+        if (obj.isFieldPresent(field.sField()) && field.style() == soeREQUIRED)
+        {
+            return false;
+        }
+
+        if (!field.supportMPT() && obj.isFieldPresent(field.sField()) &&
+            field.sField().fieldType == STI_ISSUE)
+        {
+            auto const& amount = obj.getFieldAmount(field.sField());
+
+            if (amount.asset().holds<MPTIssue>())
+                return false;
+        }
+    }
+
+    return true;
+}
+
+}  // namespace xrpl::protocol_autogen

include/xrpl/protocol_autogen/TransactionBase.h

@@ -0,0 +1,444 @@
+#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(STTx const& tx) : tx_(tx)
+    {
+    }
+
+    /**
+     * @brief Validate the transaction
+     * @return true if validation passes, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    validate() const
+    {
+        return protocol_autogen::validateSTObject(
+            tx_, TxFormats::getInstance().findByType(tx_.getTxnType())->getSOTemplate());
+    }
+
+    /**
+     * @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]]
+    STTx const&
+    getSTTx() const
+    {
+        return tx_;
+    }
+
+protected:
+    /** @brief The underlying transaction object being wrapped. */
+    STTx const& tx_;
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/TransactionBuilderBase.h

@@ -0,0 +1,182 @@
+#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/STBlob.h>
+#include <xrpl/protocol/STInteger.h>
+#include <xrpl/protocol/STObject.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>
+#include <xrpl/protocol_autogen/STObjectValidation.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)
+    {
+        object_[sfTransactionType] = transactionType;
+        setAccount(account);
+
+        if (sequence)
+        {
+            setSequence(*sequence);
+        }
+        if (fee)
+        {
+            setFee(*fee);
+        }
+    }
+
+    /**
+     * @brief Validate the transaction
+     * @return true if validation passes, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    validate()
+    {
+        if (!object_.isFieldPresent(sfTransactionType))
+        {
+            return false;
+        }
+        auto transactionType = static_cast<TxType>(object_.getFieldU16(sfTransactionType));
+        return protocol_autogen::validateSTObject(
+            object_, TxFormats::getInstance().findByType(transactionType)->getSOTemplate());
+    }
+
+    /**
+     * 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 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);
+    }
+
+    /**
+     * 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);
+    }
+
+protected:
+    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_objects/AMM.h

@@ -0,0 +1,347 @@
+#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 {
+
+// Forward declaration
+class AMMBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for AMM");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfAccount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_.at(sfAccount);
+    }
+
+    /**
+     * Get sfTradingFee (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT16::type::value_type>
+    getTradingFee() const
+    {
+        if (hasTradingFee())
+            return this->sle_.at(sfTradingFee);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasTradingFee() const
+    {
+        return this->sle_.isFieldPresent(sfTradingFee);
+    }
+
+    /**
+     * Get sfVoteSlots (soeOPTIONAL)
+     * Note: This is an untyped field (unknown).
+     */
+    [[nodiscard]]
+    std::optional<std::reference_wrapper<STArray const>>
+    getVoteSlots() const
+    {
+        if (this->sle_.isFieldPresent(sfVoteSlots))
+            return this->sle_.getFieldArray(sfVoteSlots);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasVoteSlots() const
+    {
+        return this->sle_.isFieldPresent(sfVoteSlots);
+    }
+
+    /**
+     * Get sfAuctionSlot (soeOPTIONAL)
+     * Note: This is an untyped field (unknown).
+     */
+    [[nodiscard]]
+    std::optional<STObject>
+    getAuctionSlot() const
+    {
+        if (this->sle_.isFieldPresent(sfAuctionSlot))
+            return this->sle_.getFieldObject(sfAuctionSlot);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasAuctionSlot() const
+    {
+        return this->sle_.isFieldPresent(sfAuctionSlot);
+    }
+
+    /**
+     * Get sfLPTokenBalance (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getLPTokenBalance() const
+    {
+        return this->sle_.at(sfLPTokenBalance);
+    }
+
+    /**
+     * Get sfAsset (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset() const
+    {
+        return this->sle_.at(sfAsset);
+    }
+
+    /**
+     * Get sfAsset2 (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset2() const
+    {
+        return this->sle_.at(sfAsset2);
+    }
+
+    /**
+     * Get sfOwnerNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_.at(sfOwnerNode);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getPreviousTxnID() const
+    {
+        if (hasPreviousTxnID())
+            return this->sle_.at(sfPreviousTxnID);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasPreviousTxnID() const
+    {
+        return this->sle_.isFieldPresent(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getPreviousTxnLgrSeq() const
+    {
+        if (hasPreviousTxnLgrSeq())
+            return this->sle_.at(sfPreviousTxnLgrSeq);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasPreviousTxnLgrSeq() const
+    {
+        return this->sle_.isFieldPresent(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    AMMBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltAMM)
+        {
+            throw std::runtime_error("Invalid ledger entry type for AMM");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Set sfVoteSlots (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMBuilder&
+    setVoteSlots(STArray const& value)
+    {
+        object_.setFieldArray(sfVoteSlots, value);
+        return *this;
+    }
+
+    /**
+     * Set sfAuctionSlot (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMBuilder&
+    setAuctionSlot(STObject const& value)
+    {
+        object_.setFieldObject(sfAuctionSlot, value);
+        return *this;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed AMM wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    AMM
+    build(uint256 const& index)
+    {
+        return AMM{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/AccountRoot.h

@@ -0,0 +1,727 @@
+#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 {
+
+// Forward declaration
+class AccountRootBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for AccountRoot");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfAccount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_.at(sfAccount);
+    }
+
+    /**
+     * Get sfSequence (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getSequence() const
+    {
+        return this->sle_.at(sfSequence);
+    }
+
+    /**
+     * Get sfBalance (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getBalance() const
+    {
+        return this->sle_.at(sfBalance);
+    }
+
+    /**
+     * Get sfOwnerCount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getOwnerCount() const
+    {
+        return this->sle_.at(sfOwnerCount);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+
+    /**
+     * Get sfAccountTxnID (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getAccountTxnID() const
+    {
+        if (hasAccountTxnID())
+            return this->sle_.at(sfAccountTxnID);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasAccountTxnID() const
+    {
+        return this->sle_.isFieldPresent(sfAccountTxnID);
+    }
+
+    /**
+     * Get sfRegularKey (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getRegularKey() const
+    {
+        if (hasRegularKey())
+            return this->sle_.at(sfRegularKey);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasRegularKey() const
+    {
+        return this->sle_.isFieldPresent(sfRegularKey);
+    }
+
+    /**
+     * Get sfEmailHash (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT128::type::value_type>
+    getEmailHash() const
+    {
+        if (hasEmailHash())
+            return this->sle_.at(sfEmailHash);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasEmailHash() const
+    {
+        return this->sle_.isFieldPresent(sfEmailHash);
+    }
+
+    /**
+     * Get sfWalletLocator (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getWalletLocator() const
+    {
+        if (hasWalletLocator())
+            return this->sle_.at(sfWalletLocator);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasWalletLocator() const
+    {
+        return this->sle_.isFieldPresent(sfWalletLocator);
+    }
+
+    /**
+     * Get sfWalletSize (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getWalletSize() const
+    {
+        if (hasWalletSize())
+            return this->sle_.at(sfWalletSize);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasWalletSize() const
+    {
+        return this->sle_.isFieldPresent(sfWalletSize);
+    }
+
+    /**
+     * Get sfMessageKey (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getMessageKey() const
+    {
+        if (hasMessageKey())
+            return this->sle_.at(sfMessageKey);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasMessageKey() const
+    {
+        return this->sle_.isFieldPresent(sfMessageKey);
+    }
+
+    /**
+     * Get sfTransferRate (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getTransferRate() const
+    {
+        if (hasTransferRate())
+            return this->sle_.at(sfTransferRate);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasTransferRate() const
+    {
+        return this->sle_.isFieldPresent(sfTransferRate);
+    }
+
+    /**
+     * Get sfDomain (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getDomain() const
+    {
+        if (hasDomain())
+            return this->sle_.at(sfDomain);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasDomain() const
+    {
+        return this->sle_.isFieldPresent(sfDomain);
+    }
+
+    /**
+     * Get sfTickSize (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT8::type::value_type>
+    getTickSize() const
+    {
+        if (hasTickSize())
+            return this->sle_.at(sfTickSize);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasTickSize() const
+    {
+        return this->sle_.isFieldPresent(sfTickSize);
+    }
+
+    /**
+     * Get sfTicketCount (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getTicketCount() const
+    {
+        if (hasTicketCount())
+            return this->sle_.at(sfTicketCount);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasTicketCount() const
+    {
+        return this->sle_.isFieldPresent(sfTicketCount);
+    }
+
+    /**
+     * Get sfNFTokenMinter (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getNFTokenMinter() const
+    {
+        if (hasNFTokenMinter())
+            return this->sle_.at(sfNFTokenMinter);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasNFTokenMinter() const
+    {
+        return this->sle_.isFieldPresent(sfNFTokenMinter);
+    }
+
+    /**
+     * Get sfMintedNFTokens (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getMintedNFTokens() const
+    {
+        if (hasMintedNFTokens())
+            return this->sle_.at(sfMintedNFTokens);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasMintedNFTokens() const
+    {
+        return this->sle_.isFieldPresent(sfMintedNFTokens);
+    }
+
+    /**
+     * Get sfBurnedNFTokens (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getBurnedNFTokens() const
+    {
+        if (hasBurnedNFTokens())
+            return this->sle_.at(sfBurnedNFTokens);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasBurnedNFTokens() const
+    {
+        return this->sle_.isFieldPresent(sfBurnedNFTokens);
+    }
+
+    /**
+     * Get sfFirstNFTokenSequence (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getFirstNFTokenSequence() const
+    {
+        if (hasFirstNFTokenSequence())
+            return this->sle_.at(sfFirstNFTokenSequence);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasFirstNFTokenSequence() const
+    {
+        return this->sle_.isFieldPresent(sfFirstNFTokenSequence);
+    }
+
+    /**
+     * Get sfAMMID (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getAMMID() const
+    {
+        if (hasAMMID())
+            return this->sle_.at(sfAMMID);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasAMMID() const
+    {
+        return this->sle_.isFieldPresent(sfAMMID);
+    }
+
+    /**
+     * Get sfVaultID (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getVaultID() const
+    {
+        if (hasVaultID())
+            return this->sle_.at(sfVaultID);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasVaultID() const
+    {
+        return this->sle_.isFieldPresent(sfVaultID);
+    }
+
+    /**
+     * Get sfLoanBrokerID (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getLoanBrokerID() const
+    {
+        if (hasLoanBrokerID())
+            return this->sle_.at(sfLoanBrokerID);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasLoanBrokerID() const
+    {
+        return this->sle_.isFieldPresent(sfLoanBrokerID);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    AccountRootBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltACCOUNT_ROOT)
+        {
+            throw std::runtime_error("Invalid ledger entry type for AccountRoot");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed AccountRoot wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    AccountRoot
+    build(uint256 const& index)
+    {
+        return AccountRoot{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/Amendments.h

@@ -0,0 +1,206 @@
+#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 {
+
+// Forward declaration
+class AmendmentsBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Amendments");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfAmendments (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VECTOR256::type::value_type>
+    getAmendments() const
+    {
+        if (hasAmendments())
+            return this->sle_.at(sfAmendments);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasAmendments() const
+    {
+        return this->sle_.isFieldPresent(sfAmendments);
+    }
+
+    /**
+     * Get sfMajorities (soeOPTIONAL)
+     * Note: This is an untyped field (unknown).
+     */
+    [[nodiscard]]
+    std::optional<std::reference_wrapper<STArray const>>
+    getMajorities() const
+    {
+        if (this->sle_.isFieldPresent(sfMajorities))
+            return this->sle_.getFieldArray(sfMajorities);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasMajorities() const
+    {
+        return this->sle_.isFieldPresent(sfMajorities);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getPreviousTxnID() const
+    {
+        if (hasPreviousTxnID())
+            return this->sle_.at(sfPreviousTxnID);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasPreviousTxnID() const
+    {
+        return this->sle_.isFieldPresent(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getPreviousTxnLgrSeq() const
+    {
+        if (hasPreviousTxnLgrSeq())
+            return this->sle_.at(sfPreviousTxnLgrSeq);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasPreviousTxnLgrSeq() const
+    {
+        return this->sle_.isFieldPresent(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * 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:
+    AmendmentsBuilder()
+        : LedgerEntryBuilderBase<AmendmentsBuilder>(ltAMENDMENTS)
+    {
+    }
+
+    AmendmentsBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltAMENDMENTS)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Amendments");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Set sfMajorities (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AmendmentsBuilder&
+    setMajorities(STArray const& value)
+    {
+        object_.setFieldArray(sfMajorities, value);
+        return *this;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed Amendments wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    Amendments
+    build(uint256 const& index)
+    {
+        return Amendments{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/Bridge.h

@@ -0,0 +1,313 @@
+#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 {
+
+// Forward declaration
+class BridgeBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Bridge");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfAccount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_.at(sfAccount);
+    }
+
+    /**
+     * Get sfSignatureReward (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getSignatureReward() const
+    {
+        return this->sle_.at(sfSignatureReward);
+    }
+
+    /**
+     * Get sfMinAccountCreateAmount (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getMinAccountCreateAmount() const
+    {
+        if (hasMinAccountCreateAmount())
+            return this->sle_.at(sfMinAccountCreateAmount);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasMinAccountCreateAmount() const
+    {
+        return this->sle_.isFieldPresent(sfMinAccountCreateAmount);
+    }
+
+    /**
+     * Get sfXChainBridge (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_XCHAIN_BRIDGE::type::value_type
+    getXChainBridge() const
+    {
+        return this->sle_.at(sfXChainBridge);
+    }
+
+    /**
+     * Get sfXChainClaimID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getXChainClaimID() const
+    {
+        return this->sle_.at(sfXChainClaimID);
+    }
+
+    /**
+     * Get sfXChainAccountCreateCount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getXChainAccountCreateCount() const
+    {
+        return this->sle_.at(sfXChainAccountCreateCount);
+    }
+
+    /**
+     * Get sfXChainAccountClaimCount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getXChainAccountClaimCount() const
+    {
+        return this->sle_.at(sfXChainAccountClaimCount);
+    }
+
+    /**
+     * Get sfOwnerNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_.at(sfOwnerNode);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    BridgeBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltBRIDGE)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Bridge");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed Bridge wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    Bridge
+    build(uint256 const& index)
+    {
+        return Bridge{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/Check.h

@@ -0,0 +1,381 @@
+#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 {
+
+// Forward declaration
+class CheckBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Check");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfAccount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_.at(sfAccount);
+    }
+
+    /**
+     * Get sfDestination (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getDestination() const
+    {
+        return this->sle_.at(sfDestination);
+    }
+
+    /**
+     * Get sfSendMax (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getSendMax() const
+    {
+        return this->sle_.at(sfSendMax);
+    }
+
+    /**
+     * Get sfSequence (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getSequence() const
+    {
+        return this->sle_.at(sfSequence);
+    }
+
+    /**
+     * Get sfOwnerNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_.at(sfOwnerNode);
+    }
+
+    /**
+     * Get sfDestinationNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getDestinationNode() const
+    {
+        return this->sle_.at(sfDestinationNode);
+    }
+
+    /**
+     * Get sfExpiration (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getExpiration() const
+    {
+        if (hasExpiration())
+            return this->sle_.at(sfExpiration);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasExpiration() const
+    {
+        return this->sle_.isFieldPresent(sfExpiration);
+    }
+
+    /**
+     * Get sfInvoiceID (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getInvoiceID() const
+    {
+        if (hasInvoiceID())
+            return this->sle_.at(sfInvoiceID);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasInvoiceID() const
+    {
+        return this->sle_.isFieldPresent(sfInvoiceID);
+    }
+
+    /**
+     * Get sfSourceTag (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getSourceTag() const
+    {
+        if (hasSourceTag())
+            return this->sle_.at(sfSourceTag);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasSourceTag() const
+    {
+        return this->sle_.isFieldPresent(sfSourceTag);
+    }
+
+    /**
+     * Get sfDestinationTag (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getDestinationTag() const
+    {
+        if (hasDestinationTag())
+            return this->sle_.at(sfDestinationTag);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasDestinationTag() const
+    {
+        return this->sle_.isFieldPresent(sfDestinationTag);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    CheckBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltCHECK)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Check");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed Check wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    Check
+    build(uint256 const& index)
+    {
+        return Check{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/Credential.h

@@ -0,0 +1,307 @@
+#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 {
+
+// Forward declaration
+class CredentialBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Credential");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfSubject (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getSubject() const
+    {
+        return this->sle_.at(sfSubject);
+    }
+
+    /**
+     * Get sfIssuer (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getIssuer() const
+    {
+        return this->sle_.at(sfIssuer);
+    }
+
+    /**
+     * Get sfCredentialType (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_VL::type::value_type
+    getCredentialType() const
+    {
+        return this->sle_.at(sfCredentialType);
+    }
+
+    /**
+     * Get sfExpiration (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getExpiration() const
+    {
+        if (hasExpiration())
+            return this->sle_.at(sfExpiration);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasExpiration() const
+    {
+        return this->sle_.isFieldPresent(sfExpiration);
+    }
+
+    /**
+     * Get sfURI (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getURI() const
+    {
+        if (hasURI())
+            return this->sle_.at(sfURI);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasURI() const
+    {
+        return this->sle_.isFieldPresent(sfURI);
+    }
+
+    /**
+     * Get sfIssuerNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getIssuerNode() const
+    {
+        return this->sle_.at(sfIssuerNode);
+    }
+
+    /**
+     * Get sfSubjectNode (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getSubjectNode() const
+    {
+        if (hasSubjectNode())
+            return this->sle_.at(sfSubjectNode);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasSubjectNode() const
+    {
+        return this->sle_.isFieldPresent(sfSubjectNode);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    CredentialBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltCREDENTIAL)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Credential");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed Credential wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    Credential
+    build(uint256 const& index)
+    {
+        return Credential{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/DID.h

@@ -0,0 +1,263 @@
+#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 {
+
+// Forward declaration
+class DIDBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for DID");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfAccount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_.at(sfAccount);
+    }
+
+    /**
+     * Get sfDIDDocument (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getDIDDocument() const
+    {
+        if (hasDIDDocument())
+            return this->sle_.at(sfDIDDocument);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasDIDDocument() const
+    {
+        return this->sle_.isFieldPresent(sfDIDDocument);
+    }
+
+    /**
+     * Get sfURI (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getURI() const
+    {
+        if (hasURI())
+            return this->sle_.at(sfURI);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasURI() const
+    {
+        return this->sle_.isFieldPresent(sfURI);
+    }
+
+    /**
+     * Get sfData (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getData() const
+    {
+        if (hasData())
+            return this->sle_.at(sfData);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasData() const
+    {
+        return this->sle_.isFieldPresent(sfData);
+    }
+
+    /**
+     * Get sfOwnerNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_.at(sfOwnerNode);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    DIDBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltDID)
+        {
+            throw std::runtime_error("Invalid ledger entry type for DID");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed DID wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    DID
+    build(uint256 const& index)
+    {
+        return DID{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/Delegate.h

@@ -0,0 +1,218 @@
+#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 {
+
+// Forward declaration
+class DelegateBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Delegate");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfAccount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_.at(sfAccount);
+    }
+
+    /**
+     * Get sfAuthorize (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAuthorize() const
+    {
+        return this->sle_.at(sfAuthorize);
+    }
+
+    /**
+     * Get sfPermissions (soeREQUIRED)
+     * Note: This is an untyped field (unknown).
+     */
+    [[nodiscard]]
+    STArray const&
+    getPermissions() const
+    {
+        return this->sle_.getFieldArray(sfPermissions);
+    }
+
+    /**
+     * Get sfOwnerNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_.at(sfOwnerNode);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    DelegateBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltDELEGATE)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Delegate");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Set sfPermissions (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    DelegateBuilder&
+    setPermissions(STArray const& value)
+    {
+        object_.setFieldArray(sfPermissions, value);
+        return *this;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed Delegate wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    Delegate
+    build(uint256 const& index)
+    {
+        return Delegate{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/DepositPreauth.h

@@ -0,0 +1,234 @@
+#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 {
+
+// Forward declaration
+class DepositPreauthBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for DepositPreauth");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfAccount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_.at(sfAccount);
+    }
+
+    /**
+     * Get sfAuthorize (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getAuthorize() const
+    {
+        if (hasAuthorize())
+            return this->sle_.at(sfAuthorize);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasAuthorize() const
+    {
+        return this->sle_.isFieldPresent(sfAuthorize);
+    }
+
+    /**
+     * Get sfOwnerNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_.at(sfOwnerNode);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+
+    /**
+     * Get sfAuthorizeCredentials (soeOPTIONAL)
+     * Note: This is an untyped field (unknown).
+     */
+    [[nodiscard]]
+    std::optional<std::reference_wrapper<STArray const>>
+    getAuthorizeCredentials() const
+    {
+        if (this->sle_.isFieldPresent(sfAuthorizeCredentials))
+            return this->sle_.getFieldArray(sfAuthorizeCredentials);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasAuthorizeCredentials() const
+    {
+        return this->sle_.isFieldPresent(sfAuthorizeCredentials);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    DepositPreauthBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltDEPOSIT_PREAUTH)
+        {
+            throw std::runtime_error("Invalid ledger entry type for DepositPreauth");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Set sfAuthorizeCredentials (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DepositPreauthBuilder&
+    setAuthorizeCredentials(STArray const& value)
+    {
+        object_.setFieldArray(sfAuthorizeCredentials, value);
+        return *this;
+    }
+
+    /**
+     * Build and return the completed DepositPreauth wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    DepositPreauth
+    build(uint256 const& index)
+    {
+        return DepositPreauth{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/DirectoryNode.h

@@ -0,0 +1,489 @@
+#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 {
+
+// Forward declaration
+class DirectoryNodeBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for DirectoryNode");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfOwner (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getOwner() const
+    {
+        if (hasOwner())
+            return this->sle_.at(sfOwner);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasOwner() const
+    {
+        return this->sle_.isFieldPresent(sfOwner);
+    }
+
+    /**
+     * Get sfTakerPaysCurrency (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT160::type::value_type>
+    getTakerPaysCurrency() const
+    {
+        if (hasTakerPaysCurrency())
+            return this->sle_.at(sfTakerPaysCurrency);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasTakerPaysCurrency() const
+    {
+        return this->sle_.isFieldPresent(sfTakerPaysCurrency);
+    }
+
+    /**
+     * Get sfTakerPaysIssuer (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT160::type::value_type>
+    getTakerPaysIssuer() const
+    {
+        if (hasTakerPaysIssuer())
+            return this->sle_.at(sfTakerPaysIssuer);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasTakerPaysIssuer() const
+    {
+        return this->sle_.isFieldPresent(sfTakerPaysIssuer);
+    }
+
+    /**
+     * Get sfTakerGetsCurrency (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT160::type::value_type>
+    getTakerGetsCurrency() const
+    {
+        if (hasTakerGetsCurrency())
+            return this->sle_.at(sfTakerGetsCurrency);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasTakerGetsCurrency() const
+    {
+        return this->sle_.isFieldPresent(sfTakerGetsCurrency);
+    }
+
+    /**
+     * Get sfTakerGetsIssuer (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT160::type::value_type>
+    getTakerGetsIssuer() const
+    {
+        if (hasTakerGetsIssuer())
+            return this->sle_.at(sfTakerGetsIssuer);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasTakerGetsIssuer() const
+    {
+        return this->sle_.isFieldPresent(sfTakerGetsIssuer);
+    }
+
+    /**
+     * Get sfExchangeRate (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getExchangeRate() const
+    {
+        if (hasExchangeRate())
+            return this->sle_.at(sfExchangeRate);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasExchangeRate() const
+    {
+        return this->sle_.isFieldPresent(sfExchangeRate);
+    }
+
+    /**
+     * Get sfIndexes (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_VECTOR256::type::value_type
+    getIndexes() const
+    {
+        return this->sle_.at(sfIndexes);
+    }
+
+    /**
+     * Get sfRootIndex (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getRootIndex() const
+    {
+        return this->sle_.at(sfRootIndex);
+    }
+
+    /**
+     * Get sfIndexNext (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getIndexNext() const
+    {
+        if (hasIndexNext())
+            return this->sle_.at(sfIndexNext);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasIndexNext() const
+    {
+        return this->sle_.isFieldPresent(sfIndexNext);
+    }
+
+    /**
+     * Get sfIndexPrevious (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getIndexPrevious() const
+    {
+        if (hasIndexPrevious())
+            return this->sle_.at(sfIndexPrevious);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasIndexPrevious() const
+    {
+        return this->sle_.isFieldPresent(sfIndexPrevious);
+    }
+
+    /**
+     * Get sfNFTokenID (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getNFTokenID() const
+    {
+        if (hasNFTokenID())
+            return this->sle_.at(sfNFTokenID);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasNFTokenID() const
+    {
+        return this->sle_.isFieldPresent(sfNFTokenID);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getPreviousTxnID() const
+    {
+        if (hasPreviousTxnID())
+            return this->sle_.at(sfPreviousTxnID);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasPreviousTxnID() const
+    {
+        return this->sle_.isFieldPresent(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getPreviousTxnLgrSeq() const
+    {
+        if (hasPreviousTxnLgrSeq())
+            return this->sle_.at(sfPreviousTxnLgrSeq);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasPreviousTxnLgrSeq() const
+    {
+        return this->sle_.isFieldPresent(sfPreviousTxnLgrSeq);
+    }
+
+    /**
+     * Get sfDomainID (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getDomainID() const
+    {
+        if (hasDomainID())
+            return this->sle_.at(sfDomainID);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasDomainID() const
+    {
+        return this->sle_.isFieldPresent(sfDomainID);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    DirectoryNodeBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltDIR_NODE)
+        {
+            throw std::runtime_error("Invalid ledger entry type for DirectoryNode");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed DirectoryNode wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    DirectoryNode
+    build(uint256 const& index)
+    {
+        return DirectoryNode{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/Escrow.h

@@ -0,0 +1,487 @@
+#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 {
+
+// Forward declaration
+class EscrowBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Escrow");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfAccount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_.at(sfAccount);
+    }
+
+    /**
+     * Get sfSequence (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getSequence() const
+    {
+        if (hasSequence())
+            return this->sle_.at(sfSequence);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasSequence() const
+    {
+        return this->sle_.isFieldPresent(sfSequence);
+    }
+
+    /**
+     * Get sfDestination (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getDestination() const
+    {
+        return this->sle_.at(sfDestination);
+    }
+
+    /**
+     * Get sfAmount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getAmount() const
+    {
+        return this->sle_.at(sfAmount);
+    }
+
+    /**
+     * Get sfCondition (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getCondition() const
+    {
+        if (hasCondition())
+            return this->sle_.at(sfCondition);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasCondition() const
+    {
+        return this->sle_.isFieldPresent(sfCondition);
+    }
+
+    /**
+     * Get sfCancelAfter (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getCancelAfter() const
+    {
+        if (hasCancelAfter())
+            return this->sle_.at(sfCancelAfter);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasCancelAfter() const
+    {
+        return this->sle_.isFieldPresent(sfCancelAfter);
+    }
+
+    /**
+     * Get sfFinishAfter (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getFinishAfter() const
+    {
+        if (hasFinishAfter())
+            return this->sle_.at(sfFinishAfter);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasFinishAfter() const
+    {
+        return this->sle_.isFieldPresent(sfFinishAfter);
+    }
+
+    /**
+     * Get sfSourceTag (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getSourceTag() const
+    {
+        if (hasSourceTag())
+            return this->sle_.at(sfSourceTag);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasSourceTag() const
+    {
+        return this->sle_.isFieldPresent(sfSourceTag);
+    }
+
+    /**
+     * Get sfDestinationTag (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getDestinationTag() const
+    {
+        if (hasDestinationTag())
+            return this->sle_.at(sfDestinationTag);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasDestinationTag() const
+    {
+        return this->sle_.isFieldPresent(sfDestinationTag);
+    }
+
+    /**
+     * Get sfOwnerNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_.at(sfOwnerNode);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+
+    /**
+     * Get sfDestinationNode (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getDestinationNode() const
+    {
+        if (hasDestinationNode())
+            return this->sle_.at(sfDestinationNode);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasDestinationNode() const
+    {
+        return this->sle_.isFieldPresent(sfDestinationNode);
+    }
+
+    /**
+     * Get sfTransferRate (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getTransferRate() const
+    {
+        if (hasTransferRate())
+            return this->sle_.at(sfTransferRate);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasTransferRate() const
+    {
+        return this->sle_.isFieldPresent(sfTransferRate);
+    }
+
+    /**
+     * Get sfIssuerNode (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getIssuerNode() const
+    {
+        if (hasIssuerNode())
+            return this->sle_.at(sfIssuerNode);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasIssuerNode() const
+    {
+        return this->sle_.isFieldPresent(sfIssuerNode);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    EscrowBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltESCROW)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Escrow");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed Escrow wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    Escrow
+    build(uint256 const& index)
+    {
+        return Escrow{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/FeeSettings.h

@@ -0,0 +1,355 @@
+#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 {
+
+// Forward declaration
+class FeeSettingsBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for FeeSettings");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfBaseFee (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getBaseFee() const
+    {
+        if (hasBaseFee())
+            return this->sle_.at(sfBaseFee);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasBaseFee() const
+    {
+        return this->sle_.isFieldPresent(sfBaseFee);
+    }
+
+    /**
+     * Get sfReferenceFeeUnits (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getReferenceFeeUnits() const
+    {
+        if (hasReferenceFeeUnits())
+            return this->sle_.at(sfReferenceFeeUnits);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasReferenceFeeUnits() const
+    {
+        return this->sle_.isFieldPresent(sfReferenceFeeUnits);
+    }
+
+    /**
+     * Get sfReserveBase (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getReserveBase() const
+    {
+        if (hasReserveBase())
+            return this->sle_.at(sfReserveBase);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasReserveBase() const
+    {
+        return this->sle_.isFieldPresent(sfReserveBase);
+    }
+
+    /**
+     * Get sfReserveIncrement (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getReserveIncrement() const
+    {
+        if (hasReserveIncrement())
+            return this->sle_.at(sfReserveIncrement);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasReserveIncrement() const
+    {
+        return this->sle_.isFieldPresent(sfReserveIncrement);
+    }
+
+    /**
+     * Get sfBaseFeeDrops (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getBaseFeeDrops() const
+    {
+        if (hasBaseFeeDrops())
+            return this->sle_.at(sfBaseFeeDrops);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasBaseFeeDrops() const
+    {
+        return this->sle_.isFieldPresent(sfBaseFeeDrops);
+    }
+
+    /**
+     * Get sfReserveBaseDrops (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getReserveBaseDrops() const
+    {
+        if (hasReserveBaseDrops())
+            return this->sle_.at(sfReserveBaseDrops);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasReserveBaseDrops() const
+    {
+        return this->sle_.isFieldPresent(sfReserveBaseDrops);
+    }
+
+    /**
+     * Get sfReserveIncrementDrops (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getReserveIncrementDrops() const
+    {
+        if (hasReserveIncrementDrops())
+            return this->sle_.at(sfReserveIncrementDrops);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasReserveIncrementDrops() const
+    {
+        return this->sle_.isFieldPresent(sfReserveIncrementDrops);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getPreviousTxnID() const
+    {
+        if (hasPreviousTxnID())
+            return this->sle_.at(sfPreviousTxnID);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasPreviousTxnID() const
+    {
+        return this->sle_.isFieldPresent(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getPreviousTxnLgrSeq() const
+    {
+        if (hasPreviousTxnLgrSeq())
+            return this->sle_.at(sfPreviousTxnLgrSeq);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasPreviousTxnLgrSeq() const
+    {
+        return this->sle_.isFieldPresent(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * 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:
+    FeeSettingsBuilder()
+        : LedgerEntryBuilderBase<FeeSettingsBuilder>(ltFEE_SETTINGS)
+    {
+    }
+
+    FeeSettingsBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltFEE_SETTINGS)
+        {
+            throw std::runtime_error("Invalid ledger entry type for FeeSettings");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed FeeSettings wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    FeeSettings
+    build(uint256 const& index)
+    {
+        return FeeSettings{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/LedgerHashes.h

@@ -0,0 +1,167 @@
+#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 {
+
+// Forward declaration
+class LedgerHashesBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for LedgerHashes");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfFirstLedgerSequence (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getFirstLedgerSequence() const
+    {
+        if (hasFirstLedgerSequence())
+            return this->sle_.at(sfFirstLedgerSequence);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasFirstLedgerSequence() const
+    {
+        return this->sle_.isFieldPresent(sfFirstLedgerSequence);
+    }
+
+    /**
+     * Get sfLastLedgerSequence (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getLastLedgerSequence() const
+    {
+        if (hasLastLedgerSequence())
+            return this->sle_.at(sfLastLedgerSequence);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasLastLedgerSequence() const
+    {
+        return this->sle_.isFieldPresent(sfLastLedgerSequence);
+    }
+
+    /**
+     * Get sfHashes (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_VECTOR256::type::value_type
+    getHashes() const
+    {
+        return this->sle_.at(sfHashes);
+    }
+};
+
+/**
+ * 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:
+    LedgerHashesBuilder(std::decay_t<typename SF_VECTOR256::type::value_type> const& hashes)
+        : LedgerEntryBuilderBase<LedgerHashesBuilder>(ltLEDGER_HASHES)
+    {
+        setHashes(hashes);
+    }
+
+    LedgerHashesBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltLEDGER_HASHES)
+        {
+            throw std::runtime_error("Invalid ledger entry type for LedgerHashes");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed LedgerHashes wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    LedgerHashes
+    build(uint256 const& index)
+    {
+        return LedgerHashes{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/Loan.h

@@ -0,0 +1,815 @@
+#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 {
+
+// Forward declaration
+class LoanBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Loan");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+
+    /**
+     * Get sfOwnerNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_.at(sfOwnerNode);
+    }
+
+    /**
+     * Get sfLoanBrokerNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getLoanBrokerNode() const
+    {
+        return this->sle_.at(sfLoanBrokerNode);
+    }
+
+    /**
+     * Get sfLoanBrokerID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getLoanBrokerID() const
+    {
+        return this->sle_.at(sfLoanBrokerID);
+    }
+
+    /**
+     * Get sfLoanSequence (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getLoanSequence() const
+    {
+        return this->sle_.at(sfLoanSequence);
+    }
+
+    /**
+     * Get sfBorrower (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getBorrower() const
+    {
+        return this->sle_.at(sfBorrower);
+    }
+
+    /**
+     * Get sfLoanOriginationFee (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getLoanOriginationFee() const
+    {
+        if (hasLoanOriginationFee())
+            return this->sle_.at(sfLoanOriginationFee);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasLoanOriginationFee() const
+    {
+        return this->sle_.isFieldPresent(sfLoanOriginationFee);
+    }
+
+    /**
+     * Get sfLoanServiceFee (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getLoanServiceFee() const
+    {
+        if (hasLoanServiceFee())
+            return this->sle_.at(sfLoanServiceFee);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasLoanServiceFee() const
+    {
+        return this->sle_.isFieldPresent(sfLoanServiceFee);
+    }
+
+    /**
+     * Get sfLatePaymentFee (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getLatePaymentFee() const
+    {
+        if (hasLatePaymentFee())
+            return this->sle_.at(sfLatePaymentFee);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasLatePaymentFee() const
+    {
+        return this->sle_.isFieldPresent(sfLatePaymentFee);
+    }
+
+    /**
+     * Get sfClosePaymentFee (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getClosePaymentFee() const
+    {
+        if (hasClosePaymentFee())
+            return this->sle_.at(sfClosePaymentFee);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasClosePaymentFee() const
+    {
+        return this->sle_.isFieldPresent(sfClosePaymentFee);
+    }
+
+    /**
+     * Get sfOverpaymentFee (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getOverpaymentFee() const
+    {
+        if (hasOverpaymentFee())
+            return this->sle_.at(sfOverpaymentFee);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasOverpaymentFee() const
+    {
+        return this->sle_.isFieldPresent(sfOverpaymentFee);
+    }
+
+    /**
+     * Get sfInterestRate (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getInterestRate() const
+    {
+        if (hasInterestRate())
+            return this->sle_.at(sfInterestRate);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasInterestRate() const
+    {
+        return this->sle_.isFieldPresent(sfInterestRate);
+    }
+
+    /**
+     * Get sfLateInterestRate (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getLateInterestRate() const
+    {
+        if (hasLateInterestRate())
+            return this->sle_.at(sfLateInterestRate);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasLateInterestRate() const
+    {
+        return this->sle_.isFieldPresent(sfLateInterestRate);
+    }
+
+    /**
+     * Get sfCloseInterestRate (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getCloseInterestRate() const
+    {
+        if (hasCloseInterestRate())
+            return this->sle_.at(sfCloseInterestRate);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasCloseInterestRate() const
+    {
+        return this->sle_.isFieldPresent(sfCloseInterestRate);
+    }
+
+    /**
+     * Get sfOverpaymentInterestRate (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getOverpaymentInterestRate() const
+    {
+        if (hasOverpaymentInterestRate())
+            return this->sle_.at(sfOverpaymentInterestRate);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasOverpaymentInterestRate() const
+    {
+        return this->sle_.isFieldPresent(sfOverpaymentInterestRate);
+    }
+
+    /**
+     * Get sfStartDate (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getStartDate() const
+    {
+        return this->sle_.at(sfStartDate);
+    }
+
+    /**
+     * Get sfPaymentInterval (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPaymentInterval() const
+    {
+        return this->sle_.at(sfPaymentInterval);
+    }
+
+    /**
+     * Get sfGracePeriod (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getGracePeriod() const
+    {
+        if (hasGracePeriod())
+            return this->sle_.at(sfGracePeriod);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasGracePeriod() const
+    {
+        return this->sle_.isFieldPresent(sfGracePeriod);
+    }
+
+    /**
+     * Get sfPreviousPaymentDueDate (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getPreviousPaymentDueDate() const
+    {
+        if (hasPreviousPaymentDueDate())
+            return this->sle_.at(sfPreviousPaymentDueDate);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasPreviousPaymentDueDate() const
+    {
+        return this->sle_.isFieldPresent(sfPreviousPaymentDueDate);
+    }
+
+    /**
+     * Get sfNextPaymentDueDate (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getNextPaymentDueDate() const
+    {
+        if (hasNextPaymentDueDate())
+            return this->sle_.at(sfNextPaymentDueDate);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasNextPaymentDueDate() const
+    {
+        return this->sle_.isFieldPresent(sfNextPaymentDueDate);
+    }
+
+    /**
+     * Get sfPaymentRemaining (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getPaymentRemaining() const
+    {
+        if (hasPaymentRemaining())
+            return this->sle_.at(sfPaymentRemaining);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasPaymentRemaining() const
+    {
+        return this->sle_.isFieldPresent(sfPaymentRemaining);
+    }
+
+    /**
+     * Get sfPeriodicPayment (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_NUMBER::type::value_type
+    getPeriodicPayment() const
+    {
+        return this->sle_.at(sfPeriodicPayment);
+    }
+
+    /**
+     * Get sfPrincipalOutstanding (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getPrincipalOutstanding() const
+    {
+        if (hasPrincipalOutstanding())
+            return this->sle_.at(sfPrincipalOutstanding);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasPrincipalOutstanding() const
+    {
+        return this->sle_.isFieldPresent(sfPrincipalOutstanding);
+    }
+
+    /**
+     * Get sfTotalValueOutstanding (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getTotalValueOutstanding() const
+    {
+        if (hasTotalValueOutstanding())
+            return this->sle_.at(sfTotalValueOutstanding);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasTotalValueOutstanding() const
+    {
+        return this->sle_.isFieldPresent(sfTotalValueOutstanding);
+    }
+
+    /**
+     * Get sfManagementFeeOutstanding (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getManagementFeeOutstanding() const
+    {
+        if (hasManagementFeeOutstanding())
+            return this->sle_.at(sfManagementFeeOutstanding);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasManagementFeeOutstanding() const
+    {
+        return this->sle_.isFieldPresent(sfManagementFeeOutstanding);
+    }
+
+    /**
+     * Get sfLoanScale (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_INT32::type::value_type>
+    getLoanScale() const
+    {
+        if (hasLoanScale())
+            return this->sle_.at(sfLoanScale);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasLoanScale() const
+    {
+        return this->sle_.isFieldPresent(sfLoanScale);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    LoanBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltLOAN)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Loan");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed Loan wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    Loan
+    build(uint256 const& index)
+    {
+        return Loan{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/LoanBroker.h

@@ -0,0 +1,523 @@
+#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 {
+
+// Forward declaration
+class LoanBrokerBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for LoanBroker");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+
+    /**
+     * Get sfSequence (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getSequence() const
+    {
+        return this->sle_.at(sfSequence);
+    }
+
+    /**
+     * Get sfOwnerNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_.at(sfOwnerNode);
+    }
+
+    /**
+     * Get sfVaultNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getVaultNode() const
+    {
+        return this->sle_.at(sfVaultNode);
+    }
+
+    /**
+     * Get sfVaultID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getVaultID() const
+    {
+        return this->sle_.at(sfVaultID);
+    }
+
+    /**
+     * Get sfAccount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_.at(sfAccount);
+    }
+
+    /**
+     * Get sfOwner (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getOwner() const
+    {
+        return this->sle_.at(sfOwner);
+    }
+
+    /**
+     * Get sfLoanSequence (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getLoanSequence() const
+    {
+        return this->sle_.at(sfLoanSequence);
+    }
+
+    /**
+     * Get sfData (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getData() const
+    {
+        if (hasData())
+            return this->sle_.at(sfData);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasData() const
+    {
+        return this->sle_.isFieldPresent(sfData);
+    }
+
+    /**
+     * Get sfManagementFeeRate (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT16::type::value_type>
+    getManagementFeeRate() const
+    {
+        if (hasManagementFeeRate())
+            return this->sle_.at(sfManagementFeeRate);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasManagementFeeRate() const
+    {
+        return this->sle_.isFieldPresent(sfManagementFeeRate);
+    }
+
+    /**
+     * Get sfOwnerCount (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getOwnerCount() const
+    {
+        if (hasOwnerCount())
+            return this->sle_.at(sfOwnerCount);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasOwnerCount() const
+    {
+        return this->sle_.isFieldPresent(sfOwnerCount);
+    }
+
+    /**
+     * Get sfDebtTotal (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getDebtTotal() const
+    {
+        if (hasDebtTotal())
+            return this->sle_.at(sfDebtTotal);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasDebtTotal() const
+    {
+        return this->sle_.isFieldPresent(sfDebtTotal);
+    }
+
+    /**
+     * Get sfDebtMaximum (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getDebtMaximum() const
+    {
+        if (hasDebtMaximum())
+            return this->sle_.at(sfDebtMaximum);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasDebtMaximum() const
+    {
+        return this->sle_.isFieldPresent(sfDebtMaximum);
+    }
+
+    /**
+     * Get sfCoverAvailable (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getCoverAvailable() const
+    {
+        if (hasCoverAvailable())
+            return this->sle_.at(sfCoverAvailable);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasCoverAvailable() const
+    {
+        return this->sle_.isFieldPresent(sfCoverAvailable);
+    }
+
+    /**
+     * Get sfCoverRateMinimum (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getCoverRateMinimum() const
+    {
+        if (hasCoverRateMinimum())
+            return this->sle_.at(sfCoverRateMinimum);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasCoverRateMinimum() const
+    {
+        return this->sle_.isFieldPresent(sfCoverRateMinimum);
+    }
+
+    /**
+     * Get sfCoverRateLiquidation (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getCoverRateLiquidation() const
+    {
+        if (hasCoverRateLiquidation())
+            return this->sle_.at(sfCoverRateLiquidation);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasCoverRateLiquidation() const
+    {
+        return this->sle_.isFieldPresent(sfCoverRateLiquidation);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    LoanBrokerBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltLOAN_BROKER)
+        {
+            throw std::runtime_error("Invalid ledger entry type for LoanBroker");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed LoanBroker wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    LoanBroker
+    build(uint256 const& index)
+    {
+        return LoanBroker{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/MPToken.h

@@ -0,0 +1,255 @@
+#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 {
+
+// Forward declaration
+class MPTokenBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for MPToken");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfAccount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_.at(sfAccount);
+    }
+
+    /**
+     * Get sfMPTokenIssuanceID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT192::type::value_type
+    getMPTokenIssuanceID() const
+    {
+        return this->sle_.at(sfMPTokenIssuanceID);
+    }
+
+    /**
+     * Get sfMPTAmount (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getMPTAmount() const
+    {
+        if (hasMPTAmount())
+            return this->sle_.at(sfMPTAmount);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasMPTAmount() const
+    {
+        return this->sle_.isFieldPresent(sfMPTAmount);
+    }
+
+    /**
+     * Get sfLockedAmount (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getLockedAmount() const
+    {
+        if (hasLockedAmount())
+            return this->sle_.at(sfLockedAmount);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasLockedAmount() const
+    {
+        return this->sle_.isFieldPresent(sfLockedAmount);
+    }
+
+    /**
+     * Get sfOwnerNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_.at(sfOwnerNode);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    MPTokenBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltMPTOKEN)
+        {
+            throw std::runtime_error("Invalid ledger entry type for MPToken");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed MPToken wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    MPToken
+    build(uint256 const& index)
+    {
+        return MPToken{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/MPTokenIssuance.h

@@ -0,0 +1,427 @@
+#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 {
+
+// Forward declaration
+class MPTokenIssuanceBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for MPTokenIssuance");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfIssuer (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getIssuer() const
+    {
+        return this->sle_.at(sfIssuer);
+    }
+
+    /**
+     * Get sfSequence (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getSequence() const
+    {
+        return this->sle_.at(sfSequence);
+    }
+
+    /**
+     * Get sfTransferFee (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT16::type::value_type>
+    getTransferFee() const
+    {
+        if (hasTransferFee())
+            return this->sle_.at(sfTransferFee);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasTransferFee() const
+    {
+        return this->sle_.isFieldPresent(sfTransferFee);
+    }
+
+    /**
+     * Get sfOwnerNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_.at(sfOwnerNode);
+    }
+
+    /**
+     * Get sfAssetScale (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT8::type::value_type>
+    getAssetScale() const
+    {
+        if (hasAssetScale())
+            return this->sle_.at(sfAssetScale);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasAssetScale() const
+    {
+        return this->sle_.isFieldPresent(sfAssetScale);
+    }
+
+    /**
+     * Get sfMaximumAmount (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getMaximumAmount() const
+    {
+        if (hasMaximumAmount())
+            return this->sle_.at(sfMaximumAmount);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasMaximumAmount() const
+    {
+        return this->sle_.isFieldPresent(sfMaximumAmount);
+    }
+
+    /**
+     * Get sfOutstandingAmount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOutstandingAmount() const
+    {
+        return this->sle_.at(sfOutstandingAmount);
+    }
+
+    /**
+     * Get sfLockedAmount (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getLockedAmount() const
+    {
+        if (hasLockedAmount())
+            return this->sle_.at(sfLockedAmount);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasLockedAmount() const
+    {
+        return this->sle_.isFieldPresent(sfLockedAmount);
+    }
+
+    /**
+     * Get sfMPTokenMetadata (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getMPTokenMetadata() const
+    {
+        if (hasMPTokenMetadata())
+            return this->sle_.at(sfMPTokenMetadata);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasMPTokenMetadata() const
+    {
+        return this->sle_.isFieldPresent(sfMPTokenMetadata);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+
+    /**
+     * Get sfDomainID (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getDomainID() const
+    {
+        if (hasDomainID())
+            return this->sle_.at(sfDomainID);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasDomainID() const
+    {
+        return this->sle_.isFieldPresent(sfDomainID);
+    }
+
+    /**
+     * Get sfMutableFlags (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getMutableFlags() const
+    {
+        if (hasMutableFlags())
+            return this->sle_.at(sfMutableFlags);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasMutableFlags() const
+    {
+        return this->sle_.isFieldPresent(sfMutableFlags);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    MPTokenIssuanceBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltMPTOKEN_ISSUANCE)
+        {
+            throw std::runtime_error("Invalid ledger entry type for MPTokenIssuance");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed MPTokenIssuance wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    MPTokenIssuance
+    build(uint256 const& index)
+    {
+        return MPTokenIssuance{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/NFTokenOffer.h

@@ -0,0 +1,299 @@
+#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 {
+
+// Forward declaration
+class NFTokenOfferBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for NFTokenOffer");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfOwner (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getOwner() const
+    {
+        return this->sle_.at(sfOwner);
+    }
+
+    /**
+     * Get sfNFTokenID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getNFTokenID() const
+    {
+        return this->sle_.at(sfNFTokenID);
+    }
+
+    /**
+     * Get sfAmount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getAmount() const
+    {
+        return this->sle_.at(sfAmount);
+    }
+
+    /**
+     * Get sfOwnerNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_.at(sfOwnerNode);
+    }
+
+    /**
+     * Get sfNFTokenOfferNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getNFTokenOfferNode() const
+    {
+        return this->sle_.at(sfNFTokenOfferNode);
+    }
+
+    /**
+     * Get sfDestination (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getDestination() const
+    {
+        if (hasDestination())
+            return this->sle_.at(sfDestination);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasDestination() const
+    {
+        return this->sle_.isFieldPresent(sfDestination);
+    }
+
+    /**
+     * Get sfExpiration (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getExpiration() const
+    {
+        if (hasExpiration())
+            return this->sle_.at(sfExpiration);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasExpiration() const
+    {
+        return this->sle_.isFieldPresent(sfExpiration);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    NFTokenOfferBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltNFTOKEN_OFFER)
+        {
+            throw std::runtime_error("Invalid ledger entry type for NFTokenOffer");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed NFTokenOffer wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    NFTokenOffer
+    build(uint256 const& index)
+    {
+        return NFTokenOffer{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/NFTokenPage.h

@@ -0,0 +1,212 @@
+#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 {
+
+// Forward declaration
+class NFTokenPageBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for NFTokenPage");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfPreviousPageMin (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getPreviousPageMin() const
+    {
+        if (hasPreviousPageMin())
+            return this->sle_.at(sfPreviousPageMin);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasPreviousPageMin() const
+    {
+        return this->sle_.isFieldPresent(sfPreviousPageMin);
+    }
+
+    /**
+     * Get sfNextPageMin (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getNextPageMin() const
+    {
+        if (hasNextPageMin())
+            return this->sle_.at(sfNextPageMin);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasNextPageMin() const
+    {
+        return this->sle_.isFieldPresent(sfNextPageMin);
+    }
+
+    /**
+     * Get sfNFTokens (soeREQUIRED)
+     * Note: This is an untyped field (unknown).
+     */
+    [[nodiscard]]
+    STArray const&
+    getNFTokens() const
+    {
+        return this->sle_.getFieldArray(sfNFTokens);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    NFTokenPageBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltNFTOKEN_PAGE)
+        {
+            throw std::runtime_error("Invalid ledger entry type for NFTokenPage");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Set sfNFTokens (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    NFTokenPageBuilder&
+    setNFTokens(STArray const& value)
+    {
+        object_.setFieldArray(sfNFTokens, value);
+        return *this;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed NFTokenPage wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    NFTokenPage
+    build(uint256 const& index)
+    {
+        return NFTokenPage{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/NegativeUNL.h

@@ -0,0 +1,236 @@
+#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 {
+
+// Forward declaration
+class NegativeUNLBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for NegativeUNL");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfDisabledValidators (soeOPTIONAL)
+     * Note: This is an untyped field (unknown).
+     */
+    [[nodiscard]]
+    std::optional<std::reference_wrapper<STArray const>>
+    getDisabledValidators() const
+    {
+        if (this->sle_.isFieldPresent(sfDisabledValidators))
+            return this->sle_.getFieldArray(sfDisabledValidators);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasDisabledValidators() const
+    {
+        return this->sle_.isFieldPresent(sfDisabledValidators);
+    }
+
+    /**
+     * Get sfValidatorToDisable (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getValidatorToDisable() const
+    {
+        if (hasValidatorToDisable())
+            return this->sle_.at(sfValidatorToDisable);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasValidatorToDisable() const
+    {
+        return this->sle_.isFieldPresent(sfValidatorToDisable);
+    }
+
+    /**
+     * Get sfValidatorToReEnable (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getValidatorToReEnable() const
+    {
+        if (hasValidatorToReEnable())
+            return this->sle_.at(sfValidatorToReEnable);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasValidatorToReEnable() const
+    {
+        return this->sle_.isFieldPresent(sfValidatorToReEnable);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getPreviousTxnID() const
+    {
+        if (hasPreviousTxnID())
+            return this->sle_.at(sfPreviousTxnID);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasPreviousTxnID() const
+    {
+        return this->sle_.isFieldPresent(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getPreviousTxnLgrSeq() const
+    {
+        if (hasPreviousTxnLgrSeq())
+            return this->sle_.at(sfPreviousTxnLgrSeq);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasPreviousTxnLgrSeq() const
+    {
+        return this->sle_.isFieldPresent(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * 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:
+    NegativeUNLBuilder()
+        : LedgerEntryBuilderBase<NegativeUNLBuilder>(ltNEGATIVE_UNL)
+    {
+    }
+
+    NegativeUNLBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltNEGATIVE_UNL)
+        {
+            throw std::runtime_error("Invalid ledger entry type for NegativeUNL");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * Set sfDisabledValidators (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    NegativeUNLBuilder&
+    setDisabledValidators(STArray const& value)
+    {
+        object_.setFieldArray(sfDisabledValidators, value);
+        return *this;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed NegativeUNL wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    NegativeUNL
+    build(uint256 const& index)
+    {
+        return NegativeUNL{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/Offer.h

@@ -0,0 +1,374 @@
+#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 {
+
+// Forward declaration
+class OfferBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Offer");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfAccount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_.at(sfAccount);
+    }
+
+    /**
+     * Get sfSequence (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getSequence() const
+    {
+        return this->sle_.at(sfSequence);
+    }
+
+    /**
+     * Get sfTakerPays (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getTakerPays() const
+    {
+        return this->sle_.at(sfTakerPays);
+    }
+
+    /**
+     * Get sfTakerGets (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getTakerGets() const
+    {
+        return this->sle_.at(sfTakerGets);
+    }
+
+    /**
+     * Get sfBookDirectory (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getBookDirectory() const
+    {
+        return this->sle_.at(sfBookDirectory);
+    }
+
+    /**
+     * Get sfBookNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getBookNode() const
+    {
+        return this->sle_.at(sfBookNode);
+    }
+
+    /**
+     * Get sfOwnerNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_.at(sfOwnerNode);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+
+    /**
+     * Get sfExpiration (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getExpiration() const
+    {
+        if (hasExpiration())
+            return this->sle_.at(sfExpiration);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasExpiration() const
+    {
+        return this->sle_.isFieldPresent(sfExpiration);
+    }
+
+    /**
+     * Get sfDomainID (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getDomainID() const
+    {
+        if (hasDomainID())
+            return this->sle_.at(sfDomainID);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasDomainID() const
+    {
+        return this->sle_.isFieldPresent(sfDomainID);
+    }
+
+    /**
+     * Get sfAdditionalBooks (soeOPTIONAL)
+     * Note: This is an untyped field (unknown).
+     */
+    [[nodiscard]]
+    std::optional<std::reference_wrapper<STArray const>>
+    getAdditionalBooks() const
+    {
+        if (this->sle_.isFieldPresent(sfAdditionalBooks))
+            return this->sle_.getFieldArray(sfAdditionalBooks);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasAdditionalBooks() const
+    {
+        return this->sle_.isFieldPresent(sfAdditionalBooks);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    OfferBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltOFFER)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Offer");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Set sfAdditionalBooks (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    OfferBuilder&
+    setAdditionalBooks(STArray const& value)
+    {
+        object_.setFieldArray(sfAdditionalBooks, value);
+        return *this;
+    }
+
+    /**
+     * Build and return the completed Offer wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    Offer
+    build(uint256 const& index)
+    {
+        return Offer{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/Oracle.h

@@ -0,0 +1,322 @@
+#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 {
+
+// Forward declaration
+class OracleBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Oracle");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfOwner (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getOwner() const
+    {
+        return this->sle_.at(sfOwner);
+    }
+
+    /**
+     * Get sfOracleDocumentID (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getOracleDocumentID() const
+    {
+        if (hasOracleDocumentID())
+            return this->sle_.at(sfOracleDocumentID);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasOracleDocumentID() const
+    {
+        return this->sle_.isFieldPresent(sfOracleDocumentID);
+    }
+
+    /**
+     * Get sfProvider (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_VL::type::value_type
+    getProvider() const
+    {
+        return this->sle_.at(sfProvider);
+    }
+
+    /**
+     * Get sfPriceDataSeries (soeREQUIRED)
+     * Note: This is an untyped field (unknown).
+     */
+    [[nodiscard]]
+    STArray const&
+    getPriceDataSeries() const
+    {
+        return this->sle_.getFieldArray(sfPriceDataSeries);
+    }
+
+    /**
+     * Get sfAssetClass (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_VL::type::value_type
+    getAssetClass() const
+    {
+        return this->sle_.at(sfAssetClass);
+    }
+
+    /**
+     * Get sfLastUpdateTime (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getLastUpdateTime() const
+    {
+        return this->sle_.at(sfLastUpdateTime);
+    }
+
+    /**
+     * Get sfURI (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getURI() const
+    {
+        if (hasURI())
+            return this->sle_.at(sfURI);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasURI() const
+    {
+        return this->sle_.isFieldPresent(sfURI);
+    }
+
+    /**
+     * Get sfOwnerNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_.at(sfOwnerNode);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    OracleBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltORACLE)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Oracle");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Set sfPriceDataSeries (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    OracleBuilder&
+    setPriceDataSeries(STArray const& value)
+    {
+        object_.setFieldArray(sfPriceDataSeries, value);
+        return *this;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed Oracle wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    Oracle
+    build(uint256 const& index)
+    {
+        return Oracle{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/PayChannel.h

@@ -0,0 +1,463 @@
+#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 {
+
+// Forward declaration
+class PayChannelBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for PayChannel");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfAccount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_.at(sfAccount);
+    }
+
+    /**
+     * Get sfDestination (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getDestination() const
+    {
+        return this->sle_.at(sfDestination);
+    }
+
+    /**
+     * Get sfSequence (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getSequence() const
+    {
+        if (hasSequence())
+            return this->sle_.at(sfSequence);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasSequence() const
+    {
+        return this->sle_.isFieldPresent(sfSequence);
+    }
+
+    /**
+     * Get sfAmount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getAmount() const
+    {
+        return this->sle_.at(sfAmount);
+    }
+
+    /**
+     * Get sfBalance (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getBalance() const
+    {
+        return this->sle_.at(sfBalance);
+    }
+
+    /**
+     * Get sfPublicKey (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_VL::type::value_type
+    getPublicKey() const
+    {
+        return this->sle_.at(sfPublicKey);
+    }
+
+    /**
+     * Get sfSettleDelay (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getSettleDelay() const
+    {
+        return this->sle_.at(sfSettleDelay);
+    }
+
+    /**
+     * Get sfExpiration (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getExpiration() const
+    {
+        if (hasExpiration())
+            return this->sle_.at(sfExpiration);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasExpiration() const
+    {
+        return this->sle_.isFieldPresent(sfExpiration);
+    }
+
+    /**
+     * Get sfCancelAfter (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getCancelAfter() const
+    {
+        if (hasCancelAfter())
+            return this->sle_.at(sfCancelAfter);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasCancelAfter() const
+    {
+        return this->sle_.isFieldPresent(sfCancelAfter);
+    }
+
+    /**
+     * Get sfSourceTag (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getSourceTag() const
+    {
+        if (hasSourceTag())
+            return this->sle_.at(sfSourceTag);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasSourceTag() const
+    {
+        return this->sle_.isFieldPresent(sfSourceTag);
+    }
+
+    /**
+     * Get sfDestinationTag (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getDestinationTag() const
+    {
+        if (hasDestinationTag())
+            return this->sle_.at(sfDestinationTag);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasDestinationTag() const
+    {
+        return this->sle_.isFieldPresent(sfDestinationTag);
+    }
+
+    /**
+     * Get sfOwnerNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_.at(sfOwnerNode);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+
+    /**
+     * Get sfDestinationNode (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getDestinationNode() const
+    {
+        if (hasDestinationNode())
+            return this->sle_.at(sfDestinationNode);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasDestinationNode() const
+    {
+        return this->sle_.isFieldPresent(sfDestinationNode);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    PayChannelBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltPAYCHAN)
+        {
+            throw std::runtime_error("Invalid ledger entry type for PayChannel");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed PayChannel wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    PayChannel
+    build(uint256 const& index)
+    {
+        return PayChannel{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/PermissionedDomain.h

@@ -0,0 +1,218 @@
+#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 {
+
+// Forward declaration
+class PermissionedDomainBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for PermissionedDomain");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfOwner (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getOwner() const
+    {
+        return this->sle_.at(sfOwner);
+    }
+
+    /**
+     * Get sfSequence (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getSequence() const
+    {
+        return this->sle_.at(sfSequence);
+    }
+
+    /**
+     * Get sfAcceptedCredentials (soeREQUIRED)
+     * Note: This is an untyped field (unknown).
+     */
+    [[nodiscard]]
+    STArray const&
+    getAcceptedCredentials() const
+    {
+        return this->sle_.getFieldArray(sfAcceptedCredentials);
+    }
+
+    /**
+     * Get sfOwnerNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_.at(sfOwnerNode);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    PermissionedDomainBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltPERMISSIONED_DOMAIN)
+        {
+            throw std::runtime_error("Invalid ledger entry type for PermissionedDomain");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Set sfAcceptedCredentials (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    PermissionedDomainBuilder&
+    setAcceptedCredentials(STArray const& value)
+    {
+        object_.setFieldArray(sfAcceptedCredentials, value);
+        return *this;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed PermissionedDomain wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    PermissionedDomain
+    build(uint256 const& index)
+    {
+        return PermissionedDomain{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/RippleState.h

@@ -0,0 +1,375 @@
+#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 {
+
+// Forward declaration
+class RippleStateBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for RippleState");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfBalance (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getBalance() const
+    {
+        return this->sle_.at(sfBalance);
+    }
+
+    /**
+     * Get sfLowLimit (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getLowLimit() const
+    {
+        return this->sle_.at(sfLowLimit);
+    }
+
+    /**
+     * Get sfHighLimit (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getHighLimit() const
+    {
+        return this->sle_.at(sfHighLimit);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+
+    /**
+     * Get sfLowNode (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getLowNode() const
+    {
+        if (hasLowNode())
+            return this->sle_.at(sfLowNode);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasLowNode() const
+    {
+        return this->sle_.isFieldPresent(sfLowNode);
+    }
+
+    /**
+     * Get sfLowQualityIn (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getLowQualityIn() const
+    {
+        if (hasLowQualityIn())
+            return this->sle_.at(sfLowQualityIn);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasLowQualityIn() const
+    {
+        return this->sle_.isFieldPresent(sfLowQualityIn);
+    }
+
+    /**
+     * Get sfLowQualityOut (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getLowQualityOut() const
+    {
+        if (hasLowQualityOut())
+            return this->sle_.at(sfLowQualityOut);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasLowQualityOut() const
+    {
+        return this->sle_.isFieldPresent(sfLowQualityOut);
+    }
+
+    /**
+     * Get sfHighNode (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT64::type::value_type>
+    getHighNode() const
+    {
+        if (hasHighNode())
+            return this->sle_.at(sfHighNode);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasHighNode() const
+    {
+        return this->sle_.isFieldPresent(sfHighNode);
+    }
+
+    /**
+     * Get sfHighQualityIn (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getHighQualityIn() const
+    {
+        if (hasHighQualityIn())
+            return this->sle_.at(sfHighQualityIn);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasHighQualityIn() const
+    {
+        return this->sle_.isFieldPresent(sfHighQualityIn);
+    }
+
+    /**
+     * Get sfHighQualityOut (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getHighQualityOut() const
+    {
+        if (hasHighQualityOut())
+            return this->sle_.at(sfHighQualityOut);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasHighQualityOut() const
+    {
+        return this->sle_.isFieldPresent(sfHighQualityOut);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    RippleStateBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltRIPPLE_STATE)
+        {
+            throw std::runtime_error("Invalid ledger entry type for RippleState");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed RippleState wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    RippleState
+    build(uint256 const& index)
+    {
+        return RippleState{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/SignerList.h

@@ -0,0 +1,248 @@
+#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 {
+
+// Forward declaration
+class SignerListBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for SignerList");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfOwner (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getOwner() const
+    {
+        if (hasOwner())
+            return this->sle_.at(sfOwner);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasOwner() const
+    {
+        return this->sle_.isFieldPresent(sfOwner);
+    }
+
+    /**
+     * Get sfOwnerNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_.at(sfOwnerNode);
+    }
+
+    /**
+     * Get sfSignerQuorum (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getSignerQuorum() const
+    {
+        return this->sle_.at(sfSignerQuorum);
+    }
+
+    /**
+     * Get sfSignerEntries (soeREQUIRED)
+     * Note: This is an untyped field (unknown).
+     */
+    [[nodiscard]]
+    STArray const&
+    getSignerEntries() const
+    {
+        return this->sle_.getFieldArray(sfSignerEntries);
+    }
+
+    /**
+     * Get sfSignerListID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getSignerListID() const
+    {
+        return this->sle_.at(sfSignerListID);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    SignerListBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltSIGNER_LIST)
+        {
+            throw std::runtime_error("Invalid ledger entry type for SignerList");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Set sfSignerEntries (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    SignerListBuilder&
+    setSignerEntries(STArray const& value)
+    {
+        object_.setFieldArray(sfSignerEntries, value);
+        return *this;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed SignerList wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    SignerList
+    build(uint256 const& index)
+    {
+        return SignerList{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/Ticket.h

@@ -0,0 +1,195 @@
+#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 {
+
+// Forward declaration
+class TicketBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Ticket");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfAccount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_.at(sfAccount);
+    }
+
+    /**
+     * Get sfOwnerNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_.at(sfOwnerNode);
+    }
+
+    /**
+     * Get sfTicketSequence (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getTicketSequence() const
+    {
+        return this->sle_.at(sfTicketSequence);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    TicketBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltTICKET)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Ticket");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed Ticket wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    Ticket
+    build(uint256 const& index)
+    {
+        return Ticket{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/Vault.h

@@ -0,0 +1,463 @@
+#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 {
+
+// Forward declaration
+class VaultBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Vault");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+
+    /**
+     * Get sfSequence (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getSequence() const
+    {
+        return this->sle_.at(sfSequence);
+    }
+
+    /**
+     * Get sfOwnerNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_.at(sfOwnerNode);
+    }
+
+    /**
+     * Get sfOwner (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getOwner() const
+    {
+        return this->sle_.at(sfOwner);
+    }
+
+    /**
+     * Get sfAccount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_.at(sfAccount);
+    }
+
+    /**
+     * Get sfData (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getData() const
+    {
+        if (hasData())
+            return this->sle_.at(sfData);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasData() const
+    {
+        return this->sle_.isFieldPresent(sfData);
+    }
+
+    /**
+     * Get sfAsset (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset() const
+    {
+        return this->sle_.at(sfAsset);
+    }
+
+    /**
+     * Get sfAssetsTotal (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getAssetsTotal() const
+    {
+        if (hasAssetsTotal())
+            return this->sle_.at(sfAssetsTotal);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasAssetsTotal() const
+    {
+        return this->sle_.isFieldPresent(sfAssetsTotal);
+    }
+
+    /**
+     * Get sfAssetsAvailable (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getAssetsAvailable() const
+    {
+        if (hasAssetsAvailable())
+            return this->sle_.at(sfAssetsAvailable);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasAssetsAvailable() const
+    {
+        return this->sle_.isFieldPresent(sfAssetsAvailable);
+    }
+
+    /**
+     * Get sfAssetsMaximum (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getAssetsMaximum() const
+    {
+        if (hasAssetsMaximum())
+            return this->sle_.at(sfAssetsMaximum);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasAssetsMaximum() const
+    {
+        return this->sle_.isFieldPresent(sfAssetsMaximum);
+    }
+
+    /**
+     * Get sfLossUnrealized (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getLossUnrealized() const
+    {
+        if (hasLossUnrealized())
+            return this->sle_.at(sfLossUnrealized);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasLossUnrealized() const
+    {
+        return this->sle_.isFieldPresent(sfLossUnrealized);
+    }
+
+    /**
+     * Get sfShareMPTID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT192::type::value_type
+    getShareMPTID() const
+    {
+        return this->sle_.at(sfShareMPTID);
+    }
+
+    /**
+     * Get sfWithdrawalPolicy (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT8::type::value_type
+    getWithdrawalPolicy() const
+    {
+        return this->sle_.at(sfWithdrawalPolicy);
+    }
+
+    /**
+     * Get sfScale (soeDEFAULT)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT8::type::value_type>
+    getScale() const
+    {
+        if (hasScale())
+            return this->sle_.at(sfScale);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasScale() const
+    {
+        return this->sle_.isFieldPresent(sfScale);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    VaultBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltVAULT)
+        {
+            throw std::runtime_error("Invalid ledger entry type for Vault");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed Vault wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    Vault
+    build(uint256 const& index)
+    {
+        return Vault{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/XChainOwnedClaimID.h

@@ -0,0 +1,284 @@
+#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 {
+
+// Forward declaration
+class XChainOwnedClaimIDBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for XChainOwnedClaimID");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfAccount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_.at(sfAccount);
+    }
+
+    /**
+     * Get sfXChainBridge (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_XCHAIN_BRIDGE::type::value_type
+    getXChainBridge() const
+    {
+        return this->sle_.at(sfXChainBridge);
+    }
+
+    /**
+     * Get sfXChainClaimID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getXChainClaimID() const
+    {
+        return this->sle_.at(sfXChainClaimID);
+    }
+
+    /**
+     * Get sfOtherChainSource (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getOtherChainSource() const
+    {
+        return this->sle_.at(sfOtherChainSource);
+    }
+
+    /**
+     * Get sfXChainClaimAttestations (soeREQUIRED)
+     * Note: This is an untyped field (unknown).
+     */
+    [[nodiscard]]
+    STArray const&
+    getXChainClaimAttestations() const
+    {
+        return this->sle_.getFieldArray(sfXChainClaimAttestations);
+    }
+
+    /**
+     * Get sfSignatureReward (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getSignatureReward() const
+    {
+        return this->sle_.at(sfSignatureReward);
+    }
+
+    /**
+     * Get sfOwnerNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_.at(sfOwnerNode);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    XChainOwnedClaimIDBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltXCHAIN_OWNED_CLAIM_ID)
+        {
+            throw std::runtime_error("Invalid ledger entry type for XChainOwnedClaimID");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Set sfXChainClaimAttestations (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedClaimIDBuilder&
+    setXChainClaimAttestations(STArray const& value)
+    {
+        object_.setFieldArray(sfXChainClaimAttestations, value);
+        return *this;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed XChainOwnedClaimID wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    XChainOwnedClaimID
+    build(uint256 const& index)
+    {
+        return XChainOwnedClaimID{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/XChainOwnedCreateAccountClaimID.h

@@ -0,0 +1,240 @@
+#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 {
+
+// Forward declaration
+class XChainOwnedCreateAccountClaimIDBuilder;
+
+/**
+ * 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;
+
+    /**
+     * 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(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for XChainOwnedCreateAccountClaimID");
+        }
+    }
+
+    // Ledger entry-specific field getters
+
+    /**
+     * Get sfAccount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAccount() const
+    {
+        return this->sle_.at(sfAccount);
+    }
+
+    /**
+     * Get sfXChainBridge (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_XCHAIN_BRIDGE::type::value_type
+    getXChainBridge() const
+    {
+        return this->sle_.at(sfXChainBridge);
+    }
+
+    /**
+     * Get sfXChainAccountCreateCount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getXChainAccountCreateCount() const
+    {
+        return this->sle_.at(sfXChainAccountCreateCount);
+    }
+
+    /**
+     * Get sfXChainCreateAccountAttestations (soeREQUIRED)
+     * Note: This is an untyped field (unknown).
+     */
+    [[nodiscard]]
+    STArray const&
+    getXChainCreateAccountAttestations() const
+    {
+        return this->sle_.getFieldArray(sfXChainCreateAccountAttestations);
+    }
+
+    /**
+     * Get sfOwnerNode (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT64::type::value_type
+    getOwnerNode() const
+    {
+        return this->sle_.at(sfOwnerNode);
+    }
+
+    /**
+     * Get sfPreviousTxnID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getPreviousTxnID() const
+    {
+        return this->sle_.at(sfPreviousTxnID);
+    }
+
+    /**
+     * Get sfPreviousTxnLgrSeq (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getPreviousTxnLgrSeq() const
+    {
+        return this->sle_.at(sfPreviousTxnLgrSeq);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    XChainOwnedCreateAccountClaimIDBuilder(SLE const& sle)
+    {
+        if (sle[sfLedgerEntryType] != ltXCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID)
+        {
+            throw std::runtime_error("Invalid ledger entry type for XChainOwnedCreateAccountClaimID");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Set sfXChainCreateAccountAttestations (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    XChainOwnedCreateAccountClaimIDBuilder&
+    setXChainCreateAccountAttestations(STArray const& value)
+    {
+        object_.setFieldArray(sfXChainCreateAccountAttestations, value);
+        return *this;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed XChainOwnedCreateAccountClaimID wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    XChainOwnedCreateAccountClaimID
+    build(uint256 const& index)
+    {
+        return XChainOwnedCreateAccountClaimID{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/transactions/AMMBid.h

@@ -0,0 +1,228 @@
+#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 {
+
+// Forward declaration
+class AMMBidBuilder;
+
+/**
+ * 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;
+
+    /**
+     * Construct a AMMBid transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit AMMBid(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMBid");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfAsset (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset() const
+    {
+        return this->tx_.at(sfAsset);
+    }
+
+    /**
+     * Get sfAsset2 (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset2() const
+    {
+        return this->tx_.at(sfAsset2);
+    }
+
+    /**
+     * Get sfBidMin (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getBidMin() const
+    {
+        if (hasBidMin())
+        {
+            return this->tx_.at(sfBidMin);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasBidMin() const
+    {
+        return this->tx_.isFieldPresent(sfBidMin);
+    }
+
+    /**
+     * Get sfBidMax (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getBidMax() const
+    {
+        if (hasBidMax())
+        {
+            return this->tx_.at(sfBidMax);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasBidMax() const
+    {
+        return this->tx_.isFieldPresent(sfBidMax);
+    }
+    /**
+     * Get sfAuthAccounts (soeOPTIONAL)
+     * Note: This is an untyped field
+     */
+    [[nodiscard]]
+    std::optional<std::reference_wrapper<STArray const>>
+    getAuthAccounts() const
+    {
+        if (this->tx_.isFieldPresent(sfAuthAccounts))
+            return this->tx_.getFieldArray(sfAuthAccounts);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasAuthAccounts() const
+    {
+        return this->tx_.isFieldPresent(sfAuthAccounts);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    AMMBidBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttAMM_BID)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMBidBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Set sfAuthAccounts (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    AMMBidBuilder&
+    setAuthAccounts(STArray const& value)
+    {
+        object_.setFieldArray(sfAuthAccounts, value);
+        return *this;
+    }
+
+    /**
+     * Build and return the completed AMMBid wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    AMMBid
+    build()
+    {
+        return AMMBid(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/AMMClawback.h

@@ -0,0 +1,188 @@
+#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 {
+
+// Forward declaration
+class AMMClawbackBuilder;
+
+/**
+ * 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;
+
+    /**
+     * Construct a AMMClawback transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit AMMClawback(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMClawback");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfHolder (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getHolder() const
+    {
+        return this->tx_.at(sfHolder);
+    }
+
+    /**
+     * Get sfAsset (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset() const
+    {
+        return this->tx_.at(sfAsset);
+    }
+
+    /**
+     * Get sfAsset2 (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset2() const
+    {
+        return this->tx_.at(sfAsset2);
+    }
+
+    /**
+     * Get sfAmount (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getAmount() const
+    {
+        if (hasAmount())
+        {
+            return this->tx_.at(sfAmount);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasAmount() const
+    {
+        return this->tx_.isFieldPresent(sfAmount);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    AMMClawbackBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttAMM_CLAWBACK)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMClawbackBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed AMMClawback wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    AMMClawback
+    build()
+    {
+        return AMMClawback(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/AMMCreate.h

@@ -0,0 +1,156 @@
+#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 {
+
+// Forward declaration
+class AMMCreateBuilder;
+
+/**
+ * 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;
+
+    /**
+     * Construct a AMMCreate transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit AMMCreate(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMCreate");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfAmount (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getAmount() const
+    {
+        return this->tx_.at(sfAmount);
+    }
+
+    /**
+     * Get sfAmount2 (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getAmount2() const
+    {
+        return this->tx_.at(sfAmount2);
+    }
+
+    /**
+     * Get sfTradingFee (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT16::type::value_type
+    getTradingFee() const
+    {
+        return this->tx_.at(sfTradingFee);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    AMMCreateBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttAMM_CREATE)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMCreateBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed AMMCreate wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    AMMCreate
+    build()
+    {
+        return AMMCreate(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/AMMDelete.h

@@ -0,0 +1,134 @@
+#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 {
+
+// Forward declaration
+class AMMDeleteBuilder;
+
+/**
+ * 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;
+
+    /**
+     * Construct a AMMDelete transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit AMMDelete(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMDelete");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfAsset (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset() const
+    {
+        return this->tx_.at(sfAsset);
+    }
+
+    /**
+     * Get sfAsset2 (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset2() const
+    {
+        return this->tx_.at(sfAsset2);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    AMMDeleteBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttAMM_DELETE)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMDeleteBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed AMMDelete wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    AMMDelete
+    build()
+    {
+        return AMMDelete(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/AMMDeposit.h

@@ -0,0 +1,294 @@
+#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 {
+
+// Forward declaration
+class AMMDepositBuilder;
+
+/**
+ * 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;
+
+    /**
+     * Construct a AMMDeposit transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit AMMDeposit(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMDeposit");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfAsset (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset() const
+    {
+        return this->tx_.at(sfAsset);
+    }
+
+    /**
+     * Get sfAsset2 (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset2() const
+    {
+        return this->tx_.at(sfAsset2);
+    }
+
+    /**
+     * Get sfAmount (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getAmount() const
+    {
+        if (hasAmount())
+        {
+            return this->tx_.at(sfAmount);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasAmount() const
+    {
+        return this->tx_.isFieldPresent(sfAmount);
+    }
+
+    /**
+     * Get sfAmount2 (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getAmount2() const
+    {
+        if (hasAmount2())
+        {
+            return this->tx_.at(sfAmount2);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasAmount2() const
+    {
+        return this->tx_.isFieldPresent(sfAmount2);
+    }
+
+    /**
+     * Get sfEPrice (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getEPrice() const
+    {
+        if (hasEPrice())
+        {
+            return this->tx_.at(sfEPrice);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasEPrice() const
+    {
+        return this->tx_.isFieldPresent(sfEPrice);
+    }
+
+    /**
+     * Get sfLPTokenOut (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getLPTokenOut() const
+    {
+        if (hasLPTokenOut())
+        {
+            return this->tx_.at(sfLPTokenOut);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasLPTokenOut() const
+    {
+        return this->tx_.isFieldPresent(sfLPTokenOut);
+    }
+
+    /**
+     * Get sfTradingFee (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT16::type::value_type>
+    getTradingFee() const
+    {
+        if (hasTradingFee())
+        {
+            return this->tx_.at(sfTradingFee);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasTradingFee() const
+    {
+        return this->tx_.isFieldPresent(sfTradingFee);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    AMMDepositBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttAMM_DEPOSIT)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMDepositBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed AMMDeposit wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    AMMDeposit
+    build()
+    {
+        return AMMDeposit(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/AMMVote.h

@@ -0,0 +1,156 @@
+#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 {
+
+// Forward declaration
+class AMMVoteBuilder;
+
+/**
+ * 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;
+
+    /**
+     * Construct a AMMVote transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit AMMVote(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMVote");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfAsset (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset() const
+    {
+        return this->tx_.at(sfAsset);
+    }
+
+    /**
+     * Get sfAsset2 (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset2() const
+    {
+        return this->tx_.at(sfAsset2);
+    }
+
+    /**
+     * Get sfTradingFee (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT16::type::value_type
+    getTradingFee() const
+    {
+        return this->tx_.at(sfTradingFee);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    AMMVoteBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttAMM_VOTE)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMVoteBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed AMMVote wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    AMMVote
+    build()
+    {
+        return AMMVote(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/AMMWithdraw.h

@@ -0,0 +1,262 @@
+#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 {
+
+// Forward declaration
+class AMMWithdrawBuilder;
+
+/**
+ * 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;
+
+    /**
+     * Construct a AMMWithdraw transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit AMMWithdraw(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMWithdraw");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfAsset (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset() const
+    {
+        return this->tx_.at(sfAsset);
+    }
+
+    /**
+     * Get sfAsset2 (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ISSUE::type::value_type
+    getAsset2() const
+    {
+        return this->tx_.at(sfAsset2);
+    }
+
+    /**
+     * Get sfAmount (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getAmount() const
+    {
+        if (hasAmount())
+        {
+            return this->tx_.at(sfAmount);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasAmount() const
+    {
+        return this->tx_.isFieldPresent(sfAmount);
+    }
+
+    /**
+     * Get sfAmount2 (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getAmount2() const
+    {
+        if (hasAmount2())
+        {
+            return this->tx_.at(sfAmount2);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasAmount2() const
+    {
+        return this->tx_.isFieldPresent(sfAmount2);
+    }
+
+    /**
+     * Get sfEPrice (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getEPrice() const
+    {
+        if (hasEPrice())
+        {
+            return this->tx_.at(sfEPrice);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasEPrice() const
+    {
+        return this->tx_.isFieldPresent(sfEPrice);
+    }
+
+    /**
+     * Get sfLPTokenIn (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getLPTokenIn() const
+    {
+        if (hasLPTokenIn())
+        {
+            return this->tx_.at(sfLPTokenIn);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasLPTokenIn() const
+    {
+        return this->tx_.isFieldPresent(sfLPTokenIn);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    AMMWithdrawBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttAMM_WITHDRAW)
+        {
+            throw std::runtime_error("Invalid transaction type for AMMWithdrawBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed AMMWithdraw wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    AMMWithdraw
+    build()
+    {
+        return AMMWithdraw(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/AccountDelete.h

@@ -0,0 +1,176 @@
+#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 {
+
+// Forward declaration
+class AccountDeleteBuilder;
+
+/**
+ * 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;
+
+    /**
+     * Construct a AccountDelete transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit AccountDelete(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for AccountDelete");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfDestination (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getDestination() const
+    {
+        return this->tx_.at(sfDestination);
+    }
+
+    /**
+     * Get sfDestinationTag (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getDestinationTag() const
+    {
+        if (hasDestinationTag())
+        {
+            return this->tx_.at(sfDestinationTag);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasDestinationTag() const
+    {
+        return this->tx_.isFieldPresent(sfDestinationTag);
+    }
+
+    /**
+     * Get sfCredentialIDs (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VECTOR256::type::value_type>
+    getCredentialIDs() const
+    {
+        if (hasCredentialIDs())
+        {
+            return this->tx_.at(sfCredentialIDs);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasCredentialIDs() const
+    {
+        return this->tx_.isFieldPresent(sfCredentialIDs);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    AccountDeleteBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttACCOUNT_DELETE)
+        {
+            throw std::runtime_error("Invalid transaction type for AccountDeleteBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed AccountDelete wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    AccountDelete
+    build()
+    {
+        return AccountDelete(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/AccountSet.h

@@ -0,0 +1,410 @@
+#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 {
+
+// Forward declaration
+class AccountSetBuilder;
+
+/**
+ * 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;
+
+    /**
+     * Construct a AccountSet transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit AccountSet(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for AccountSet");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfEmailHash (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT128::type::value_type>
+    getEmailHash() const
+    {
+        if (hasEmailHash())
+        {
+            return this->tx_.at(sfEmailHash);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasEmailHash() const
+    {
+        return this->tx_.isFieldPresent(sfEmailHash);
+    }
+
+    /**
+     * Get sfWalletLocator (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getWalletLocator() const
+    {
+        if (hasWalletLocator())
+        {
+            return this->tx_.at(sfWalletLocator);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasWalletLocator() const
+    {
+        return this->tx_.isFieldPresent(sfWalletLocator);
+    }
+
+    /**
+     * Get sfWalletSize (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getWalletSize() const
+    {
+        if (hasWalletSize())
+        {
+            return this->tx_.at(sfWalletSize);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasWalletSize() const
+    {
+        return this->tx_.isFieldPresent(sfWalletSize);
+    }
+
+    /**
+     * Get sfMessageKey (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getMessageKey() const
+    {
+        if (hasMessageKey())
+        {
+            return this->tx_.at(sfMessageKey);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasMessageKey() const
+    {
+        return this->tx_.isFieldPresent(sfMessageKey);
+    }
+
+    /**
+     * Get sfDomain (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getDomain() const
+    {
+        if (hasDomain())
+        {
+            return this->tx_.at(sfDomain);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasDomain() const
+    {
+        return this->tx_.isFieldPresent(sfDomain);
+    }
+
+    /**
+     * Get sfTransferRate (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getTransferRate() const
+    {
+        if (hasTransferRate())
+        {
+            return this->tx_.at(sfTransferRate);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasTransferRate() const
+    {
+        return this->tx_.isFieldPresent(sfTransferRate);
+    }
+
+    /**
+     * Get sfSetFlag (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getSetFlag() const
+    {
+        if (hasSetFlag())
+        {
+            return this->tx_.at(sfSetFlag);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasSetFlag() const
+    {
+        return this->tx_.isFieldPresent(sfSetFlag);
+    }
+
+    /**
+     * Get sfClearFlag (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getClearFlag() const
+    {
+        if (hasClearFlag())
+        {
+            return this->tx_.at(sfClearFlag);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasClearFlag() const
+    {
+        return this->tx_.isFieldPresent(sfClearFlag);
+    }
+
+    /**
+     * Get sfTickSize (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT8::type::value_type>
+    getTickSize() const
+    {
+        if (hasTickSize())
+        {
+            return this->tx_.at(sfTickSize);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasTickSize() const
+    {
+        return this->tx_.isFieldPresent(sfTickSize);
+    }
+
+    /**
+     * Get sfNFTokenMinter (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getNFTokenMinter() const
+    {
+        if (hasNFTokenMinter())
+        {
+            return this->tx_.at(sfNFTokenMinter);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasNFTokenMinter() const
+    {
+        return this->tx_.isFieldPresent(sfNFTokenMinter);
+    }
+};
+
+/**
+ * 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:
+    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)
+    {
+    }
+
+    AccountSetBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttACCOUNT_SET)
+        {
+            throw std::runtime_error("Invalid transaction type for AccountSetBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed AccountSet wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    AccountSet
+    build()
+    {
+        return AccountSet(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/Batch.h

@@ -0,0 +1,142 @@
+#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 {
+
+// Forward declaration
+class BatchBuilder;
+
+/**
+ * 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;
+
+    /**
+     * Construct a Batch transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit Batch(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for Batch");
+        }
+    }
+
+    // Transaction-specific field getters
+    /**
+     * Get sfRawTransactions (soeREQUIRED)
+     * Note: This is an untyped field
+     */
+    [[nodiscard]]
+    STArray const&
+    getRawTransactions() const
+    {
+        return this->tx_.getFieldArray(sfRawTransactions);
+    }
+    /**
+     * Get sfBatchSigners (soeOPTIONAL)
+     * Note: This is an untyped field
+     */
+    [[nodiscard]]
+    std::optional<std::reference_wrapper<STArray const>>
+    getBatchSigners() const
+    {
+        if (this->tx_.isFieldPresent(sfBatchSigners))
+            return this->tx_.getFieldArray(sfBatchSigners);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasBatchSigners() const
+    {
+        return this->tx_.isFieldPresent(sfBatchSigners);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    BatchBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttBATCH)
+        {
+            throw std::runtime_error("Invalid transaction type for BatchBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * Set sfRawTransactions (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    BatchBuilder&
+    setRawTransactions(STArray const& value)
+    {
+        object_.setFieldArray(sfRawTransactions, value);
+        return *this;
+    }
+
+    /**
+     * Set sfBatchSigners (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    BatchBuilder&
+    setBatchSigners(STArray const& value)
+    {
+        object_.setFieldArray(sfBatchSigners, value);
+        return *this;
+    }
+
+    /**
+     * Build and return the completed Batch wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    Batch
+    build()
+    {
+        return Batch(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/CheckCancel.h

@@ -0,0 +1,112 @@
+#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 {
+
+// Forward declaration
+class CheckCancelBuilder;
+
+/**
+ * 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;
+
+    /**
+     * Construct a CheckCancel transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit CheckCancel(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for CheckCancel");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfCheckID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getCheckID() const
+    {
+        return this->tx_.at(sfCheckID);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    CheckCancelBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttCHECK_CANCEL)
+        {
+            throw std::runtime_error("Invalid transaction type for CheckCancelBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed CheckCancel wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    CheckCancel
+    build()
+    {
+        return CheckCancel(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/CheckCash.h

@@ -0,0 +1,176 @@
+#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 {
+
+// Forward declaration
+class CheckCashBuilder;
+
+/**
+ * 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;
+
+    /**
+     * Construct a CheckCash transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit CheckCash(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for CheckCash");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfCheckID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getCheckID() const
+    {
+        return this->tx_.at(sfCheckID);
+    }
+
+    /**
+     * Get sfAmount (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getAmount() const
+    {
+        if (hasAmount())
+        {
+            return this->tx_.at(sfAmount);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasAmount() const
+    {
+        return this->tx_.isFieldPresent(sfAmount);
+    }
+
+    /**
+     * Get sfDeliverMin (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getDeliverMin() const
+    {
+        if (hasDeliverMin())
+        {
+            return this->tx_.at(sfDeliverMin);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasDeliverMin() const
+    {
+        return this->tx_.isFieldPresent(sfDeliverMin);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    CheckCashBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttCHECK_CASH)
+        {
+            throw std::runtime_error("Invalid transaction type for CheckCashBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed CheckCash wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    CheckCash
+    build()
+    {
+        return CheckCash(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/CheckCreate.h

@@ -0,0 +1,230 @@
+#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 {
+
+// Forward declaration
+class CheckCreateBuilder;
+
+/**
+ * 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;
+
+    /**
+     * Construct a CheckCreate transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit CheckCreate(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for CheckCreate");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfDestination (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getDestination() const
+    {
+        return this->tx_.at(sfDestination);
+    }
+
+    /**
+     * Get sfSendMax (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getSendMax() const
+    {
+        return this->tx_.at(sfSendMax);
+    }
+
+    /**
+     * Get sfExpiration (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getExpiration() const
+    {
+        if (hasExpiration())
+        {
+            return this->tx_.at(sfExpiration);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasExpiration() const
+    {
+        return this->tx_.isFieldPresent(sfExpiration);
+    }
+
+    /**
+     * Get sfDestinationTag (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getDestinationTag() const
+    {
+        if (hasDestinationTag())
+        {
+            return this->tx_.at(sfDestinationTag);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasDestinationTag() const
+    {
+        return this->tx_.isFieldPresent(sfDestinationTag);
+    }
+
+    /**
+     * Get sfInvoiceID (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getInvoiceID() const
+    {
+        if (hasInvoiceID())
+        {
+            return this->tx_.at(sfInvoiceID);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasInvoiceID() const
+    {
+        return this->tx_.isFieldPresent(sfInvoiceID);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    CheckCreateBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttCHECK_CREATE)
+        {
+            throw std::runtime_error("Invalid transaction type for CheckCreateBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed CheckCreate wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    CheckCreate
+    build()
+    {
+        return CheckCreate(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/Clawback.h

@@ -0,0 +1,146 @@
+#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 {
+
+// Forward declaration
+class ClawbackBuilder;
+
+/**
+ * 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;
+
+    /**
+     * Construct a Clawback transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit Clawback(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for Clawback");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfAmount (soeREQUIRED)
+     * Note: This field supports MPT (Multi-Purpose Token) amounts.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getAmount() const
+    {
+        return this->tx_.at(sfAmount);
+    }
+
+    /**
+     * Get sfHolder (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getHolder() const
+    {
+        if (hasHolder())
+        {
+            return this->tx_.at(sfHolder);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasHolder() const
+    {
+        return this->tx_.isFieldPresent(sfHolder);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    ClawbackBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttCLAWBACK)
+        {
+            throw std::runtime_error("Invalid transaction type for ClawbackBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed Clawback wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    Clawback
+    build()
+    {
+        return Clawback(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/CredentialAccept.h

@@ -0,0 +1,134 @@
+#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 {
+
+// Forward declaration
+class CredentialAcceptBuilder;
+
+/**
+ * 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;
+
+    /**
+     * Construct a CredentialAccept transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit CredentialAccept(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for CredentialAccept");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfIssuer (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getIssuer() const
+    {
+        return this->tx_.at(sfIssuer);
+    }
+
+    /**
+     * Get sfCredentialType (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_VL::type::value_type
+    getCredentialType() const
+    {
+        return this->tx_.at(sfCredentialType);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    CredentialAcceptBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttCREDENTIAL_ACCEPT)
+        {
+            throw std::runtime_error("Invalid transaction type for CredentialAcceptBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed CredentialAccept wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    CredentialAccept
+    build()
+    {
+        return CredentialAccept(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/CredentialCreate.h

@@ -0,0 +1,198 @@
+#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 {
+
+// Forward declaration
+class CredentialCreateBuilder;
+
+/**
+ * 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;
+
+    /**
+     * Construct a CredentialCreate transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit CredentialCreate(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for CredentialCreate");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfSubject (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getSubject() const
+    {
+        return this->tx_.at(sfSubject);
+    }
+
+    /**
+     * Get sfCredentialType (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_VL::type::value_type
+    getCredentialType() const
+    {
+        return this->tx_.at(sfCredentialType);
+    }
+
+    /**
+     * Get sfExpiration (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getExpiration() const
+    {
+        if (hasExpiration())
+        {
+            return this->tx_.at(sfExpiration);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasExpiration() const
+    {
+        return this->tx_.isFieldPresent(sfExpiration);
+    }
+
+    /**
+     * Get sfURI (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getURI() const
+    {
+        if (hasURI())
+        {
+            return this->tx_.at(sfURI);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasURI() const
+    {
+        return this->tx_.isFieldPresent(sfURI);
+    }
+};
+
+/**
+ * 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:
+    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);
+    }
+
+    CredentialCreateBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttCREDENTIAL_CREATE)
+        {
+            throw std::runtime_error("Invalid transaction type for CredentialCreateBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Build and return the completed CredentialCreate wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    CredentialCreate
+    build()
+    {
+        return CredentialCreate(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/CredentialDelete.h

@@ -0,0 +1,176 @@
+#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 {
+
+// Forward declaration
+class CredentialDeleteBuilder;
+
+/**
+ * Transaction: CredentialDelete
+ * Type: ttCREDENTIAL_DELETE (60)
+ * Delegable: Delegation::delegable
+ * Amendment: featureCredentials
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use CredentialDeleteBuilder to construct new transactions.
+ */
+class CredentialDelete : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttCREDENTIAL_DELETE;
+
+    /**
+     * Construct a CredentialDelete transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit CredentialDelete(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for CredentialDelete");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfSubject (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getSubject() const
+    {
+        if (hasSubject())
+        {
+            return this->tx_.at(sfSubject);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasSubject() const
+    {
+        return this->tx_.isFieldPresent(sfSubject);
+    }
+
+    /**
+     * Get sfIssuer (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getIssuer() const
+    {
+        if (hasIssuer())
+        {
+            return this->tx_.at(sfIssuer);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasIssuer() const
+    {
+        return this->tx_.isFieldPresent(sfIssuer);
+    }
+
+    /**
+     * Get sfCredentialType (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_VL::type::value_type
+    getCredentialType() const
+    {
+        return this->tx_.at(sfCredentialType);
+    }
+};
+
+/**
+ * Builder for CredentialDelete 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 CredentialDeleteBuilder : public TransactionBuilderBase<CredentialDeleteBuilder>
+{
+public:
+    CredentialDeleteBuilder(SF_ACCOUNT::type::value_type account,
+                     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<CredentialDeleteBuilder>(ttCREDENTIAL_DELETE, account, sequence, fee)
+    {
+        setCredentialType(credentialType);
+    }
+
+    CredentialDeleteBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttCREDENTIAL_DELETE)
+        {
+            throw std::runtime_error("Invalid transaction type for CredentialDeleteBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * Set sfSubject (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    CredentialDeleteBuilder&
+    setSubject(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfSubject] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfIssuer (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    CredentialDeleteBuilder&
+    setIssuer(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfIssuer] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfCredentialType (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    CredentialDeleteBuilder&
+    setCredentialType(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfCredentialType] = value;
+        return *this;
+    }
+
+    /**
+     * Build and return the completed CredentialDelete wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    CredentialDelete
+    build()
+    {
+        return CredentialDelete(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/DIDDelete.h

@@ -0,0 +1,90 @@
+#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 {
+
+// Forward declaration
+class DIDDeleteBuilder;
+
+/**
+ * Transaction: DIDDelete
+ * Type: ttDID_DELETE (50)
+ * Delegable: Delegation::delegable
+ * Amendment: featureDID
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use DIDDeleteBuilder to construct new transactions.
+ */
+class DIDDelete : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttDID_DELETE;
+
+    /**
+     * Construct a DIDDelete transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit DIDDelete(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for DIDDelete");
+        }
+    }
+
+    // Transaction-specific field getters
+};
+
+/**
+ * Builder for DIDDelete 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 DIDDeleteBuilder : public TransactionBuilderBase<DIDDeleteBuilder>
+{
+public:
+    DIDDeleteBuilder(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<DIDDeleteBuilder>(ttDID_DELETE, account, sequence, fee)
+    {
+    }
+
+    DIDDeleteBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttDID_DELETE)
+        {
+            throw std::runtime_error("Invalid transaction type for DIDDeleteBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * Build and return the completed DIDDelete wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    DIDDelete
+    build()
+    {
+        return DIDDelete(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/DIDSet.h

@@ -0,0 +1,186 @@
+#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 {
+
+// Forward declaration
+class DIDSetBuilder;
+
+/**
+ * Transaction: DIDSet
+ * Type: ttDID_SET (49)
+ * Delegable: Delegation::delegable
+ * Amendment: featureDID
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use DIDSetBuilder to construct new transactions.
+ */
+class DIDSet : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttDID_SET;
+
+    /**
+     * Construct a DIDSet transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit DIDSet(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for DIDSet");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfDIDDocument (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getDIDDocument() const
+    {
+        if (hasDIDDocument())
+        {
+            return this->tx_.at(sfDIDDocument);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasDIDDocument() const
+    {
+        return this->tx_.isFieldPresent(sfDIDDocument);
+    }
+
+    /**
+     * Get sfURI (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getURI() const
+    {
+        if (hasURI())
+        {
+            return this->tx_.at(sfURI);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasURI() const
+    {
+        return this->tx_.isFieldPresent(sfURI);
+    }
+
+    /**
+     * Get sfData (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getData() const
+    {
+        if (hasData())
+        {
+            return this->tx_.at(sfData);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasData() const
+    {
+        return this->tx_.isFieldPresent(sfData);
+    }
+};
+
+/**
+ * Builder for DIDSet 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 DIDSetBuilder : public TransactionBuilderBase<DIDSetBuilder>
+{
+public:
+    DIDSetBuilder(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<DIDSetBuilder>(ttDID_SET, account, sequence, fee)
+    {
+    }
+
+    DIDSetBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttDID_SET)
+        {
+            throw std::runtime_error("Invalid transaction type for DIDSetBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * Set sfDIDDocument (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DIDSetBuilder&
+    setDIDDocument(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfDIDDocument] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfURI (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DIDSetBuilder&
+    setURI(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfURI] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfData (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DIDSetBuilder&
+    setData(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfData] = value;
+        return *this;
+    }
+
+    /**
+     * Build and return the completed DIDSet wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    DIDSet
+    build()
+    {
+        return DIDSet(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/DelegateSet.h

@@ -0,0 +1,134 @@
+#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 {
+
+// Forward declaration
+class DelegateSetBuilder;
+
+/**
+ * Transaction: DelegateSet
+ * Type: ttDELEGATE_SET (64)
+ * Delegable: Delegation::notDelegable
+ * Amendment: featurePermissionDelegationV1_1
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use DelegateSetBuilder to construct new transactions.
+ */
+class DelegateSet : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttDELEGATE_SET;
+
+    /**
+     * Construct a DelegateSet transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit DelegateSet(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for DelegateSet");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfAuthorize (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getAuthorize() const
+    {
+        return this->tx_.at(sfAuthorize);
+    }
+    /**
+     * Get sfPermissions (soeREQUIRED)
+     * Note: This is an untyped field
+     */
+    [[nodiscard]]
+    STArray const&
+    getPermissions() const
+    {
+        return this->tx_.getFieldArray(sfPermissions);
+    }
+};
+
+/**
+ * Builder for DelegateSet 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 DelegateSetBuilder : public TransactionBuilderBase<DelegateSetBuilder>
+{
+public:
+    DelegateSetBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_ACCOUNT::type::value_type> const& authorize,                     STArray const& permissions,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<DelegateSetBuilder>(ttDELEGATE_SET, account, sequence, fee)
+    {
+        setAuthorize(authorize);
+        setPermissions(permissions);
+    }
+
+    DelegateSetBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttDELEGATE_SET)
+        {
+            throw std::runtime_error("Invalid transaction type for DelegateSetBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * Set sfAuthorize (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    DelegateSetBuilder&
+    setAuthorize(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfAuthorize] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfPermissions (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    DelegateSetBuilder&
+    setPermissions(STArray const& value)
+    {
+        object_.setFieldArray(sfPermissions, value);
+        return *this;
+    }
+
+    /**
+     * Build and return the completed DelegateSet wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    DelegateSet
+    build()
+    {
+        return DelegateSet(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/DepositPreauth.h

@@ -0,0 +1,214 @@
+#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 {
+
+// Forward declaration
+class DepositPreauthBuilder;
+
+/**
+ * Transaction: DepositPreauth
+ * Type: ttDEPOSIT_PREAUTH (19)
+ * Delegable: Delegation::delegable
+ * Amendment: uint256{}
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use DepositPreauthBuilder to construct new transactions.
+ */
+class DepositPreauth : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttDEPOSIT_PREAUTH;
+
+    /**
+     * Construct a DepositPreauth transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit DepositPreauth(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for DepositPreauth");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfAuthorize (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getAuthorize() const
+    {
+        if (hasAuthorize())
+        {
+            return this->tx_.at(sfAuthorize);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasAuthorize() const
+    {
+        return this->tx_.isFieldPresent(sfAuthorize);
+    }
+
+    /**
+     * Get sfUnauthorize (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getUnauthorize() const
+    {
+        if (hasUnauthorize())
+        {
+            return this->tx_.at(sfUnauthorize);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasUnauthorize() const
+    {
+        return this->tx_.isFieldPresent(sfUnauthorize);
+    }
+    /**
+     * Get sfAuthorizeCredentials (soeOPTIONAL)
+     * Note: This is an untyped field
+     */
+    [[nodiscard]]
+    std::optional<std::reference_wrapper<STArray const>>
+    getAuthorizeCredentials() const
+    {
+        if (this->tx_.isFieldPresent(sfAuthorizeCredentials))
+            return this->tx_.getFieldArray(sfAuthorizeCredentials);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasAuthorizeCredentials() const
+    {
+        return this->tx_.isFieldPresent(sfAuthorizeCredentials);
+    }
+    /**
+     * Get sfUnauthorizeCredentials (soeOPTIONAL)
+     * Note: This is an untyped field
+     */
+    [[nodiscard]]
+    std::optional<std::reference_wrapper<STArray const>>
+    getUnauthorizeCredentials() const
+    {
+        if (this->tx_.isFieldPresent(sfUnauthorizeCredentials))
+            return this->tx_.getFieldArray(sfUnauthorizeCredentials);
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasUnauthorizeCredentials() const
+    {
+        return this->tx_.isFieldPresent(sfUnauthorizeCredentials);
+    }
+};
+
+/**
+ * Builder for DepositPreauth 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 DepositPreauthBuilder : public TransactionBuilderBase<DepositPreauthBuilder>
+{
+public:
+    DepositPreauthBuilder(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<DepositPreauthBuilder>(ttDEPOSIT_PREAUTH, account, sequence, fee)
+    {
+    }
+
+    DepositPreauthBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttDEPOSIT_PREAUTH)
+        {
+            throw std::runtime_error("Invalid transaction type for DepositPreauthBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * 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;
+    }
+
+    /**
+     * Set sfUnauthorize (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DepositPreauthBuilder&
+    setUnauthorize(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfUnauthorize] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfAuthorizeCredentials (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DepositPreauthBuilder&
+    setAuthorizeCredentials(STArray const& value)
+    {
+        object_.setFieldArray(sfAuthorizeCredentials, value);
+        return *this;
+    }
+
+    /**
+     * Set sfUnauthorizeCredentials (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    DepositPreauthBuilder&
+    setUnauthorizeCredentials(STArray const& value)
+    {
+        object_.setFieldArray(sfUnauthorizeCredentials, value);
+        return *this;
+    }
+
+    /**
+     * Build and return the completed DepositPreauth wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    DepositPreauth
+    build()
+    {
+        return DepositPreauth(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/EnableAmendment.h

@@ -0,0 +1,134 @@
+#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 {
+
+// Forward declaration
+class EnableAmendmentBuilder;
+
+/**
+ * Transaction: EnableAmendment
+ * Type: ttAMENDMENT (100)
+ * Delegable: Delegation::notDelegable
+ * Amendment: uint256{}
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use EnableAmendmentBuilder to construct new transactions.
+ */
+class EnableAmendment : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttAMENDMENT;
+
+    /**
+     * Construct a EnableAmendment transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit EnableAmendment(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for EnableAmendment");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfLedgerSequence (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getLedgerSequence() const
+    {
+        return this->tx_.at(sfLedgerSequence);
+    }
+
+    /**
+     * Get sfAmendment (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getAmendment() const
+    {
+        return this->tx_.at(sfAmendment);
+    }
+};
+
+/**
+ * Builder for EnableAmendment 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 EnableAmendmentBuilder : public TransactionBuilderBase<EnableAmendmentBuilder>
+{
+public:
+    EnableAmendmentBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_UINT32::type::value_type> const& ledgerSequence,                     std::decay_t<typename SF_UINT256::type::value_type> const& amendment,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<EnableAmendmentBuilder>(ttAMENDMENT, account, sequence, fee)
+    {
+        setLedgerSequence(ledgerSequence);
+        setAmendment(amendment);
+    }
+
+    EnableAmendmentBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttAMENDMENT)
+        {
+            throw std::runtime_error("Invalid transaction type for EnableAmendmentBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * Set sfLedgerSequence (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    EnableAmendmentBuilder&
+    setLedgerSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfLedgerSequence] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfAmendment (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    EnableAmendmentBuilder&
+    setAmendment(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfAmendment] = value;
+        return *this;
+    }
+
+    /**
+     * Build and return the completed EnableAmendment wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    EnableAmendment
+    build()
+    {
+        return EnableAmendment(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/EscrowCancel.h

@@ -0,0 +1,134 @@
+#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 {
+
+// Forward declaration
+class EscrowCancelBuilder;
+
+/**
+ * Transaction: EscrowCancel
+ * Type: ttESCROW_CANCEL (4)
+ * Delegable: Delegation::delegable
+ * Amendment: uint256{}
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use EscrowCancelBuilder to construct new transactions.
+ */
+class EscrowCancel : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttESCROW_CANCEL;
+
+    /**
+     * Construct a EscrowCancel transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit EscrowCancel(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for EscrowCancel");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfOwner (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getOwner() const
+    {
+        return this->tx_.at(sfOwner);
+    }
+
+    /**
+     * Get sfOfferSequence (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getOfferSequence() const
+    {
+        return this->tx_.at(sfOfferSequence);
+    }
+};
+
+/**
+ * Builder for EscrowCancel 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 EscrowCancelBuilder : public TransactionBuilderBase<EscrowCancelBuilder>
+{
+public:
+    EscrowCancelBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_ACCOUNT::type::value_type> const& owner,                     std::decay_t<typename SF_UINT32::type::value_type> const& offerSequence,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<EscrowCancelBuilder>(ttESCROW_CANCEL, account, sequence, fee)
+    {
+        setOwner(owner);
+        setOfferSequence(offerSequence);
+    }
+
+    EscrowCancelBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttESCROW_CANCEL)
+        {
+            throw std::runtime_error("Invalid transaction type for EscrowCancelBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * Set sfOwner (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowCancelBuilder&
+    setOwner(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfOwner] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfOfferSequence (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowCancelBuilder&
+    setOfferSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfOfferSequence] = value;
+        return *this;
+    }
+
+    /**
+     * Build and return the completed EscrowCancel wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    EscrowCancel
+    build()
+    {
+        return EscrowCancel(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/EscrowCreate.h

@@ -0,0 +1,264 @@
+#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 {
+
+// Forward declaration
+class EscrowCreateBuilder;
+
+/**
+ * Transaction: EscrowCreate
+ * Type: ttESCROW_CREATE (1)
+ * Delegable: Delegation::delegable
+ * Amendment: uint256{}
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use EscrowCreateBuilder to construct new transactions.
+ */
+class EscrowCreate : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttESCROW_CREATE;
+
+    /**
+     * Construct a EscrowCreate transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit EscrowCreate(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for EscrowCreate");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfDestination (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getDestination() const
+    {
+        return this->tx_.at(sfDestination);
+    }
+
+    /**
+     * Get sfAmount (soeREQUIRED)
+     * Note: This field supports MPT (Multi-Purpose Token) amounts.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getAmount() const
+    {
+        return this->tx_.at(sfAmount);
+    }
+
+    /**
+     * Get sfCondition (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getCondition() const
+    {
+        if (hasCondition())
+        {
+            return this->tx_.at(sfCondition);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasCondition() const
+    {
+        return this->tx_.isFieldPresent(sfCondition);
+    }
+
+    /**
+     * Get sfCancelAfter (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getCancelAfter() const
+    {
+        if (hasCancelAfter())
+        {
+            return this->tx_.at(sfCancelAfter);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasCancelAfter() const
+    {
+        return this->tx_.isFieldPresent(sfCancelAfter);
+    }
+
+    /**
+     * Get sfFinishAfter (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getFinishAfter() const
+    {
+        if (hasFinishAfter())
+        {
+            return this->tx_.at(sfFinishAfter);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasFinishAfter() const
+    {
+        return this->tx_.isFieldPresent(sfFinishAfter);
+    }
+
+    /**
+     * Get sfDestinationTag (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getDestinationTag() const
+    {
+        if (hasDestinationTag())
+        {
+            return this->tx_.at(sfDestinationTag);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasDestinationTag() const
+    {
+        return this->tx_.isFieldPresent(sfDestinationTag);
+    }
+};
+
+/**
+ * Builder for EscrowCreate 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 EscrowCreateBuilder : public TransactionBuilderBase<EscrowCreateBuilder>
+{
+public:
+    EscrowCreateBuilder(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& amount,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<EscrowCreateBuilder>(ttESCROW_CREATE, account, sequence, fee)
+    {
+        setDestination(destination);
+        setAmount(amount);
+    }
+
+    EscrowCreateBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttESCROW_CREATE)
+        {
+            throw std::runtime_error("Invalid transaction type for EscrowCreateBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * Set sfDestination (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowCreateBuilder&
+    setDestination(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfDestination] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfAmount (soeREQUIRED)
+     * Note: This field supports MPT (Multi-Purpose Token) amounts.
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowCreateBuilder&
+    setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfAmount] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfCondition (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowCreateBuilder&
+    setCondition(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfCondition] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfCancelAfter (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowCreateBuilder&
+    setCancelAfter(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfCancelAfter] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfFinishAfter (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowCreateBuilder&
+    setFinishAfter(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfFinishAfter] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfDestinationTag (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowCreateBuilder&
+    setDestinationTag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfDestinationTag] = value;
+        return *this;
+    }
+
+    /**
+     * Build and return the completed EscrowCreate wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    EscrowCreate
+    build()
+    {
+        return EscrowCreate(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/EscrowFinish.h

@@ -0,0 +1,230 @@
+#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 {
+
+// Forward declaration
+class EscrowFinishBuilder;
+
+/**
+ * Transaction: EscrowFinish
+ * Type: ttESCROW_FINISH (2)
+ * Delegable: Delegation::delegable
+ * Amendment: uint256{}
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use EscrowFinishBuilder to construct new transactions.
+ */
+class EscrowFinish : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttESCROW_FINISH;
+
+    /**
+     * Construct a EscrowFinish transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit EscrowFinish(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for EscrowFinish");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfOwner (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_ACCOUNT::type::value_type
+    getOwner() const
+    {
+        return this->tx_.at(sfOwner);
+    }
+
+    /**
+     * Get sfOfferSequence (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT32::type::value_type
+    getOfferSequence() const
+    {
+        return this->tx_.at(sfOfferSequence);
+    }
+
+    /**
+     * Get sfFulfillment (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getFulfillment() const
+    {
+        if (hasFulfillment())
+        {
+            return this->tx_.at(sfFulfillment);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasFulfillment() const
+    {
+        return this->tx_.isFieldPresent(sfFulfillment);
+    }
+
+    /**
+     * Get sfCondition (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getCondition() const
+    {
+        if (hasCondition())
+        {
+            return this->tx_.at(sfCondition);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasCondition() const
+    {
+        return this->tx_.isFieldPresent(sfCondition);
+    }
+
+    /**
+     * Get sfCredentialIDs (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VECTOR256::type::value_type>
+    getCredentialIDs() const
+    {
+        if (hasCredentialIDs())
+        {
+            return this->tx_.at(sfCredentialIDs);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasCredentialIDs() const
+    {
+        return this->tx_.isFieldPresent(sfCredentialIDs);
+    }
+};
+
+/**
+ * Builder for EscrowFinish 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 EscrowFinishBuilder : public TransactionBuilderBase<EscrowFinishBuilder>
+{
+public:
+    EscrowFinishBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_ACCOUNT::type::value_type> const& owner,                     std::decay_t<typename SF_UINT32::type::value_type> const& offerSequence,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<EscrowFinishBuilder>(ttESCROW_FINISH, account, sequence, fee)
+    {
+        setOwner(owner);
+        setOfferSequence(offerSequence);
+    }
+
+    EscrowFinishBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttESCROW_FINISH)
+        {
+            throw std::runtime_error("Invalid transaction type for EscrowFinishBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * Set sfOwner (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowFinishBuilder&
+    setOwner(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfOwner] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfOfferSequence (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowFinishBuilder&
+    setOfferSequence(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfOfferSequence] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfFulfillment (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowFinishBuilder&
+    setFulfillment(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfFulfillment] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfCondition (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowFinishBuilder&
+    setCondition(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfCondition] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfCredentialIDs (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowFinishBuilder&
+    setCredentialIDs(std::decay_t<typename SF_VECTOR256::type::value_type> const& value)
+    {
+        object_[sfCredentialIDs] = value;
+        return *this;
+    }
+
+    /**
+     * Build and return the completed EscrowFinish wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    EscrowFinish
+    build()
+    {
+        return EscrowFinish(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/LedgerStateFix.h

@@ -0,0 +1,144 @@
+#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 {
+
+// Forward declaration
+class LedgerStateFixBuilder;
+
+/**
+ * Transaction: LedgerStateFix
+ * Type: ttLEDGER_STATE_FIX (53)
+ * Delegable: Delegation::delegable
+ * Amendment: fixNFTokenPageLinks
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use LedgerStateFixBuilder to construct new transactions.
+ */
+class LedgerStateFix : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttLEDGER_STATE_FIX;
+
+    /**
+     * Construct a LedgerStateFix transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit LedgerStateFix(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for LedgerStateFix");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfLedgerFixType (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT16::type::value_type
+    getLedgerFixType() const
+    {
+        return this->tx_.at(sfLedgerFixType);
+    }
+
+    /**
+     * Get sfOwner (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getOwner() const
+    {
+        if (hasOwner())
+        {
+            return this->tx_.at(sfOwner);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasOwner() const
+    {
+        return this->tx_.isFieldPresent(sfOwner);
+    }
+};
+
+/**
+ * Builder for LedgerStateFix 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 LedgerStateFixBuilder : public TransactionBuilderBase<LedgerStateFixBuilder>
+{
+public:
+    LedgerStateFixBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_UINT16::type::value_type> const& ledgerFixType,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<LedgerStateFixBuilder>(ttLEDGER_STATE_FIX, account, sequence, fee)
+    {
+        setLedgerFixType(ledgerFixType);
+    }
+
+    LedgerStateFixBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttLEDGER_STATE_FIX)
+        {
+            throw std::runtime_error("Invalid transaction type for LedgerStateFixBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * Set sfLedgerFixType (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LedgerStateFixBuilder&
+    setLedgerFixType(std::decay_t<typename SF_UINT16::type::value_type> const& value)
+    {
+        object_[sfLedgerFixType] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfOwner (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    LedgerStateFixBuilder&
+    setOwner(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfOwner] = value;
+        return *this;
+    }
+
+    /**
+     * Build and return the completed LedgerStateFix wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    LedgerStateFix
+    build()
+    {
+        return LedgerStateFix(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/LoanBrokerCoverClawback.h

@@ -0,0 +1,156 @@
+#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 {
+
+// Forward declaration
+class LoanBrokerCoverClawbackBuilder;
+
+/**
+ * Transaction: LoanBrokerCoverClawback
+ * Type: ttLOAN_BROKER_COVER_CLAWBACK (78)
+ * Delegable: Delegation::delegable
+ * Amendment: featureLendingProtocol
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use LoanBrokerCoverClawbackBuilder to construct new transactions.
+ */
+class LoanBrokerCoverClawback : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttLOAN_BROKER_COVER_CLAWBACK;
+
+    /**
+     * Construct a LoanBrokerCoverClawback transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit LoanBrokerCoverClawback(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for LoanBrokerCoverClawback");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfLoanBrokerID (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getLoanBrokerID() const
+    {
+        if (hasLoanBrokerID())
+        {
+            return this->tx_.at(sfLoanBrokerID);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasLoanBrokerID() const
+    {
+        return this->tx_.isFieldPresent(sfLoanBrokerID);
+    }
+
+    /**
+     * Get sfAmount (soeOPTIONAL)
+     * Note: This field supports MPT (Multi-Purpose Token) amounts.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_AMOUNT::type::value_type>
+    getAmount() const
+    {
+        if (hasAmount())
+        {
+            return this->tx_.at(sfAmount);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasAmount() const
+    {
+        return this->tx_.isFieldPresent(sfAmount);
+    }
+};
+
+/**
+ * Builder for LoanBrokerCoverClawback 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 LoanBrokerCoverClawbackBuilder : public TransactionBuilderBase<LoanBrokerCoverClawbackBuilder>
+{
+public:
+    LoanBrokerCoverClawbackBuilder(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<LoanBrokerCoverClawbackBuilder>(ttLOAN_BROKER_COVER_CLAWBACK, account, sequence, fee)
+    {
+    }
+
+    LoanBrokerCoverClawbackBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttLOAN_BROKER_COVER_CLAWBACK)
+        {
+            throw std::runtime_error("Invalid transaction type for LoanBrokerCoverClawbackBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * Set sfLoanBrokerID (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerCoverClawbackBuilder&
+    setLoanBrokerID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfLoanBrokerID] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfAmount (soeOPTIONAL)
+     * Note: This field supports MPT (Multi-Purpose Token) amounts.
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerCoverClawbackBuilder&
+    setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfAmount] = value;
+        return *this;
+    }
+
+    /**
+     * Build and return the completed LoanBrokerCoverClawback wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    LoanBrokerCoverClawback
+    build()
+    {
+        return LoanBrokerCoverClawback(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/LoanBrokerCoverDeposit.h

@@ -0,0 +1,136 @@
+#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 {
+
+// Forward declaration
+class LoanBrokerCoverDepositBuilder;
+
+/**
+ * Transaction: LoanBrokerCoverDeposit
+ * Type: ttLOAN_BROKER_COVER_DEPOSIT (76)
+ * Delegable: Delegation::delegable
+ * Amendment: featureLendingProtocol
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use LoanBrokerCoverDepositBuilder to construct new transactions.
+ */
+class LoanBrokerCoverDeposit : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttLOAN_BROKER_COVER_DEPOSIT;
+
+    /**
+     * Construct a LoanBrokerCoverDeposit transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit LoanBrokerCoverDeposit(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for LoanBrokerCoverDeposit");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfLoanBrokerID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getLoanBrokerID() const
+    {
+        return this->tx_.at(sfLoanBrokerID);
+    }
+
+    /**
+     * Get sfAmount (soeREQUIRED)
+     * Note: This field supports MPT (Multi-Purpose Token) amounts.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getAmount() const
+    {
+        return this->tx_.at(sfAmount);
+    }
+};
+
+/**
+ * Builder for LoanBrokerCoverDeposit 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 LoanBrokerCoverDepositBuilder : public TransactionBuilderBase<LoanBrokerCoverDepositBuilder>
+{
+public:
+    LoanBrokerCoverDepositBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_UINT256::type::value_type> const& loanBrokerID,                     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<LoanBrokerCoverDepositBuilder>(ttLOAN_BROKER_COVER_DEPOSIT, account, sequence, fee)
+    {
+        setLoanBrokerID(loanBrokerID);
+        setAmount(amount);
+    }
+
+    LoanBrokerCoverDepositBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttLOAN_BROKER_COVER_DEPOSIT)
+        {
+            throw std::runtime_error("Invalid transaction type for LoanBrokerCoverDepositBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * Set sfLoanBrokerID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerCoverDepositBuilder&
+    setLoanBrokerID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfLoanBrokerID] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfAmount (soeREQUIRED)
+     * Note: This field supports MPT (Multi-Purpose Token) amounts.
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerCoverDepositBuilder&
+    setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfAmount] = value;
+        return *this;
+    }
+
+    /**
+     * Build and return the completed LoanBrokerCoverDeposit wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    LoanBrokerCoverDeposit
+    build()
+    {
+        return LoanBrokerCoverDeposit(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/LoanBrokerCoverWithdraw.h

@@ -0,0 +1,200 @@
+#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 {
+
+// Forward declaration
+class LoanBrokerCoverWithdrawBuilder;
+
+/**
+ * Transaction: LoanBrokerCoverWithdraw
+ * Type: ttLOAN_BROKER_COVER_WITHDRAW (77)
+ * Delegable: Delegation::delegable
+ * Amendment: featureLendingProtocol
+ * Privileges: mayAuthorizeMPT
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use LoanBrokerCoverWithdrawBuilder to construct new transactions.
+ */
+class LoanBrokerCoverWithdraw : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttLOAN_BROKER_COVER_WITHDRAW;
+
+    /**
+     * Construct a LoanBrokerCoverWithdraw transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit LoanBrokerCoverWithdraw(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for LoanBrokerCoverWithdraw");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfLoanBrokerID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getLoanBrokerID() const
+    {
+        return this->tx_.at(sfLoanBrokerID);
+    }
+
+    /**
+     * Get sfAmount (soeREQUIRED)
+     * Note: This field supports MPT (Multi-Purpose Token) amounts.
+     */
+    [[nodiscard]]
+    SF_AMOUNT::type::value_type
+    getAmount() const
+    {
+        return this->tx_.at(sfAmount);
+    }
+
+    /**
+     * Get sfDestination (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_ACCOUNT::type::value_type>
+    getDestination() const
+    {
+        if (hasDestination())
+        {
+            return this->tx_.at(sfDestination);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasDestination() const
+    {
+        return this->tx_.isFieldPresent(sfDestination);
+    }
+
+    /**
+     * Get sfDestinationTag (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getDestinationTag() const
+    {
+        if (hasDestinationTag())
+        {
+            return this->tx_.at(sfDestinationTag);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasDestinationTag() const
+    {
+        return this->tx_.isFieldPresent(sfDestinationTag);
+    }
+};
+
+/**
+ * Builder for LoanBrokerCoverWithdraw 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 LoanBrokerCoverWithdrawBuilder : public TransactionBuilderBase<LoanBrokerCoverWithdrawBuilder>
+{
+public:
+    LoanBrokerCoverWithdrawBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_UINT256::type::value_type> const& loanBrokerID,                     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<LoanBrokerCoverWithdrawBuilder>(ttLOAN_BROKER_COVER_WITHDRAW, account, sequence, fee)
+    {
+        setLoanBrokerID(loanBrokerID);
+        setAmount(amount);
+    }
+
+    LoanBrokerCoverWithdrawBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttLOAN_BROKER_COVER_WITHDRAW)
+        {
+            throw std::runtime_error("Invalid transaction type for LoanBrokerCoverWithdrawBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * Set sfLoanBrokerID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerCoverWithdrawBuilder&
+    setLoanBrokerID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfLoanBrokerID] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfAmount (soeREQUIRED)
+     * Note: This field supports MPT (Multi-Purpose Token) amounts.
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerCoverWithdrawBuilder&
+    setAmount(std::decay_t<typename SF_AMOUNT::type::value_type> const& value)
+    {
+        object_[sfAmount] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfDestination (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerCoverWithdrawBuilder&
+    setDestination(std::decay_t<typename SF_ACCOUNT::type::value_type> const& value)
+    {
+        object_[sfDestination] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfDestinationTag (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerCoverWithdrawBuilder&
+    setDestinationTag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfDestinationTag] = value;
+        return *this;
+    }
+
+    /**
+     * Build and return the completed LoanBrokerCoverWithdraw wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    LoanBrokerCoverWithdraw
+    build()
+    {
+        return LoanBrokerCoverWithdraw(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/LoanBrokerDelete.h

@@ -0,0 +1,112 @@
+#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 {
+
+// Forward declaration
+class LoanBrokerDeleteBuilder;
+
+/**
+ * Transaction: LoanBrokerDelete
+ * Type: ttLOAN_BROKER_DELETE (75)
+ * Delegable: Delegation::delegable
+ * Amendment: featureLendingProtocol
+ * Privileges: mustDeleteAcct | mayAuthorizeMPT
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use LoanBrokerDeleteBuilder to construct new transactions.
+ */
+class LoanBrokerDelete : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttLOAN_BROKER_DELETE;
+
+    /**
+     * Construct a LoanBrokerDelete transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit LoanBrokerDelete(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for LoanBrokerDelete");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfLoanBrokerID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getLoanBrokerID() const
+    {
+        return this->tx_.at(sfLoanBrokerID);
+    }
+};
+
+/**
+ * Builder for LoanBrokerDelete 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 LoanBrokerDeleteBuilder : public TransactionBuilderBase<LoanBrokerDeleteBuilder>
+{
+public:
+    LoanBrokerDeleteBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_UINT256::type::value_type> const& loanBrokerID,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<LoanBrokerDeleteBuilder>(ttLOAN_BROKER_DELETE, account, sequence, fee)
+    {
+        setLoanBrokerID(loanBrokerID);
+    }
+
+    LoanBrokerDeleteBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttLOAN_BROKER_DELETE)
+        {
+            throw std::runtime_error("Invalid transaction type for LoanBrokerDeleteBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * Set sfLoanBrokerID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerDeleteBuilder&
+    setLoanBrokerID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfLoanBrokerID] = value;
+        return *this;
+    }
+
+    /**
+     * Build and return the completed LoanBrokerDelete wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    LoanBrokerDelete
+    build()
+    {
+        return LoanBrokerDelete(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/LoanBrokerSet.h

@@ -0,0 +1,304 @@
+#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 {
+
+// Forward declaration
+class LoanBrokerSetBuilder;
+
+/**
+ * Transaction: LoanBrokerSet
+ * Type: ttLOAN_BROKER_SET (74)
+ * Delegable: Delegation::delegable
+ * Amendment: featureLendingProtocol
+ * Privileges: createPseudoAcct | mayAuthorizeMPT
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use LoanBrokerSetBuilder to construct new transactions.
+ */
+class LoanBrokerSet : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttLOAN_BROKER_SET;
+
+    /**
+     * Construct a LoanBrokerSet transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit LoanBrokerSet(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for LoanBrokerSet");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfVaultID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getVaultID() const
+    {
+        return this->tx_.at(sfVaultID);
+    }
+
+    /**
+     * Get sfLoanBrokerID (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT256::type::value_type>
+    getLoanBrokerID() const
+    {
+        if (hasLoanBrokerID())
+        {
+            return this->tx_.at(sfLoanBrokerID);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasLoanBrokerID() const
+    {
+        return this->tx_.isFieldPresent(sfLoanBrokerID);
+    }
+
+    /**
+     * Get sfData (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getData() const
+    {
+        if (hasData())
+        {
+            return this->tx_.at(sfData);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasData() const
+    {
+        return this->tx_.isFieldPresent(sfData);
+    }
+
+    /**
+     * Get sfManagementFeeRate (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT16::type::value_type>
+    getManagementFeeRate() const
+    {
+        if (hasManagementFeeRate())
+        {
+            return this->tx_.at(sfManagementFeeRate);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasManagementFeeRate() const
+    {
+        return this->tx_.isFieldPresent(sfManagementFeeRate);
+    }
+
+    /**
+     * Get sfDebtMaximum (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_NUMBER::type::value_type>
+    getDebtMaximum() const
+    {
+        if (hasDebtMaximum())
+        {
+            return this->tx_.at(sfDebtMaximum);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasDebtMaximum() const
+    {
+        return this->tx_.isFieldPresent(sfDebtMaximum);
+    }
+
+    /**
+     * Get sfCoverRateMinimum (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getCoverRateMinimum() const
+    {
+        if (hasCoverRateMinimum())
+        {
+            return this->tx_.at(sfCoverRateMinimum);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasCoverRateMinimum() const
+    {
+        return this->tx_.isFieldPresent(sfCoverRateMinimum);
+    }
+
+    /**
+     * Get sfCoverRateLiquidation (soeOPTIONAL)
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getCoverRateLiquidation() const
+    {
+        if (hasCoverRateLiquidation())
+        {
+            return this->tx_.at(sfCoverRateLiquidation);
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    hasCoverRateLiquidation() const
+    {
+        return this->tx_.isFieldPresent(sfCoverRateLiquidation);
+    }
+};
+
+/**
+ * Builder for LoanBrokerSet 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 LoanBrokerSetBuilder : public TransactionBuilderBase<LoanBrokerSetBuilder>
+{
+public:
+    LoanBrokerSetBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_UINT256::type::value_type> const& vaultID,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<LoanBrokerSetBuilder>(ttLOAN_BROKER_SET, account, sequence, fee)
+    {
+        setVaultID(vaultID);
+    }
+
+    LoanBrokerSetBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttLOAN_BROKER_SET)
+        {
+            throw std::runtime_error("Invalid transaction type for LoanBrokerSetBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * Set sfVaultID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerSetBuilder&
+    setVaultID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfVaultID] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfLoanBrokerID (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerSetBuilder&
+    setLoanBrokerID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfLoanBrokerID] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfData (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerSetBuilder&
+    setData(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfData] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfManagementFeeRate (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerSetBuilder&
+    setManagementFeeRate(std::decay_t<typename SF_UINT16::type::value_type> const& value)
+    {
+        object_[sfManagementFeeRate] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfDebtMaximum (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerSetBuilder&
+    setDebtMaximum(std::decay_t<typename SF_NUMBER::type::value_type> const& value)
+    {
+        object_[sfDebtMaximum] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfCoverRateMinimum (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerSetBuilder&
+    setCoverRateMinimum(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfCoverRateMinimum] = value;
+        return *this;
+    }
+
+    /**
+     * Set sfCoverRateLiquidation (soeOPTIONAL)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanBrokerSetBuilder&
+    setCoverRateLiquidation(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfCoverRateLiquidation] = value;
+        return *this;
+    }
+
+    /**
+     * Build and return the completed LoanBrokerSet wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    LoanBrokerSet
+    build()
+    {
+        return LoanBrokerSet(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/LoanDelete.h

@@ -0,0 +1,112 @@
+#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 {
+
+// Forward declaration
+class LoanDeleteBuilder;
+
+/**
+ * Transaction: LoanDelete
+ * Type: ttLOAN_DELETE (81)
+ * Delegable: Delegation::delegable
+ * Amendment: featureLendingProtocol
+ * Privileges: noPriv
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use LoanDeleteBuilder to construct new transactions.
+ */
+class LoanDelete : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttLOAN_DELETE;
+
+    /**
+     * Construct a LoanDelete transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit LoanDelete(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for LoanDelete");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfLoanID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getLoanID() const
+    {
+        return this->tx_.at(sfLoanID);
+    }
+};
+
+/**
+ * Builder for LoanDelete 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 LoanDeleteBuilder : public TransactionBuilderBase<LoanDeleteBuilder>
+{
+public:
+    LoanDeleteBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_UINT256::type::value_type> const& loanID,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<LoanDeleteBuilder>(ttLOAN_DELETE, account, sequence, fee)
+    {
+        setLoanID(loanID);
+    }
+
+    LoanDeleteBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttLOAN_DELETE)
+        {
+            throw std::runtime_error("Invalid transaction type for LoanDeleteBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * Set sfLoanID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanDeleteBuilder&
+    setLoanID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfLoanID] = value;
+        return *this;
+    }
+
+    /**
+     * Build and return the completed LoanDelete wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    LoanDelete
+    build()
+    {
+        return LoanDelete(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/LoanManage.h

@@ -0,0 +1,112 @@
+#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 {
+
+// Forward declaration
+class LoanManageBuilder;
+
+/**
+ * Transaction: LoanManage
+ * Type: ttLOAN_MANAGE (82)
+ * Delegable: Delegation::delegable
+ * Amendment: featureLendingProtocol
+ * Privileges: mayModifyVault
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use LoanManageBuilder to construct new transactions.
+ */
+class LoanManage : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = ttLOAN_MANAGE;
+
+    /**
+     * Construct a LoanManage transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit LoanManage(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for LoanManage");
+        }
+    }
+
+    // Transaction-specific field getters
+
+    /**
+     * Get sfLoanID (soeREQUIRED)
+     */
+    [[nodiscard]]
+    SF_UINT256::type::value_type
+    getLoanID() const
+    {
+        return this->tx_.at(sfLoanID);
+    }
+};
+
+/**
+ * Builder for LoanManage 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 LoanManageBuilder : public TransactionBuilderBase<LoanManageBuilder>
+{
+public:
+    LoanManageBuilder(SF_ACCOUNT::type::value_type account,
+                     std::decay_t<typename SF_UINT256::type::value_type> const& loanID,                    std::optional<SF_UINT32::type::value_type> sequence = std::nullopt,
+                    std::optional<SF_AMOUNT::type::value_type> fee = std::nullopt
+)
+        : TransactionBuilderBase<LoanManageBuilder>(ttLOAN_MANAGE, account, sequence, fee)
+    {
+        setLoanID(loanID);
+    }
+
+    LoanManageBuilder(STTx const& tx)
+    {
+        if (tx.getTxnType() != ttLOAN_MANAGE)
+        {
+            throw std::runtime_error("Invalid transaction type for LoanManageBuilder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+
+    /**
+     * Set sfLoanID (soeREQUIRED)
+     * @return Reference to this builder for method chaining.
+     */
+    LoanManageBuilder&
+    setLoanID(std::decay_t<typename SF_UINT256::type::value_type> const& value)
+    {
+        object_[sfLoanID] = value;
+        return *this;
+    }
+
+    /**
+     * Build and return the completed LoanManage wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    LoanManage
+    build()
+    {
+        return LoanManage(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions