Fix formatting errors

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,

.cmake-format.yaml

@@ -1,247 +0,0 @@
-_help_parse: Options affecting listfile parsing
-parse:
-  _help_additional_commands:
-    - Specify structure for custom cmake functions
-  additional_commands:
-    target_protobuf_sources:
-      pargs:
-        - target
-        - prefix
-      kwargs:
-        PROTOS: "*"
-        LANGUAGE: cpp
-        IMPORT_DIRS: "*"
-        GENERATE_EXTENSIONS: "*"
-        PLUGIN: "*"
-  _help_override_spec:
-    - Override configurations per-command where available
-  override_spec: {}
-  _help_vartags:
-    - Specify variable tags.
-  vartags: []
-  _help_proptags:
-    - Specify property tags.
-  proptags: []
-_help_format: Options affecting formatting.
-format:
-  _help_disable:
-    - Disable formatting entirely, making cmake-format a no-op
-  disable: false
-  _help_line_width:
-    - How wide to allow formatted cmake files
-  line_width: 100
-  _help_tab_size:
-    - How many spaces to tab for indent
-  tab_size: 4
-  _help_use_tabchars:
-    - If true, lines are indented using tab characters (utf-8
-    - 0x09) instead of <tab_size> space characters (utf-8 0x20).
-    - In cases where the layout would require a fractional tab
-    - character, the behavior of the  fractional indentation is
-    - governed by <fractional_tab_policy>
-  use_tabchars: false
-  _help_fractional_tab_policy:
-    - If <use_tabchars> is True, then the value of this variable
-    - indicates how fractional indentions are handled during
-    - whitespace replacement. If set to 'use-space', fractional
-    - indentation is left as spaces (utf-8 0x20). If set to
-    - "`round-up` fractional indentation is replaced with a single"
-    - tab character (utf-8 0x09) effectively shifting the column
-    - to the next tabstop
-  fractional_tab_policy: use-space
-  _help_max_subgroups_hwrap:
-    - If an argument group contains more than this many sub-groups
-    - (parg or kwarg groups) then force it to a vertical layout.
-  max_subgroups_hwrap: 4
-  _help_max_pargs_hwrap:
-    - If a positional argument group contains more than this many
-    - arguments, then force it to a vertical layout.
-  max_pargs_hwrap: 5
-  _help_max_rows_cmdline:
-    - If a cmdline positional group consumes more than this many
-    - lines without nesting, then invalidate the layout (and nest)
-  max_rows_cmdline: 2
-  _help_separate_ctrl_name_with_space:
-    - If true, separate flow control names from their parentheses
-    - with a space
-  separate_ctrl_name_with_space: true
-  _help_separate_fn_name_with_space:
-    - If true, separate function names from parentheses with a
-    - space
-  separate_fn_name_with_space: false
-  _help_dangle_parens:
-    - If a statement is wrapped to more than one line, than dangle
-    - the closing parenthesis on its own line.
-  dangle_parens: false
-  _help_dangle_align:
-    - If the trailing parenthesis must be 'dangled' on its on
-    - "line, then align it to this reference: `prefix`: the start"
-    - "of the statement, `prefix-indent`: the start of the"
-    - "statement, plus one indentation level, `child`: align to"
-    - the column of the arguments
-  dangle_align: prefix
-  _help_min_prefix_chars:
-    - If the statement spelling length (including space and
-    - parenthesis) is smaller than this amount, then force reject
-    - nested layouts.
-  min_prefix_chars: 18
-  _help_max_prefix_chars:
-    - If the statement spelling length (including space and
-    - parenthesis) is larger than the tab width by more than this
-    - amount, then force reject un-nested layouts.
-  max_prefix_chars: 10
-  _help_max_lines_hwrap:
-    - If a candidate layout is wrapped horizontally but it exceeds
-    - this many lines, then reject the layout.
-  max_lines_hwrap: 2
-  _help_line_ending:
-    - What style line endings to use in the output.
-  line_ending: unix
-  _help_command_case:
-    - Format command names consistently as 'lower' or 'upper' case
-  command_case: canonical
-  _help_keyword_case:
-    - Format keywords consistently as 'lower' or 'upper' case
-  keyword_case: unchanged
-  _help_always_wrap:
-    - A list of command names which should always be wrapped
-  always_wrap: []
-  _help_enable_sort:
-    - If true, the argument lists which are known to be sortable
-    - will be sorted lexicographicall
-  enable_sort: true
-  _help_autosort:
-    - If true, the parsers may infer whether or not an argument
-    - list is sortable (without annotation).
-  autosort: true
-  _help_require_valid_layout:
-    - By default, if cmake-format cannot successfully fit
-    - everything into the desired linewidth it will apply the
-    - last, most aggressive attempt that it made. If this flag is
-    - True, however, cmake-format will print error, exit with non-
-    - zero status code, and write-out nothing
-  require_valid_layout: false
-  _help_layout_passes:
-    - A dictionary mapping layout nodes to a list of wrap
-    - decisions. See the documentation for more information.
-  layout_passes: {}
-_help_markup: Options affecting comment reflow and formatting.
-markup:
-  _help_bullet_char:
-    - What character to use for bulleted lists
-  bullet_char: "-"
-  _help_enum_char:
-    - What character to use as punctuation after numerals in an
-    - enumerated list
-  enum_char: .
-  _help_first_comment_is_literal:
-    - If comment markup is enabled, don't reflow the first comment
-    - block in each listfile. Use this to preserve formatting of
-    - your copyright/license statements.
-  first_comment_is_literal: false
-  _help_literal_comment_pattern:
-    - If comment markup is enabled, don't reflow any comment block
-    - which matches this (regex) pattern. Default is `None`
-    - (disabled).
-  literal_comment_pattern: null
-  _help_fence_pattern:
-    - Regular expression to match preformat fences in comments
-    - default= ``r'^\s*([`~]{3}[`~]*)(.*)$'``
-  fence_pattern: ^\s*([`~]{3}[`~]*)(.*)$
-  _help_ruler_pattern:
-    - Regular expression to match rulers in comments default=
-    - '``r''^\s*[^\w\s]{3}.*[^\w\s]{3}$''``'
-  ruler_pattern: ^\s*[^\w\s]{3}.*[^\w\s]{3}$
-  _help_explicit_trailing_pattern:
-    - If a comment line matches starts with this pattern then it
-    - is explicitly a trailing comment for the preceding
-    - argument. Default is '#<'
-  explicit_trailing_pattern: "#<"
-  _help_hashruler_min_length:
-    - If a comment line starts with at least this many consecutive
-    - hash characters, then don't lstrip() them off. This allows
-    - for lazy hash rulers where the first hash char is not
-    - separated by space
-  hashruler_min_length: 10
-  _help_canonicalize_hashrulers:
-    - If true, then insert a space between the first hash char and
-    - remaining hash chars in a hash ruler, and normalize its
-    - length to fill the column
-  canonicalize_hashrulers: true
-  _help_enable_markup:
-    - enable comment markup parsing and reflow
-  enable_markup: false
-_help_lint: Options affecting the linter
-lint:
-  _help_disabled_codes:
-    - a list of lint codes to disable
-  disabled_codes: []
-  _help_function_pattern:
-    - regular expression pattern describing valid function names
-  function_pattern: "[0-9a-z_]+"
-  _help_macro_pattern:
-    - regular expression pattern describing valid macro names
-  macro_pattern: "[0-9A-Z_]+"
-  _help_global_var_pattern:
-    - regular expression pattern describing valid names for
-    - variables with global (cache) scope
-  global_var_pattern: "[A-Z][0-9A-Z_]+"
-  _help_internal_var_pattern:
-    - regular expression pattern describing valid names for
-    - variables with global scope (but internal semantic)
-  internal_var_pattern: _[A-Z][0-9A-Z_]+
-  _help_local_var_pattern:
-    - regular expression pattern describing valid names for
-    - variables with local scope
-  local_var_pattern: "[a-z][a-z0-9_]+"
-  _help_private_var_pattern:
-    - regular expression pattern describing valid names for
-    - privatedirectory variables
-  private_var_pattern: _[0-9a-z_]+
-  _help_public_var_pattern:
-    - regular expression pattern describing valid names for public
-    - directory variables
-  public_var_pattern: "[A-Z][0-9A-Z_]+"
-  _help_argument_var_pattern:
-    - regular expression pattern describing valid names for
-    - function/macro arguments and loop variables.
-  argument_var_pattern: "[a-z][a-z0-9_]+"
-  _help_keyword_pattern:
-    - regular expression pattern describing valid names for
-    - keywords used in functions or macros
-  keyword_pattern: "[A-Z][0-9A-Z_]+"
-  _help_max_conditionals_custom_parser:
-    - In the heuristic for C0201, how many conditionals to match
-    - within a loop in before considering the loop a parser.
-  max_conditionals_custom_parser: 2
-  _help_min_statement_spacing:
-    - Require at least this many newlines between statements
-  min_statement_spacing: 1
-  _help_max_statement_spacing:
-    - Require no more than this many newlines between statements
-  max_statement_spacing: 2
-  max_returns: 6
-  max_branches: 12
-  max_arguments: 5
-  max_localvars: 15
-  max_statements: 50
-_help_encode: Options affecting file encoding
-encode:
-  _help_emit_byteorder_mark:
-    - If true, emit the unicode byte-order mark (BOM) at the start
-    - of the file
-  emit_byteorder_mark: false
-  _help_input_encoding:
-    - Specify the encoding of the input file. Defaults to utf-8
-  input_encoding: utf-8
-  _help_output_encoding:
-    - Specify the encoding of the output file. Defaults to utf-8.
-    - Note that cmake only claims to support utf-8 so be careful
-    - when using anything else
-  output_encoding: utf-8
-_help_misc: Miscellaneous configurations options.
-misc:
-  _help_per_command:
-    - A dictionary containing any per-command configuration
-    - overrides. Currently only `command_case` is supported.
-  per_command: {}

.gersemi/definitions.cmake

@@ -0,0 +1,101 @@
+# Custom CMake command definitions for gersemi formatting.
+# These stubs teach gersemi the signatures of project-specific commands
+# so it can format their invocations correctly.
+
+function(git_branch branch_val)
+endfunction()
+
+function(isolate_headers target A B scope)
+endfunction()
+
+function(create_symbolic_link target link)
+endfunction()
+
+function(xrpl_add_test name)
+endfunction()
+
+macro(exclude_from_default target_)
+endmacro()
+
+macro(exclude_if_included target_)
+endmacro()
+
+function(target_protobuf_sources target prefix)
+    set(options APPEND_PATH DESCRIPTORS)
+    set(oneValueArgs
+        LANGUAGE
+        OUT_VAR
+        EXPORT_MACRO
+        TARGET
+        PROTOC_OUT_DIR
+        PLUGIN
+        PLUGIN_OPTIONS
+        PROTOC_EXE
+    )
+    set(multiValueArgs
+        PROTOS
+        IMPORT_DIRS
+        GENERATE_EXTENSIONS
+        PROTOC_OPTIONS
+        DEPENDENCIES
+    )
+    cmake_parse_arguments(
+        THIS_FUNCTION_PREFIX
+        "${options}"
+        "${oneValueArgs}"
+        "${multiValueArgs}"
+        ${ARGN}
+    )
+endfunction()
+
+function(add_module parent name)
+endfunction()
+
+function(setup_protocol_autogen)
+endfunction()
+
+function(target_link_modules parent scope)
+endfunction()
+
+function(setup_target_for_coverage_gcovr)
+    set(options NONE)
+    set(oneValueArgs BASE_DIRECTORY NAME FORMAT)
+    set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
+    cmake_parse_arguments(
+        THIS_FUNCTION_PREFIX
+        "${options}"
+        "${oneValueArgs}"
+        "${multiValueArgs}"
+        ${ARGN}
+    )
+endfunction()
+
+function(add_code_coverage_to_target name scope)
+endfunction()
+
+function(verbose_find_path variable name)
+    set(options
+        NO_CACHE
+        REQUIRED
+        OPTIONAL
+        NO_DEFAULT_PATH
+        NO_PACKAGE_ROOT_PATH
+        NO_CMAKE_PATH
+        NO_CMAKE_ENVIRONMENT_PATH
+        NO_SYSTEM_ENVIRONMENT_PATH
+        NO_CMAKE_SYSTEM_PATH
+        NO_CMAKE_INSTALL_PREFIX
+        CMAKE_FIND_ROOT_PATH_BOTH
+        ONLY_CMAKE_FIND_ROOT_PATH
+        NO_CMAKE_FIND_ROOT_PATH
+    )
+    set(oneValueArgs REGISTRY_VIEW VALIDATOR DOC)
+    set(multiValueArgs NAMES HINTS PATHS PATH_SUFFIXES)
+    cmake_parse_arguments(
+        THIS_FUNCTION_PREFIX
+        "${options}"
+        "${oneValueArgs}"
+        "${multiValueArgs}"
+        ${ARGN}
+    )
+endfunction()

.gersemirc

@@ -0,0 +1 @@
+definitions: [.gersemi]

.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
@@ -174,6 +175,8 @@ test.unit_test > xrpl.basics
 tests.libxrpl > xrpl.basics
 tests.libxrpl > xrpl.json
 tests.libxrpl > xrpl.net
+tests.libxrpl > xrpl.protocol
+tests.libxrpl > xrpl.protocol_autogen
 xrpl.conditions > xrpl.basics
 xrpl.conditions > xrpl.protocol
 xrpl.core > xrpl.basics
@@ -190,6 +193,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,39 +14,42 @@ 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
+  - repo: https://github.com/BlankSpruce/gersemi
+    rev: 0.26.0
     hooks:
-      - id: cmake-format
-        additional_dependencies: [PyYAML]
+      - id: gersemi
 
   - 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 +64,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
@@ -70,5 +81,6 @@ repos:
 exclude: |
   (?x)^(
       external/.*|
-      .github/scripts/levelization/results/.*\.txt
+      .github/scripts/levelization/results/.*\.txt|
+      src/tests/libxrpl/protocol_autogen/(transactions|ledger_objects)/.*
   )$

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

@@ -1,16 +1,16 @@
 cmake_minimum_required(VERSION 3.16)
 
-if (POLICY CMP0074)
+if(POLICY CMP0074)
     cmake_policy(SET CMP0074 NEW)
-endif ()
-if (POLICY CMP0077)
+endif()
+if(POLICY CMP0077)
     cmake_policy(SET CMP0077 NEW)
-endif ()
+endif()
 
 # Fix "unrecognized escape" issues when passing CMAKE_MODULE_PATH on Windows.
-if (DEFINED CMAKE_MODULE_PATH)
+if(DEFINED CMAKE_MODULE_PATH)
     file(TO_CMAKE_PATH "${CMAKE_MODULE_PATH}" CMAKE_MODULE_PATH)
-endif ()
+endif()
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
 project(xrpl)
@@ -21,77 +21,64 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 include(CompilationEnv)
 
-if (is_gcc)
+if(is_gcc)
     # GCC-specific fixes
     add_compile_options(-Wno-unknown-pragmas -Wno-subobject-linkage)
     # -Wno-subobject-linkage can be removed when we upgrade GCC version to at least 13.3
-elseif (is_clang)
+elseif(is_clang)
     # Clang-specific fixes
     add_compile_options(-Wno-unknown-warning-option) # Ignore unknown warning options
-elseif (is_msvc)
+elseif(is_msvc)
     # MSVC-specific fixes
     add_compile_options(/wd4068) # Ignore unknown pragmas
-endif ()
+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)
+if(thread_safety_analysis)
+    add_compile_options(
+        -Wthread-safety
+        -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
+        -DXRPL_ENABLE_THREAD_SAFETY_ANNOTATIONS
+    )
     add_compile_options("-stdlib=libc++")
     add_link_options("-stdlib=libc++")
-endif ()
+endif()
 
 include(CheckCXXCompilerFlag)
 include(FetchContent)
 include(ExternalProject)
 include(CMakeFuncs) # must come *after* ExternalProject b/c it overrides one function in EP
-if (target)
-    message(FATAL_ERROR "The target option has been removed - use native cmake options to control build"
+if(target)
+    message(
+        FATAL_ERROR
+        "The target option has been removed - use native cmake options to control build"
     )
-endif ()
+endif()
 
 include(XrplSanity)
 include(XrplVersion)
 include(XrplSettings)
 # this check has to remain in the top-level cmake because of the early return statement
-if (packages_only)
-    if (NOT TARGET rpm)
-        message(FATAL_ERROR "packages_only requested, but targets were not created - is docker installed?"
+if(packages_only)
+    if(NOT TARGET rpm)
+        message(
+            FATAL_ERROR
+            "packages_only requested, but targets were not created - is docker installed?"
         )
-    endif ()
+    endif()
     return()
-endif ()
+endif()
 include(XrplCompiler)
 include(XrplSanitizers)
 include(XrplInterface)
 
 option(only_docs "Include only the docs target?" FALSE)
 include(XrplDocs)
-if (only_docs)
+if(only_docs)
     return()
-endif ()
+endif()
 
 include(deps/Boost)
 
@@ -110,42 +97,46 @@ find_package(xxHash REQUIRED)
 
 target_link_libraries(
     xrpl_libs
-    INTERFACE ed25519::ed25519
-              lz4::lz4
-              OpenSSL::Crypto
-              OpenSSL::SSL
-              secp256k1::secp256k1
-              soci::soci
-              SQLite::SQLite3)
+    INTERFACE
+        ed25519::ed25519
+        lz4::lz4
+        OpenSSL::Crypto
+        OpenSSL::SSL
+        secp256k1::secp256k1
+        soci::soci
+        SQLite::SQLite3
+)
 
 option(rocksdb "Enable RocksDB" ON)
-if (rocksdb)
+if(rocksdb)
     find_package(RocksDB REQUIRED)
-    set_target_properties(RocksDB::rocksdb PROPERTIES INTERFACE_COMPILE_DEFINITIONS
-                                                      XRPL_ROCKSDB_AVAILABLE=1)
+    set_target_properties(
+        RocksDB::rocksdb
+        PROPERTIES INTERFACE_COMPILE_DEFINITIONS XRPL_ROCKSDB_AVAILABLE=1
+    )
     target_link_libraries(xrpl_libs INTERFACE RocksDB::rocksdb)
-endif ()
+endif()
 
 # Work around changes to Conan recipe for now.
-if (TARGET nudb::core)
+if(TARGET nudb::core)
     set(nudb nudb::core)
-elseif (TARGET NuDB::nudb)
+elseif(TARGET NuDB::nudb)
     set(nudb NuDB::nudb)
-else ()
+else()
     message(FATAL_ERROR "unknown nudb target")
-endif ()
+endif()
 target_link_libraries(xrpl_libs INTERFACE ${nudb})
 
-if (coverage)
+if(coverage)
     include(XrplCov)
-endif ()
+endif()
 
 set(PROJECT_EXPORT_SET XrplExports)
 include(XrplCore)
 include(XrplInstall)
 include(XrplValidatorKeys)
 
-if (tests)
+if(tests)
     include(CTest)
     add_subdirectory(src/tests/libxrpl)
-endif ()
+endif()

cmake/CMakeFuncs.cmake

@@ -1,29 +1,32 @@
-macro (exclude_from_default target_)
+macro(exclude_from_default target_)
     set_target_properties(${target_} PROPERTIES EXCLUDE_FROM_ALL ON)
     set_target_properties(${target_} PROPERTIES EXCLUDE_FROM_DEFAULT_BUILD ON)
-endmacro ()
+endmacro()
 
-macro (exclude_if_included target_)
+macro(exclude_if_included target_)
     get_directory_property(has_parent PARENT_DIRECTORY)
-    if (has_parent)
+    if(has_parent)
         exclude_from_default(${target_})
-    endif ()
-endmacro ()
+    endif()
+endmacro()
 
 find_package(Git)
 
-function (git_branch branch_val)
-    if (NOT GIT_FOUND)
+function(git_branch branch_val)
+    if(NOT GIT_FOUND)
         return()
-    endif ()
+    endif()
     set(_branch "")
-    execute_process(COMMAND ${GIT_EXECUTABLE} "rev-parse" "--abbrev-ref" "HEAD"
-                    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-                    RESULT_VARIABLE _git_exit_code
-                    OUTPUT_VARIABLE _temp_branch
-                    OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET)
-    if (_git_exit_code EQUAL 0)
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} "rev-parse" "--abbrev-ref" "HEAD"
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        RESULT_VARIABLE _git_exit_code
+        OUTPUT_VARIABLE _temp_branch
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        ERROR_QUIET
+    )
+    if(_git_exit_code EQUAL 0)
         set(_branch ${_temp_branch})
-    endif ()
+    endif()
     set(${branch_val} "${_branch}" PARENT_SCOPE)
-endfunction ()
+endfunction()

cmake/Ccache.cmake

@@ -1,50 +1,62 @@
 find_program(CCACHE_PATH "ccache")
-if (NOT CCACHE_PATH)
+if(NOT CCACHE_PATH)
     return()
-endif ()
+endif()
 
 # For Linux and macOS we can use the ccache binary directly.
-if (NOT MSVC)
+if(NOT MSVC)
     set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE_PATH}")
     set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_PATH}")
     message(STATUS "Found ccache: ${CCACHE_PATH}")
     return()
-endif ()
+endif()
 
 # For Windows more effort is required. The code below is a modified version of
 # https://github.com/ccache/ccache/wiki/MS-Visual-Studio#usage-with-cmake.
-if ("${CCACHE_PATH}" MATCHES "chocolatey")
+if("${CCACHE_PATH}" MATCHES "chocolatey")
     message(DEBUG "Ccache path: ${CCACHE_PATH}")
     # Chocolatey uses a shim executable that we cannot use directly, in which case we have to find the executable it
     # points to. If we cannot find the target executable then we cannot use ccache.
     find_program(BASH_PATH "bash")
-    if (NOT BASH_PATH)
+    if(NOT BASH_PATH)
         message(WARNING "Could not find bash.")
         return()
-    endif ()
+    endif()
 
-    execute_process(COMMAND bash -c
-                            "export LC_ALL='en_US.UTF-8'; ${CCACHE_PATH} --shimgen-noop | grep -oP 'path to executable: \\K.+' | head -c -1"
-                    OUTPUT_VARIABLE CCACHE_PATH)
+    execute_process(
+        COMMAND
+            bash -c
+            "export LC_ALL='en_US.UTF-8'; ${CCACHE_PATH} --shimgen-noop | grep -oP 'path to executable: \\K.+' | head -c -1"
+        OUTPUT_VARIABLE CCACHE_PATH
+    )
 
-    if (NOT CCACHE_PATH)
+    if(NOT CCACHE_PATH)
         message(WARNING "Could not find ccache target.")
         return()
-    endif ()
+    endif()
     file(TO_CMAKE_PATH "${CCACHE_PATH}" CCACHE_PATH)
-endif ()
+endif()
 message(STATUS "Found ccache: ${CCACHE_PATH}")
 
 # Tell cmake to use ccache for compiling with Visual Studio.
 file(COPY_FILE ${CCACHE_PATH} ${CMAKE_BINARY_DIR}/cl.exe ONLY_IF_DIFFERENT)
-set(CMAKE_VS_GLOBALS "CLToolExe=cl.exe" "CLToolPath=${CMAKE_BINARY_DIR}" "TrackFileAccess=false"
-                     "UseMultiToolTask=true")
+set(CMAKE_VS_GLOBALS
+    "CLToolExe=cl.exe"
+    "CLToolPath=${CMAKE_BINARY_DIR}"
+    "TrackFileAccess=false"
+    "UseMultiToolTask=true"
+)
 
 # By default Visual Studio generators will use /Zi to capture debug information, which is not compatible with ccache, so
 # tell it to use /Z7 instead.
-if (MSVC)
-    foreach (var_ CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG
-                  CMAKE_CXX_FLAGS_RELEASE)
+if(MSVC)
+    foreach(
+        var_
+        CMAKE_C_FLAGS_DEBUG
+        CMAKE_C_FLAGS_RELEASE
+        CMAKE_CXX_FLAGS_DEBUG
+        CMAKE_CXX_FLAGS_RELEASE
+    )
         string(REPLACE "/Zi" "/Z7" ${var_} "${${var_}}")
-    endforeach ()
-endif ()
+    endforeach()
+endif()

cmake/CodeCoverage.cmake

@@ -174,37 +174,45 @@ option(CODE_COVERAGE_VERBOSE "Verbose information" FALSE)
 # Check prereqs
 find_program(GCOVR_PATH gcovr PATHS ${CMAKE_SOURCE_DIR}/scripts/test)
 
-if (DEFINED CODE_COVERAGE_GCOV_TOOL)
+if(DEFINED CODE_COVERAGE_GCOV_TOOL)
     set(GCOV_TOOL "${CODE_COVERAGE_GCOV_TOOL}")
-elseif (DEFINED ENV{CODE_COVERAGE_GCOV_TOOL})
+elseif(DEFINED ENV{CODE_COVERAGE_GCOV_TOOL})
     set(GCOV_TOOL "$ENV{CODE_COVERAGE_GCOV_TOOL}")
-elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
-    if (APPLE)
-        execute_process(COMMAND xcrun -f llvm-cov OUTPUT_VARIABLE LLVMCOV_PATH
-                        OUTPUT_STRIP_TRAILING_WHITESPACE)
-    else ()
+elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
+    if(APPLE)
+        execute_process(
+            COMMAND xcrun -f llvm-cov
+            OUTPUT_VARIABLE LLVMCOV_PATH
+            OUTPUT_STRIP_TRAILING_WHITESPACE
+        )
+    else()
         find_program(LLVMCOV_PATH llvm-cov)
-    endif ()
-    if (LLVMCOV_PATH)
+    endif()
+    if(LLVMCOV_PATH)
         set(GCOV_TOOL "${LLVMCOV_PATH} gcov")
-    endif ()
-elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
+    endif()
+elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
     find_program(GCOV_PATH gcov)
     set(GCOV_TOOL "${GCOV_PATH}")
-endif ()
+endif()
 
 # Check supported compiler (Clang, GNU and Flang)
 get_property(LANGUAGES GLOBAL PROPERTY ENABLED_LANGUAGES)
-foreach (LANG ${LANGUAGES})
-    if ("${CMAKE_${LANG}_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
-        if ("${CMAKE_${LANG}_COMPILER_VERSION}" VERSION_LESS 3)
-            message(FATAL_ERROR "Clang version must be 3.0.0 or greater! Aborting...")
-        endif ()
-    elseif (NOT "${CMAKE_${LANG}_COMPILER_ID}" MATCHES "GNU" AND NOT "${CMAKE_${LANG}_COMPILER_ID}"
-                                                                 MATCHES "(LLVM)?[Ff]lang")
+foreach(LANG ${LANGUAGES})
+    if("${CMAKE_${LANG}_COMPILER_ID}" MATCHES "(Apple)?[Cc]lang")
+        if("${CMAKE_${LANG}_COMPILER_VERSION}" VERSION_LESS 3)
+            message(
+                FATAL_ERROR
+                "Clang version must be 3.0.0 or greater! Aborting..."
+            )
+        endif()
+    elseif(
+        NOT "${CMAKE_${LANG}_COMPILER_ID}" MATCHES "GNU"
+        AND NOT "${CMAKE_${LANG}_COMPILER_ID}" MATCHES "(LLVM)?[Ff]lang"
+    )
         message(FATAL_ERROR "Compiler is not GNU or Flang! Aborting...")
-    endif ()
-endforeach ()
+    endif()
+endforeach()
 
 set(COVERAGE_COMPILER_FLAGS "-g --coverage" CACHE INTERNAL "")
 
@@ -213,7 +221,7 @@ set(COVERAGE_C_COMPILER_FLAGS "")
 set(COVERAGE_CXX_LINKER_FLAGS "")
 set(COVERAGE_C_LINKER_FLAGS "")
 
-if (CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
+if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
     include(CheckCXXCompilerFlag)
     include(CheckCCompilerFlag)
     include(CheckLinkerFlag)
@@ -224,51 +232,77 @@ if (CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
     set(COVERAGE_C_LINKER_FLAGS ${COVERAGE_COMPILER_FLAGS})
 
     check_cxx_compiler_flag(-fprofile-abs-path HAVE_cxx_fprofile_abs_path)
-    if (HAVE_cxx_fprofile_abs_path)
-        set(COVERAGE_CXX_COMPILER_FLAGS "${COVERAGE_CXX_COMPILER_FLAGS} -fprofile-abs-path")
-    endif ()
+    if(HAVE_cxx_fprofile_abs_path)
+        set(COVERAGE_CXX_COMPILER_FLAGS
+            "${COVERAGE_CXX_COMPILER_FLAGS} -fprofile-abs-path"
+        )
+    endif()
 
     check_c_compiler_flag(-fprofile-abs-path HAVE_c_fprofile_abs_path)
-    if (HAVE_c_fprofile_abs_path)
-        set(COVERAGE_C_COMPILER_FLAGS "${COVERAGE_C_COMPILER_FLAGS} -fprofile-abs-path")
-    endif ()
+    if(HAVE_c_fprofile_abs_path)
+        set(COVERAGE_C_COMPILER_FLAGS
+            "${COVERAGE_C_COMPILER_FLAGS} -fprofile-abs-path"
+        )
+    endif()
 
     check_linker_flag(CXX -fprofile-abs-path HAVE_cxx_linker_fprofile_abs_path)
-    if (HAVE_cxx_linker_fprofile_abs_path)
-        set(COVERAGE_CXX_LINKER_FLAGS "${COVERAGE_CXX_LINKER_FLAGS} -fprofile-abs-path")
-    endif ()
+    if(HAVE_cxx_linker_fprofile_abs_path)
+        set(COVERAGE_CXX_LINKER_FLAGS
+            "${COVERAGE_CXX_LINKER_FLAGS} -fprofile-abs-path"
+        )
+    endif()
 
     check_linker_flag(C -fprofile-abs-path HAVE_c_linker_fprofile_abs_path)
-    if (HAVE_c_linker_fprofile_abs_path)
-        set(COVERAGE_C_LINKER_FLAGS "${COVERAGE_C_LINKER_FLAGS} -fprofile-abs-path")
-    endif ()
+    if(HAVE_c_linker_fprofile_abs_path)
+        set(COVERAGE_C_LINKER_FLAGS
+            "${COVERAGE_C_LINKER_FLAGS} -fprofile-abs-path"
+        )
+    endif()
 
     check_cxx_compiler_flag(-fprofile-update=atomic HAVE_cxx_fprofile_update)
-    if (HAVE_cxx_fprofile_update)
-        set(COVERAGE_CXX_COMPILER_FLAGS "${COVERAGE_CXX_COMPILER_FLAGS}  -fprofile-update=atomic")
-    endif ()
+    if(HAVE_cxx_fprofile_update)
+        set(COVERAGE_CXX_COMPILER_FLAGS
+            "${COVERAGE_CXX_COMPILER_FLAGS}  -fprofile-update=atomic"
+        )
+    endif()
 
     check_c_compiler_flag(-fprofile-update=atomic HAVE_c_fprofile_update)
-    if (HAVE_c_fprofile_update)
-        set(COVERAGE_C_COMPILER_FLAGS "${COVERAGE_C_COMPILER_FLAGS} -fprofile-update=atomic")
-    endif ()
+    if(HAVE_c_fprofile_update)
+        set(COVERAGE_C_COMPILER_FLAGS
+            "${COVERAGE_C_COMPILER_FLAGS} -fprofile-update=atomic"
+        )
+    endif()
 
-    check_linker_flag(CXX -fprofile-update=atomic HAVE_cxx_linker_fprofile_update)
-    if (HAVE_cxx_linker_fprofile_update)
-        set(COVERAGE_CXX_LINKER_FLAGS "${COVERAGE_CXX_LINKER_FLAGS} -fprofile-update=atomic")
-    endif ()
+    check_linker_flag(
+        CXX
+        -fprofile-update=atomic
+        HAVE_cxx_linker_fprofile_update
+    )
+    if(HAVE_cxx_linker_fprofile_update)
+        set(COVERAGE_CXX_LINKER_FLAGS
+            "${COVERAGE_CXX_LINKER_FLAGS} -fprofile-update=atomic"
+        )
+    endif()
 
     check_linker_flag(C -fprofile-update=atomic HAVE_c_linker_fprofile_update)
-    if (HAVE_c_linker_fprofile_update)
-        set(COVERAGE_C_LINKER_FLAGS "${COVERAGE_C_LINKER_FLAGS} -fprofile-update=atomic")
-    endif ()
+    if(HAVE_c_linker_fprofile_update)
+        set(COVERAGE_C_LINKER_FLAGS
+            "${COVERAGE_C_LINKER_FLAGS} -fprofile-update=atomic"
+        )
+    endif()
+endif()
 
-endif ()
-
-get_property(GENERATOR_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-if (NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG))
-    message(WARNING "Code coverage results with an optimised (non-Debug) build may be misleading")
-endif () # NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG)
+get_property(
+    GENERATOR_IS_MULTI_CONFIG
+    GLOBAL
+    PROPERTY GENERATOR_IS_MULTI_CONFIG
+)
+if(NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG))
+    message(
+        WARNING
+        "Code coverage results with an optimised (non-Debug) build may be misleading"
+    )
+endif() # NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG)
 
 # Defines a target for running and collection code coverage information
 # Builds dependencies, runs the given executable and outputs reports.
@@ -292,125 +326,167 @@ endif () # NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR GENERATOR_IS_MULTI_CONFIG)
 # )
 # The user can set the variable GCOVR_ADDITIONAL_ARGS to supply additional flags to the
 # GCVOR command.
-function (setup_target_for_coverage_gcovr)
+function(setup_target_for_coverage_gcovr)
     set(options NONE)
     set(oneValueArgs BASE_DIRECTORY NAME FORMAT)
     set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
-    cmake_parse_arguments(Coverage "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+    cmake_parse_arguments(
+        Coverage
+        "${options}"
+        "${oneValueArgs}"
+        "${multiValueArgs}"
+        ${ARGN}
+    )
 
-    if (NOT GCOV_TOOL)
+    if(NOT GCOV_TOOL)
         message(FATAL_ERROR "Could not find gcov or llvm-cov tool! Aborting...")
-    endif ()
+    endif()
 
-    if (NOT GCOVR_PATH)
+    if(NOT GCOVR_PATH)
         message(FATAL_ERROR "Could not find gcovr tool! Aborting...")
-    endif ()
+    endif()
 
     # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR
-    if (DEFINED Coverage_BASE_DIRECTORY)
+    if(DEFINED Coverage_BASE_DIRECTORY)
         get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE)
-    else ()
+    else()
         set(BASEDIR ${PROJECT_SOURCE_DIR})
-    endif ()
+    endif()
 
-    if (NOT DEFINED Coverage_FORMAT)
+    if(NOT DEFINED Coverage_FORMAT)
         set(Coverage_FORMAT xml)
-    endif ()
+    endif()
 
-    if (NOT DEFINED Coverage_EXECUTABLE AND DEFINED Coverage_EXECUTABLE_ARGS)
-        message(FATAL_ERROR "EXECUTABLE_ARGS must not be set if EXECUTABLE is not set")
-    endif ()
-
-    if ("--output" IN_LIST GCOVR_ADDITIONAL_ARGS)
-        message(FATAL_ERROR "Unsupported --output option detected in GCOVR_ADDITIONAL_ARGS! Aborting..."
+    if(NOT DEFINED Coverage_EXECUTABLE AND DEFINED Coverage_EXECUTABLE_ARGS)
+        message(
+            FATAL_ERROR
+            "EXECUTABLE_ARGS must not be set if EXECUTABLE is not set"
         )
-    else ()
-        if ((Coverage_FORMAT STREQUAL "html-details") OR (Coverage_FORMAT STREQUAL "html-nested"))
-            set(GCOVR_OUTPUT_FILE ${PROJECT_BINARY_DIR}/${Coverage_NAME}/index.html)
-            set(GCOVR_CREATE_FOLDER ${PROJECT_BINARY_DIR}/${Coverage_NAME})
-        elseif (Coverage_FORMAT STREQUAL "html-single")
-            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.html)
-        elseif ((Coverage_FORMAT STREQUAL "json-summary") OR (Coverage_FORMAT STREQUAL
-                                                              "json-details")
-                OR (Coverage_FORMAT STREQUAL "coveralls"))
-            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.json)
-        elseif (Coverage_FORMAT STREQUAL "txt")
-            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.txt)
-        elseif (Coverage_FORMAT STREQUAL "csv")
-            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.csv)
-        elseif (Coverage_FORMAT STREQUAL "lcov")
-            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.lcov)
-        else ()
-            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.xml)
-        endif ()
-    endif ()
+    endif()
 
-    if ((Coverage_FORMAT STREQUAL "cobertura") OR (Coverage_FORMAT STREQUAL "xml"))
+    if("--output" IN_LIST GCOVR_ADDITIONAL_ARGS)
+        message(
+            FATAL_ERROR
+            "Unsupported --output option detected in GCOVR_ADDITIONAL_ARGS! Aborting..."
+        )
+    else()
+        if(
+            (Coverage_FORMAT STREQUAL "html-details")
+            OR (Coverage_FORMAT STREQUAL "html-nested")
+        )
+            set(GCOVR_OUTPUT_FILE
+                ${PROJECT_BINARY_DIR}/${Coverage_NAME}/index.html
+            )
+            set(GCOVR_CREATE_FOLDER ${PROJECT_BINARY_DIR}/${Coverage_NAME})
+        elseif(Coverage_FORMAT STREQUAL "html-single")
+            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.html)
+        elseif(
+            (Coverage_FORMAT STREQUAL "json-summary")
+            OR (Coverage_FORMAT STREQUAL "json-details")
+            OR (Coverage_FORMAT STREQUAL "coveralls")
+        )
+            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.json)
+        elseif(Coverage_FORMAT STREQUAL "txt")
+            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.txt)
+        elseif(Coverage_FORMAT STREQUAL "csv")
+            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.csv)
+        elseif(Coverage_FORMAT STREQUAL "lcov")
+            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.lcov)
+        else()
+            set(GCOVR_OUTPUT_FILE ${Coverage_NAME}.xml)
+        endif()
+    endif()
+
+    if(
+        (Coverage_FORMAT STREQUAL "cobertura")
+        OR (Coverage_FORMAT STREQUAL "xml")
+    )
         list(APPEND GCOVR_ADDITIONAL_ARGS --cobertura "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --cobertura-pretty)
         set(Coverage_FORMAT cobertura) # overwrite xml
-    elseif (Coverage_FORMAT STREQUAL "sonarqube")
+    elseif(Coverage_FORMAT STREQUAL "sonarqube")
         list(APPEND GCOVR_ADDITIONAL_ARGS --sonarqube "${GCOVR_OUTPUT_FILE}")
-    elseif (Coverage_FORMAT STREQUAL "jacoco")
+    elseif(Coverage_FORMAT STREQUAL "jacoco")
         list(APPEND GCOVR_ADDITIONAL_ARGS --jacoco "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --jacoco-pretty)
-    elseif (Coverage_FORMAT STREQUAL "clover")
+    elseif(Coverage_FORMAT STREQUAL "clover")
         list(APPEND GCOVR_ADDITIONAL_ARGS --clover "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --clover-pretty)
-    elseif (Coverage_FORMAT STREQUAL "lcov")
+    elseif(Coverage_FORMAT STREQUAL "lcov")
         list(APPEND GCOVR_ADDITIONAL_ARGS --lcov "${GCOVR_OUTPUT_FILE}")
-    elseif (Coverage_FORMAT STREQUAL "json-summary")
+    elseif(Coverage_FORMAT STREQUAL "json-summary")
         list(APPEND GCOVR_ADDITIONAL_ARGS --json-summary "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --json-summary-pretty)
-    elseif (Coverage_FORMAT STREQUAL "json-details")
+    elseif(Coverage_FORMAT STREQUAL "json-details")
         list(APPEND GCOVR_ADDITIONAL_ARGS --json "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --json-pretty)
-    elseif (Coverage_FORMAT STREQUAL "coveralls")
+    elseif(Coverage_FORMAT STREQUAL "coveralls")
         list(APPEND GCOVR_ADDITIONAL_ARGS --coveralls "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --coveralls-pretty)
-    elseif (Coverage_FORMAT STREQUAL "csv")
+    elseif(Coverage_FORMAT STREQUAL "csv")
         list(APPEND GCOVR_ADDITIONAL_ARGS --csv "${GCOVR_OUTPUT_FILE}")
-    elseif (Coverage_FORMAT STREQUAL "txt")
+    elseif(Coverage_FORMAT STREQUAL "txt")
         list(APPEND GCOVR_ADDITIONAL_ARGS --txt "${GCOVR_OUTPUT_FILE}")
-    elseif (Coverage_FORMAT STREQUAL "html-single")
+    elseif(Coverage_FORMAT STREQUAL "html-single")
         list(APPEND GCOVR_ADDITIONAL_ARGS --html "${GCOVR_OUTPUT_FILE}")
         list(APPEND GCOVR_ADDITIONAL_ARGS --html-self-contained)
-    elseif (Coverage_FORMAT STREQUAL "html-nested")
+    elseif(Coverage_FORMAT STREQUAL "html-nested")
         list(APPEND GCOVR_ADDITIONAL_ARGS --html-nested "${GCOVR_OUTPUT_FILE}")
-    elseif (Coverage_FORMAT STREQUAL "html-details")
+    elseif(Coverage_FORMAT STREQUAL "html-details")
         list(APPEND GCOVR_ADDITIONAL_ARGS --html-details "${GCOVR_OUTPUT_FILE}")
-    else ()
-        message(FATAL_ERROR "Unsupported output style ${Coverage_FORMAT}! Aborting...")
-    endif ()
+    else()
+        message(
+            FATAL_ERROR
+            "Unsupported output style ${Coverage_FORMAT}! Aborting..."
+        )
+    endif()
 
     # Collect excludes (CMake 3.4+: Also compute absolute paths)
     set(GCOVR_EXCLUDES "")
-    foreach (EXCLUDE ${Coverage_EXCLUDE} ${COVERAGE_EXCLUDES} ${COVERAGE_GCOVR_EXCLUDES})
-        if (CMAKE_VERSION VERSION_GREATER 3.4)
-            get_filename_component(EXCLUDE ${EXCLUDE} ABSOLUTE BASE_DIR ${BASEDIR})
-        endif ()
+    foreach(
+        EXCLUDE
+        ${Coverage_EXCLUDE}
+        ${COVERAGE_EXCLUDES}
+        ${COVERAGE_GCOVR_EXCLUDES}
+    )
+        if(CMAKE_VERSION VERSION_GREATER 3.4)
+            get_filename_component(
+                EXCLUDE
+                ${EXCLUDE}
+                ABSOLUTE
+                BASE_DIR ${BASEDIR}
+            )
+        endif()
         list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
-    endforeach ()
+    endforeach()
     list(REMOVE_DUPLICATES GCOVR_EXCLUDES)
 
     # Combine excludes to several -e arguments
     set(GCOVR_EXCLUDE_ARGS "")
-    foreach (EXCLUDE ${GCOVR_EXCLUDES})
+    foreach(EXCLUDE ${GCOVR_EXCLUDES})
         list(APPEND GCOVR_EXCLUDE_ARGS "-e")
         list(APPEND GCOVR_EXCLUDE_ARGS "${EXCLUDE}")
-    endforeach ()
+    endforeach()
 
     # Set up commands which will be run to generate coverage data
     # If EXECUTABLE is not set, the user is expected to run the tests manually
     # before running the coverage target NAME
-    if (DEFINED Coverage_EXECUTABLE)
-        set(GCOVR_EXEC_TESTS_CMD ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS})
-    endif ()
+    if(DEFINED Coverage_EXECUTABLE)
+        set(GCOVR_EXEC_TESTS_CMD
+            ${Coverage_EXECUTABLE}
+            ${Coverage_EXECUTABLE_ARGS}
+        )
+    endif()
 
     # Create folder
-    if (DEFINED GCOVR_CREATE_FOLDER)
-        set(GCOVR_FOLDER_CMD ${CMAKE_COMMAND} -E make_directory ${GCOVR_CREATE_FOLDER})
-    endif ()
+    if(DEFINED GCOVR_CREATE_FOLDER)
+        set(GCOVR_FOLDER_CMD
+            ${CMAKE_COMMAND}
+            -E
+            make_directory
+            ${GCOVR_CREATE_FOLDER}
+        )
+    endif()
 
     # Running gcovr
     set(GCOVR_CMD
@@ -422,56 +498,95 @@ function (setup_target_for_coverage_gcovr)
         ${BASEDIR}
         ${GCOVR_ADDITIONAL_ARGS}
         ${GCOVR_EXCLUDE_ARGS}
-        --object-directory=${PROJECT_BINARY_DIR})
+        --object-directory=${PROJECT_BINARY_DIR}
+    )
 
-    if (CODE_COVERAGE_VERBOSE)
+    if(CODE_COVERAGE_VERBOSE)
         message(STATUS "Executed command report")
 
-        if (NOT "${GCOVR_EXEC_TESTS_CMD}" STREQUAL "")
+        if(NOT "${GCOVR_EXEC_TESTS_CMD}" STREQUAL "")
             message(STATUS "Command to run tests: ")
-            string(REPLACE ";" " " GCOVR_EXEC_TESTS_CMD_SPACED "${GCOVR_EXEC_TESTS_CMD}")
+            string(
+                REPLACE ";"
+                " "
+                GCOVR_EXEC_TESTS_CMD_SPACED
+                "${GCOVR_EXEC_TESTS_CMD}"
+            )
             message(STATUS "${GCOVR_EXEC_TESTS_CMD_SPACED}")
-        endif ()
+        endif()
 
-        if (NOT "${GCOVR_FOLDER_CMD}" STREQUAL "")
+        if(NOT "${GCOVR_FOLDER_CMD}" STREQUAL "")
             message(STATUS "Command to create a folder: ")
-            string(REPLACE ";" " " GCOVR_FOLDER_CMD_SPACED "${GCOVR_FOLDER_CMD}")
+            string(
+                REPLACE ";"
+                " "
+                GCOVR_FOLDER_CMD_SPACED
+                "${GCOVR_FOLDER_CMD}"
+            )
             message(STATUS "${GCOVR_FOLDER_CMD_SPACED}")
-        endif ()
+        endif()
 
         message(STATUS "Command to generate gcovr coverage data: ")
         string(REPLACE ";" " " GCOVR_CMD_SPACED "${GCOVR_CMD}")
         message(STATUS "${GCOVR_CMD_SPACED}")
-    endif ()
+    endif()
 
-    add_custom_target(${Coverage_NAME}
-                      COMMAND ${GCOVR_EXEC_TESTS_CMD}
-                      COMMAND ${GCOVR_FOLDER_CMD}
-                      COMMAND ${GCOVR_CMD}
-                      BYPRODUCTS ${GCOVR_OUTPUT_FILE}
-                      WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
-                      DEPENDS ${Coverage_DEPENDENCIES}
-                      VERBATIM # Protect arguments to commands
-                      COMMENT "Running gcovr to produce code coverage report.")
+    add_custom_target(
+        ${Coverage_NAME}
+        COMMAND ${GCOVR_EXEC_TESTS_CMD}
+        COMMAND ${GCOVR_FOLDER_CMD}
+        COMMAND ${GCOVR_CMD}
+        BYPRODUCTS ${GCOVR_OUTPUT_FILE}
+        WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
+        DEPENDS ${Coverage_DEPENDENCIES}
+        VERBATIM # Protect arguments to commands
+        COMMENT "Running gcovr to produce code coverage report."
+    )
 
     # Show info where to find the report
     add_custom_command(
-        TARGET ${Coverage_NAME} POST_BUILD COMMAND echo
-        COMMENT "Code coverage report saved in ${GCOVR_OUTPUT_FILE} formatted as ${Coverage_FORMAT}"
+        TARGET ${Coverage_NAME}
+        POST_BUILD
+        COMMAND echo
+        COMMENT
+            "Code coverage report saved in ${GCOVR_OUTPUT_FILE} formatted as ${Coverage_FORMAT}"
     )
-endfunction () # setup_target_for_coverage_gcovr
+endfunction() # setup_target_for_coverage_gcovr
 
-function (add_code_coverage_to_target name scope)
-    separate_arguments(COVERAGE_CXX_COMPILER_FLAGS NATIVE_COMMAND "${COVERAGE_CXX_COMPILER_FLAGS}")
-    separate_arguments(COVERAGE_C_COMPILER_FLAGS NATIVE_COMMAND "${COVERAGE_C_COMPILER_FLAGS}")
-    separate_arguments(COVERAGE_CXX_LINKER_FLAGS NATIVE_COMMAND "${COVERAGE_CXX_LINKER_FLAGS}")
-    separate_arguments(COVERAGE_C_LINKER_FLAGS NATIVE_COMMAND "${COVERAGE_C_LINKER_FLAGS}")
+function(add_code_coverage_to_target name scope)
+    separate_arguments(
+        COVERAGE_CXX_COMPILER_FLAGS
+        NATIVE_COMMAND
+        "${COVERAGE_CXX_COMPILER_FLAGS}"
+    )
+    separate_arguments(
+        COVERAGE_C_COMPILER_FLAGS
+        NATIVE_COMMAND
+        "${COVERAGE_C_COMPILER_FLAGS}"
+    )
+    separate_arguments(
+        COVERAGE_CXX_LINKER_FLAGS
+        NATIVE_COMMAND
+        "${COVERAGE_CXX_LINKER_FLAGS}"
+    )
+    separate_arguments(
+        COVERAGE_C_LINKER_FLAGS
+        NATIVE_COMMAND
+        "${COVERAGE_C_LINKER_FLAGS}"
+    )
 
     # Add compiler options to the target
     target_compile_options(
-        ${name} ${scope} $<$<COMPILE_LANGUAGE:CXX>:${COVERAGE_CXX_COMPILER_FLAGS}>
-        $<$<COMPILE_LANGUAGE:C>:${COVERAGE_C_COMPILER_FLAGS}>)
+        ${name}
+        ${scope}
+        $<$<COMPILE_LANGUAGE:CXX>:${COVERAGE_CXX_COMPILER_FLAGS}>
+        $<$<COMPILE_LANGUAGE:C>:${COVERAGE_C_COMPILER_FLAGS}>
+    )
 
-    target_link_libraries(${name} ${scope} $<$<LINK_LANGUAGE:CXX>:${COVERAGE_CXX_LINKER_FLAGS}>
-                          $<$<LINK_LANGUAGE:C>:${COVERAGE_C_LINKER_FLAGS}>)
-endfunction () # add_code_coverage_to_target
+    target_link_libraries(
+        ${name}
+        ${scope}
+        $<$<LINK_LANGUAGE:CXX>:${COVERAGE_CXX_LINKER_FLAGS}>
+        $<$<LINK_LANGUAGE:C>:${COVERAGE_C_LINKER_FLAGS}>
+    )
+endfunction() # add_code_coverage_to_target

cmake/CompilationEnv.cmake

@@ -14,20 +14,20 @@ set(is_gcc FALSE)
 set(is_msvc FALSE)
 set(is_xcode FALSE)
 
-if (CMAKE_CXX_COMPILER_ID MATCHES ".*Clang") # Clang or AppleClang
+if(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang") # Clang or AppleClang
     set(is_clang TRUE)
-elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     set(is_gcc TRUE)
-elseif (MSVC)
+elseif(MSVC)
     set(is_msvc TRUE)
-else ()
+else()
     message(FATAL_ERROR "Unsupported C++ compiler: ${CMAKE_CXX_COMPILER_ID}")
-endif ()
+endif()
 
 # Xcode generator detection
-if (CMAKE_GENERATOR STREQUAL "Xcode")
+if(CMAKE_GENERATOR STREQUAL "Xcode")
     set(is_xcode TRUE)
-endif ()
+endif()
 
 # --------------------------------------------------------------------
 # Operating system detection
@@ -36,23 +36,23 @@ set(is_linux FALSE)
 set(is_windows FALSE)
 set(is_macos FALSE)
 
-if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
     set(is_linux TRUE)
-elseif (CMAKE_SYSTEM_NAME STREQUAL "Windows")
+elseif(CMAKE_SYSTEM_NAME STREQUAL "Windows")
     set(is_windows TRUE)
-elseif (CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
     set(is_macos TRUE)
-endif ()
+endif()
 
 # --------------------------------------------------------------------
 # Architecture
 # --------------------------------------------------------------------
 set(is_amd64 FALSE)
 set(is_arm64 FALSE)
-if (CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64")
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64")
     set(is_amd64 TRUE)
-elseif (CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64|ARM64")
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64|ARM64")
     set(is_arm64 TRUE)
-else ()
+else()
     message(FATAL_ERROR "Unknown architecture: ${CMAKE_SYSTEM_PROCESSOR}")
-endif ()
+endif()

cmake/GitInfo.cmake

@@ -0,0 +1,28 @@
+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/XrplAddTest.cmake

@@ -1,13 +1,22 @@
 include(isolate_headers)
 
-function (xrpl_add_test name)
+function(xrpl_add_test name)
     set(target ${PROJECT_NAME}.test.${name})
 
-    file(GLOB_RECURSE sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/${name}/*.cpp"
-         "${CMAKE_CURRENT_SOURCE_DIR}/${name}.cpp")
+    file(
+        GLOB_RECURSE sources
+        CONFIGURE_DEPENDS
+        "${CMAKE_CURRENT_SOURCE_DIR}/${name}/*.cpp"
+        "${CMAKE_CURRENT_SOURCE_DIR}/${name}.cpp"
+    )
     add_executable(${target} ${ARGN} ${sources})
 
-    isolate_headers(${target} "${CMAKE_SOURCE_DIR}" "${CMAKE_SOURCE_DIR}/tests/${name}" PRIVATE)
+    isolate_headers(
+        ${target}
+        "${CMAKE_SOURCE_DIR}"
+        "${CMAKE_SOURCE_DIR}/tests/${name}"
+        PRIVATE
+    )
 
     add_test(NAME ${target} COMMAND ${target})
-endfunction ()
+endfunction()

cmake/XrplCompiler.cmake

@@ -14,33 +14,42 @@ include(XrplSanitizers)
 # add a single global dependency on this interface lib
 link_libraries(Xrpl::common)
 # Respect CMAKE_POSITION_INDEPENDENT_CODE setting (may be set by Conan toolchain)
-if (NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE)
+if(NOT DEFINED CMAKE_POSITION_INDEPENDENT_CODE)
     set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-endif ()
-set_target_properties(common PROPERTIES INTERFACE_POSITION_INDEPENDENT_CODE
-                                        ${CMAKE_POSITION_INDEPENDENT_CODE})
+endif()
+set_target_properties(
+    common
+    PROPERTIES
+        INTERFACE_POSITION_INDEPENDENT_CODE ${CMAKE_POSITION_INDEPENDENT_CODE}
+)
 set(CMAKE_CXX_EXTENSIONS OFF)
 target_compile_definitions(
     common
-    INTERFACE $<$<CONFIG:Debug>:DEBUG
-              _DEBUG>
-              #[===[
+    INTERFACE
+        $<$<CONFIG:Debug>:DEBUG
+        _DEBUG>
+        #[===[
     NOTE: CMAKE release builds already have NDEBUG defined, so no need to add it
     explicitly except for the special case of (profile ON) and (assert OFF).
     Presumably this is because we don't want profile builds asserting unless
     asserts were specifically requested.
     ]===]
-              $<$<AND:$<BOOL:${profile}>,$<NOT:$<BOOL:${assert}>>>:NDEBUG>
-              # TODO: Remove once we have migrated functions from OpenSSL 1.x to 3.x.
-              OPENSSL_SUPPRESS_DEPRECATED)
+        $<$<AND:$<BOOL:${profile}>,$<NOT:$<BOOL:${assert}>>>:NDEBUG>
+        # TODO: Remove once we have migrated functions from OpenSSL 1.x to 3.x.
+        OPENSSL_SUPPRESS_DEPRECATED
+)
 
-if (MSVC)
+if(MSVC)
     # remove existing exception flag since we set it to -EHa
     string(REGEX REPLACE "[-/]EH[a-z]+" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 
-    foreach (var_ CMAKE_C_FLAGS_DEBUG CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG
-                  CMAKE_CXX_FLAGS_RELEASE)
-
+    foreach(
+        var_
+        CMAKE_C_FLAGS_DEBUG
+        CMAKE_C_FLAGS_RELEASE
+        CMAKE_CXX_FLAGS_DEBUG
+        CMAKE_CXX_FLAGS_RELEASE
+    )
         # also remove dynamic runtime
         string(REGEX REPLACE "[-/]MD[d]*" " " ${var_} "${${var_}}")
 
@@ -48,120 +57,143 @@ if (MSVC)
         string(REPLACE "/ZI" "/Zi" ${var_} "${${var_}}")
 
         # omit debug info completely under CI (not needed)
-        if (is_ci)
+        if(is_ci)
             string(REPLACE "/Zi" " " ${var_} "${${var_}}")
             string(REPLACE "/Z7" " " ${var_} "${${var_}}")
-        endif ()
-    endforeach ()
+        endif()
+    endforeach()
 
     target_compile_options(
         common
         INTERFACE # Increase object file max size
-                  -bigobj
-                  # Floating point behavior
-                  -fp:precise
-                  # __cdecl calling convention
-                  -Gd
-                  # Minimal rebuild: disabled
-                  -Gm-
-                  # Function level linking: disabled
-                  -Gy-
-                  # Multiprocessor compilation
-                  -MP
-                  # pragma omp: disabled
-                  -openmp-
-                  # No error reporting to Internet
-                  -errorReport:none
-                  # Suppress login banner
-                  -nologo
-                  # Disable signed/unsigned comparison warnings
-                  -wd4018
-                  # Disable float to int possible loss of data warnings
-                  -wd4244
-                  # Disable size_t to T possible loss of data warnings
-                  -wd4267
-                  # Disable C4800(int to bool performance)
-                  -wd4800
-                  # Decorated name length exceeded, name was truncated
-                  -wd4503
-                  $<$<COMPILE_LANGUAGE:CXX>:
-                  -EHa
-                  -GR
-                  >
-                  $<$<CONFIG:Release>:-Ox>
-                  $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:Debug>>:
-                  -GS
-                  -Zc:forScope
-                  >
-                  # static runtime
-                  $<$<CONFIG:Debug>:-MTd>
-                  $<$<NOT:$<CONFIG:Debug>>:-MT>
-                  $<$<BOOL:${werr}>:-WX>)
+            -bigobj
+            # Floating point behavior
+            -fp:precise
+            # __cdecl calling convention
+            -Gd
+            # Minimal rebuild: disabled
+            -Gm-
+            # Function level linking: disabled
+            -Gy-
+            # Multiprocessor compilation
+            -MP
+            # pragma omp: disabled
+            -openmp-
+            # No error reporting to Internet
+            -errorReport:none
+            # Suppress login banner
+            -nologo
+            # Disable signed/unsigned comparison warnings
+            -wd4018
+            # Disable float to int possible loss of data warnings
+            -wd4244
+            # Disable size_t to T possible loss of data warnings
+            -wd4267
+            # Disable C4800(int to bool performance)
+            -wd4800
+            # Decorated name length exceeded, name was truncated
+            -wd4503
+            $<$<COMPILE_LANGUAGE:CXX>:
+            -EHa
+            -GR
+            >
+            $<$<CONFIG:Release>:-Ox>
+            $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:Debug>>:
+            -GS
+            -Zc:forScope
+            >
+            # static runtime
+            $<$<CONFIG:Debug>:-MTd>
+            $<$<NOT:$<CONFIG:Debug>>:-MT>
+            $<$<BOOL:${werr}>:-WX>
+    )
     target_compile_definitions(
         common
-        INTERFACE _WIN32_WINNT=0x6000
-                  _SCL_SECURE_NO_WARNINGS
-                  _CRT_SECURE_NO_WARNINGS
-                  WIN32_CONSOLE
-                  WIN32_LEAN_AND_MEAN
-                  NOMINMAX
-                  # TODO: Resolve these warnings, don't just silence them
-                  _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS
-                  $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:Debug>>:_CRTDBG_MAP_ALLOC>)
+        INTERFACE
+            _WIN32_WINNT=0x6000
+            _SCL_SECURE_NO_WARNINGS
+            _CRT_SECURE_NO_WARNINGS
+            WIN32_CONSOLE
+            WIN32_LEAN_AND_MEAN
+            NOMINMAX
+            # TODO: Resolve these warnings, don't just silence them
+            _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS
+            $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<CONFIG:Debug>>:_CRTDBG_MAP_ALLOC>
+    )
     target_link_libraries(common INTERFACE -errorreport:none -machine:X64)
-else ()
+else()
     target_compile_options(
         common
-        INTERFACE -Wall
-                  -Wdeprecated
-                  $<$<BOOL:${is_clang}>:-Wno-deprecated-declarations>
-                  $<$<BOOL:${wextra}>:-Wextra
-                  -Wno-unused-parameter>
-                  $<$<BOOL:${werr}>:-Werror>
-                  -fstack-protector
-                  -Wno-sign-compare
-                  -Wno-unused-but-set-variable
-                  $<$<NOT:$<CONFIG:Debug>>:-fno-strict-aliasing>
-                  # tweak gcc optimization for debug
-                  $<$<AND:$<BOOL:${is_gcc}>,$<CONFIG:Debug>>:-O0>
-                  # Add debug symbols to release config
-                  $<$<CONFIG:Release>:-g>)
+        INTERFACE
+            -Wall
+            -Wdeprecated
+            $<$<BOOL:${is_clang}>:-Wno-deprecated-declarations>
+            $<$<BOOL:${wextra}>:-Wextra
+            -Wno-unused-parameter>
+            $<$<BOOL:${werr}>:-Werror>
+            -fstack-protector
+            -Wno-sign-compare
+            -Wno-unused-but-set-variable
+            $<$<NOT:$<CONFIG:Debug>>:-fno-strict-aliasing>
+            # tweak gcc optimization for debug
+            $<$<AND:$<BOOL:${is_gcc}>,$<CONFIG:Debug>>:-O0>
+            # Add debug symbols to release config
+            $<$<CONFIG:Release>:-g>
+    )
     target_link_libraries(
         common
-        INTERFACE -rdynamic
-                  $<$<BOOL:${is_linux}>:-Wl,-z,relro,-z,now,--build-id>
-                  # link to static libc/c++ iff: * static option set and * NOT APPLE (AppleClang does not support static
-                  # libc/c++) and * NOT SANITIZERS (sanitizers typically don't work with static libc/c++)
-                  $<$<AND:$<BOOL:${static}>,$<NOT:$<BOOL:${APPLE}>>,$<NOT:$<BOOL:${SANITIZERS_ENABLED}>>>:
-                  -static-libstdc++
-                  -static-libgcc
-                  >)
-endif ()
+        INTERFACE
+            -rdynamic
+            $<$<BOOL:${is_linux}>:-Wl,-z,relro,-z,now,--build-id>
+            # link to static libc/c++ iff: * static option set and * NOT APPLE (AppleClang does not support static
+            # libc/c++) and * NOT SANITIZERS (sanitizers typically don't work with static libc/c++)
+            $<$<AND:$<BOOL:${static}>,$<NOT:$<BOOL:${APPLE}>>,$<NOT:$<BOOL:${SANITIZERS_ENABLED}>>>:
+            -static-libstdc++
+            -static-libgcc
+            >
+    )
+endif()
 
 # Antithesis instrumentation will only be built and deployed using machines running Linux.
-if (voidstar)
-    if (NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
-        message(FATAL_ERROR "Antithesis instrumentation requires Debug build type, aborting...")
-    elseif (NOT is_linux)
-        message(FATAL_ERROR "Antithesis instrumentation requires Linux, aborting...")
-    elseif (NOT (is_clang AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 16.0))
-        message(FATAL_ERROR "Antithesis instrumentation requires Clang version 16 or later, aborting..."
+if(voidstar)
+    if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+        message(
+            FATAL_ERROR
+            "Antithesis instrumentation requires Debug build type, aborting..."
         )
-    endif ()
-endif ()
+    elseif(NOT is_linux)
+        message(
+            FATAL_ERROR
+            "Antithesis instrumentation requires Linux, aborting..."
+        )
+    elseif(
+        NOT (is_clang AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 16.0)
+    )
+        message(
+            FATAL_ERROR
+            "Antithesis instrumentation requires Clang version 16 or later, aborting..."
+        )
+    endif()
+endif()
 
-if (use_mold)
+if(use_mold)
     # use mold linker if available
-    execute_process(COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=mold -Wl,--version ERROR_QUIET
-                    OUTPUT_VARIABLE LD_VERSION)
-    if ("${LD_VERSION}" MATCHES "mold")
+    execute_process(
+        COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=mold -Wl,--version
+        ERROR_QUIET
+        OUTPUT_VARIABLE LD_VERSION
+    )
+    if("${LD_VERSION}" MATCHES "mold")
         target_link_libraries(common INTERFACE -fuse-ld=mold)
-    endif ()
+    endif()
     unset(LD_VERSION)
-elseif (use_gold AND is_gcc)
+elseif(use_gold AND is_gcc)
     # use gold linker if available
-    execute_process(COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=gold -Wl,--version ERROR_QUIET
-                    OUTPUT_VARIABLE LD_VERSION)
+    execute_process(
+        COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=gold -Wl,--version
+        ERROR_QUIET
+        OUTPUT_VARIABLE LD_VERSION
+    )
     #[=========================================================[
        NOTE: THE gold linker inserts -rpath as DT_RUNPATH by
        default instead of DT_RPATH, so you might have slightly
@@ -175,32 +207,37 @@ elseif (use_gold AND is_gcc)
        disabling would be to figure out all the settings
        required to make gold play nicely with jemalloc.
     #]=========================================================]
-    if (("${LD_VERSION}" MATCHES "GNU gold") AND (NOT jemalloc))
+    if(("${LD_VERSION}" MATCHES "GNU gold") AND (NOT jemalloc))
         target_link_libraries(
             common
-            INTERFACE -fuse-ld=gold
-                      -Wl,--no-as-needed
-                      #[=========================================================[
+            INTERFACE
+                -fuse-ld=gold
+                -Wl,--no-as-needed
+                #[=========================================================[
            see https://bugs.launchpad.net/ubuntu/+source/eglibc/+bug/1253638/comments/5
            DT_RUNPATH does not work great for transitive
            dependencies (of which boost has a few) - so just
            switch to DT_RPATH if doing dynamic linking with gold
         #]=========================================================]
-                      $<$<NOT:$<BOOL:${static}>>:-Wl,--disable-new-dtags>)
-    endif ()
+                $<$<NOT:$<BOOL:${static}>>:-Wl,--disable-new-dtags>
+        )
+    endif()
     unset(LD_VERSION)
-elseif (use_lld)
+elseif(use_lld)
     # use lld linker if available
-    execute_process(COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=lld -Wl,--version ERROR_QUIET
-                    OUTPUT_VARIABLE LD_VERSION)
-    if ("${LD_VERSION}" MATCHES "LLD")
+    execute_process(
+        COMMAND ${CMAKE_CXX_COMPILER} -fuse-ld=lld -Wl,--version
+        ERROR_QUIET
+        OUTPUT_VARIABLE LD_VERSION
+    )
+    if("${LD_VERSION}" MATCHES "LLD")
         target_link_libraries(common INTERFACE -fuse-ld=lld)
-    endif ()
+    endif()
     unset(LD_VERSION)
-endif ()
+endif()
 
-if (assert)
-    foreach (var_ CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_RELEASE)
+if(assert)
+    foreach(var_ CMAKE_C_FLAGS_RELEASE CMAKE_CXX_FLAGS_RELEASE)
         string(REGEX REPLACE "[-/]DNDEBUG" "" ${var_} "${${var_}}")
-    endforeach ()
-endif ()
+    endforeach()
+endif()

cmake/XrplConfig.cmake

@@ -3,50 +3,58 @@ include(CMakeFindDependencyMacro)
 #[=========================================================[
   Boost
 #]=========================================================]
-if (static OR APPLE OR MSVC)
+if(static OR APPLE OR MSVC)
     set(Boost_USE_STATIC_LIBS ON)
-endif ()
+endif()
 set(Boost_USE_MULTITHREADED ON)
-if (static OR MSVC)
+if(static OR MSVC)
     set(Boost_USE_STATIC_RUNTIME ON)
-else ()
+else()
     set(Boost_USE_STATIC_RUNTIME OFF)
-endif ()
-find_dependency(Boost
-                COMPONENTS
-                chrono
-                container
-                context
-                coroutine
-                date_time
-                filesystem
-                program_options
-                regex
-                system
-                thread)
+endif()
+find_dependency(
+    Boost
+    COMPONENTS
+    chrono
+    container
+    context
+    coroutine
+    date_time
+    filesystem
+    program_options
+    regex
+    system
+    thread
+)
 #[=========================================================[
   OpenSSL
 #]=========================================================]
-if (NOT DEFINED OPENSSL_ROOT_DIR)
-    if (DEFINED ENV{OPENSSL_ROOT})
+if(NOT DEFINED OPENSSL_ROOT_DIR)
+    if(DEFINED ENV{OPENSSL_ROOT})
         set(OPENSSL_ROOT_DIR $ENV{OPENSSL_ROOT})
-    elseif (APPLE)
+    elseif(APPLE)
         find_program(homebrew brew)
-        if (homebrew)
-            execute_process(COMMAND ${homebrew} --prefix openssl OUTPUT_VARIABLE OPENSSL_ROOT_DIR
-                            OUTPUT_STRIP_TRAILING_WHITESPACE)
-        endif ()
-    endif ()
+        if(homebrew)
+            execute_process(
+                COMMAND ${homebrew} --prefix openssl
+                OUTPUT_VARIABLE OPENSSL_ROOT_DIR
+                OUTPUT_STRIP_TRAILING_WHITESPACE
+            )
+        endif()
+    endif()
     file(TO_CMAKE_PATH "${OPENSSL_ROOT_DIR}" OPENSSL_ROOT_DIR)
-endif ()
+endif()
 
-if (static OR APPLE OR MSVC)
+if(static OR APPLE OR MSVC)
     set(OPENSSL_USE_STATIC_LIBS ON)
-endif ()
+endif()
 set(OPENSSL_MSVC_STATIC_RT ON)
 find_dependency(OpenSSL REQUIRED)
 find_dependency(ZLIB)
 find_dependency(date)
-if (TARGET ZLIB::ZLIB)
-    set_target_properties(OpenSSL::Crypto PROPERTIES INTERFACE_LINK_LIBRARIES ZLIB::ZLIB)
-endif ()
+if(TARGET ZLIB::ZLIB)
+    set_target_properties(
+        OpenSSL::Crypto
+        PROPERTIES INTERFACE_LINK_LIBRARIES ZLIB::ZLIB
+    )
+endif()

cmake/XrplCore.cmake

@@ -10,25 +10,44 @@ include(target_protobuf_sources)
 # so we just build them as a separate library.
 add_library(xrpl.libpb)
 set_target_properties(xrpl.libpb PROPERTIES UNITY_BUILD OFF)
-target_protobuf_sources(xrpl.libpb xrpl/proto LANGUAGE cpp IMPORT_DIRS include/xrpl/proto
-                        PROTOS include/xrpl/proto/xrpl.proto)
+target_protobuf_sources(
+    xrpl.libpb
+    xrpl/proto
+    LANGUAGE cpp
+    IMPORT_DIRS include/xrpl/proto
+    PROTOS include/xrpl/proto/xrpl.proto
+)
 
 file(GLOB_RECURSE protos "include/xrpl/proto/org/*.proto")
-target_protobuf_sources(xrpl.libpb xrpl/proto LANGUAGE cpp IMPORT_DIRS include/xrpl/proto
-                        PROTOS "${protos}")
 target_protobuf_sources(
-    xrpl.libpb xrpl/proto
+    xrpl.libpb
+    xrpl/proto
+    LANGUAGE cpp
+    IMPORT_DIRS include/xrpl/proto
+    PROTOS "${protos}"
+)
+target_protobuf_sources(
+    xrpl.libpb
+    xrpl/proto
     LANGUAGE grpc
     IMPORT_DIRS include/xrpl/proto
     PROTOS "${protos}"
     PLUGIN protoc-gen-grpc=$<TARGET_FILE:gRPC::grpc_cpp_plugin>
-    GENERATE_EXTENSIONS .grpc.pb.h .grpc.pb.cc)
+    GENERATE_EXTENSIONS .grpc.pb.h .grpc.pb.cc
+)
 
 target_compile_options(
     xrpl.libpb
-    PUBLIC $<$<BOOL:${is_msvc}>:-wd4996> $<$<BOOL:${is_xcode}>:
-           --system-header-prefix="google/protobuf" -Wno-deprecated-dynamic-exception-spec >
-    PRIVATE $<$<BOOL:${is_msvc}>:-wd4065> $<$<NOT:$<BOOL:${is_msvc}>>:-Wno-deprecated-declarations>)
+    PUBLIC
+        $<$<BOOL:${is_msvc}>:-wd4996>
+        $<$<BOOL:${is_xcode}>:
+        --system-header-prefix="google/protobuf"
+        -Wno-deprecated-dynamic-exception-spec
+        >
+    PRIVATE
+        $<$<BOOL:${is_msvc}>:-wd4065>
+        $<$<NOT:$<BOOL:${is_msvc}>>:-Wno-deprecated-declarations>
+)
 
 target_link_libraries(xrpl.libpb PUBLIC protobuf::libprotobuf gRPC::grpc++)
 
@@ -37,19 +56,21 @@ add_library(xrpl.imports.main INTERFACE)
 
 target_link_libraries(
     xrpl.imports.main
-    INTERFACE absl::random_random
-              date::date
-              ed25519::ed25519
-              LibArchive::LibArchive
-              OpenSSL::Crypto
-              Xrpl::boost
-              Xrpl::libs
-              Xrpl::opts
-              Xrpl::syslibs
-              secp256k1::secp256k1
-              xrpl.libpb
-              xxHash::xxhash
-              $<$<BOOL:${voidstar}>:antithesis-sdk-cpp>)
+    INTERFACE
+        absl::random_random
+        date::date
+        ed25519::ed25519
+        LibArchive::LibArchive
+        OpenSSL::Crypto
+        Xrpl::boost
+        Xrpl::libs
+        Xrpl::opts
+        Xrpl::syslibs
+        secp256k1::secp256k1
+        xrpl.libpb
+        xxHash::xxhash
+        $<$<BOOL:${voidstar}>:antithesis-sdk-cpp>
+)
 
 include(add_module)
 include(target_link_modules)
@@ -58,6 +79,16 @@ 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,36 +102,79 @@ 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)
+target_link_libraries(
+    xrpl.libxrpl.net
+    PUBLIC
+        xrpl.libxrpl.basics
+        xrpl.libxrpl.json
+        xrpl.libxrpl.protocol
+        xrpl.libxrpl.resource
+)
 
 add_module(xrpl nodestore)
-target_link_libraries(xrpl.libxrpl.nodestore PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json
-                                                    xrpl.libxrpl.protocol)
+target_link_libraries(
+    xrpl.libxrpl.nodestore
+    PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json xrpl.libxrpl.protocol
+)
 
 add_module(xrpl shamap)
-target_link_libraries(xrpl.libxrpl.shamap PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.crypto
-                                                 xrpl.libxrpl.protocol xrpl.libxrpl.nodestore)
+target_link_libraries(
+    xrpl.libxrpl.shamap
+    PUBLIC
+        xrpl.libxrpl.basics
+        xrpl.libxrpl.crypto
+        xrpl.libxrpl.protocol
+        xrpl.libxrpl.nodestore
+)
 
 add_module(xrpl rdb)
-target_link_libraries(xrpl.libxrpl.rdb PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.core)
+target_link_libraries(
+    xrpl.libxrpl.rdb
+    PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.core
+)
 
 add_module(xrpl server)
-target_link_libraries(xrpl.libxrpl.server PUBLIC xrpl.libxrpl.protocol xrpl.libxrpl.core
-                                                 xrpl.libxrpl.rdb xrpl.libxrpl.resource)
+target_link_libraries(
+    xrpl.libxrpl.server
+    PUBLIC
+        xrpl.libxrpl.protocol
+        xrpl.libxrpl.core
+        xrpl.libxrpl.rdb
+        xrpl.libxrpl.resource
+)
 
 add_module(xrpl conditions)
 target_link_libraries(xrpl.libxrpl.conditions PUBLIC xrpl.libxrpl.server)
@@ -108,13 +182,16 @@ target_link_libraries(xrpl.libxrpl.conditions PUBLIC xrpl.libxrpl.server)
 add_module(xrpl ledger)
 target_link_libraries(
     xrpl.libxrpl.ledger
-    PUBLIC xrpl.libxrpl.basics
-           xrpl.libxrpl.json
-           xrpl.libxrpl.protocol
-           xrpl.libxrpl.rdb
-           xrpl.libxrpl.server
-           xrpl.libxrpl.shamap
-           xrpl.libxrpl.conditions)
+    PUBLIC
+        xrpl.libxrpl.basics
+        xrpl.libxrpl.json
+        xrpl.libxrpl.protocol
+        xrpl.libxrpl.protocol_autogen
+        xrpl.libxrpl.rdb
+        xrpl.libxrpl.server
+        xrpl.libxrpl.shamap
+        xrpl.libxrpl.conditions
+)
 
 add_module(xrpl tx)
 target_link_libraries(xrpl.libxrpl.tx PUBLIC xrpl.libxrpl.ledger)
@@ -124,7 +201,11 @@ set_target_properties(xrpl.libxrpl PROPERTIES OUTPUT_NAME xrpl)
 
 add_library(xrpl::libxrpl ALIAS xrpl.libxrpl)
 
-file(GLOB_RECURSE sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/libxrpl/*.cpp")
+file(
+    GLOB_RECURSE sources
+    CONFIGURE_DEPENDS
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/libxrpl/*.cpp"
+)
 target_sources(xrpl.libxrpl PRIVATE ${sources})
 
 target_link_modules(
@@ -135,16 +216,19 @@ target_link_modules(
     conditions
     core
     crypto
+    git
     json
     ledger
     net
     nodestore
     protocol
+    protocol_autogen
     rdb
     resource
     server
     shamap
-    tx)
+    tx
+)
 
 # All headers in libxrpl are in modules.
 # Uncomment this stanza if you have not yet moved new headers into a module.
@@ -155,34 +239,51 @@ target_link_modules(
 #     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
 #     $<INSTALL_INTERFACE:include>)
 
-if (xrpld)
+if(xrpld)
     add_executable(xrpld)
-    if (tests)
+    if(tests)
         target_compile_definitions(xrpld PUBLIC ENABLE_TESTS)
-        target_compile_definitions(xrpld PRIVATE UNIT_TEST_REFERENCE_FEE=${UNIT_TEST_REFERENCE_FEE})
-    endif ()
-    target_include_directories(xrpld PRIVATE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>)
+        target_compile_definitions(
+            xrpld
+            PRIVATE UNIT_TEST_REFERENCE_FEE=${UNIT_TEST_REFERENCE_FEE}
+        )
+    endif()
+    target_include_directories(
+        xrpld
+        PRIVATE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
+    )
 
-    file(GLOB_RECURSE sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/xrpld/*.cpp")
+    file(
+        GLOB_RECURSE sources
+        CONFIGURE_DEPENDS
+        "${CMAKE_CURRENT_SOURCE_DIR}/src/xrpld/*.cpp"
+    )
     target_sources(xrpld PRIVATE ${sources})
 
-    if (tests)
-        file(GLOB_RECURSE sources CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/src/test/*.cpp")
+    if(tests)
+        file(
+            GLOB_RECURSE sources
+            CONFIGURE_DEPENDS
+            "${CMAKE_CURRENT_SOURCE_DIR}/src/test/*.cpp"
+        )
         target_sources(xrpld PRIVATE ${sources})
-    endif ()
+    endif()
 
     target_link_libraries(xrpld Xrpl::boost Xrpl::opts Xrpl::libs xrpl.libxrpl)
     exclude_if_included(xrpld)
     # define a macro for tests that might need to
     # be excluded or run differently in CI environment
-    if (is_ci)
+    if(is_ci)
         target_compile_definitions(xrpld PRIVATE XRPL_RUNNING_IN_CI)
-    endif ()
+    endif()
 
-    if (voidstar)
+    if(voidstar)
         target_compile_options(xrpld PRIVATE -fsanitize-coverage=trace-pc-guard)
         # xrpld requires access to antithesis-sdk-cpp implementation file
         # antithesis_instrumentation.h, which is not exported as INTERFACE
-        target_include_directories(xrpld PRIVATE ${CMAKE_SOURCE_DIR}/external/antithesis-sdk)
-    endif ()
-endif ()
+        target_include_directories(
+            xrpld
+            PRIVATE ${CMAKE_SOURCE_DIR}/external/antithesis-sdk
+        )
+    endif()
+endif()

cmake/XrplCov.cmake

@@ -2,14 +2,17 @@
    coverage report target
 #]===================================================================]
 
-if (NOT coverage)
+if(NOT coverage)
     message(FATAL_ERROR "Code coverage not enabled! Aborting ...")
-endif ()
+endif()
 
-if (CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
-    message(WARNING "Code coverage on Windows is not supported, ignoring 'coverage' flag")
+if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+    message(
+        WARNING
+        "Code coverage on Windows is not supported, ignoring 'coverage' flag"
+    )
     return()
-endif ()
+endif()
 
 include(ProcessorCount)
 ProcessorCount(PROCESSOR_COUNT)
@@ -21,32 +24,30 @@ include(CodeCoverage)
 # `CodeCoverage.cmake`)
 
 set(GCOVR_ADDITIONAL_ARGS ${coverage_extra_args})
-if (NOT GCOVR_ADDITIONAL_ARGS STREQUAL "")
+if(NOT GCOVR_ADDITIONAL_ARGS STREQUAL "")
     separate_arguments(GCOVR_ADDITIONAL_ARGS)
-endif ()
+endif()
 
-list(APPEND
-     GCOVR_ADDITIONAL_ARGS
-     --exclude-throw-branches
-     --exclude-noncode-lines
-     --exclude-unreachable-branches
-     -s
-     -j
-     ${PROCESSOR_COUNT})
+list(
+    APPEND GCOVR_ADDITIONAL_ARGS
+    --exclude-throw-branches
+    --exclude-noncode-lines
+    --exclude-unreachable-branches
+    -s
+    -j
+    ${PROCESSOR_COUNT}
+)
 
 setup_target_for_coverage_gcovr(
-    NAME
-    coverage
-    FORMAT
-    ${coverage_format}
+    NAME coverage
+    FORMAT ${coverage_format}
     EXCLUDE
-    "src/test"
-    "src/tests"
-    "include/xrpl/beast/test"
-    "include/xrpl/beast/unit_test"
-    "${CMAKE_BINARY_DIR}/pb-xrpl.libpb"
-    DEPENDENCIES
-    xrpld
-    xrpl.tests)
+        "src/test"
+        "src/tests"
+        "include/xrpl/beast/test"
+        "include/xrpl/beast/unit_test"
+        "${CMAKE_BINARY_DIR}/pb-xrpl.libpb"
+    DEPENDENCIES xrpld xrpl.tests
+)
 
 add_code_coverage_to_target(opts INTERFACE)

cmake/XrplDocs.cmake

@@ -2,71 +2,90 @@
    docs target (optional)
 #]===================================================================]
 
-if (NOT only_docs)
+if(NOT only_docs)
     return()
-endif ()
+endif()
 
 find_package(Doxygen)
-if (NOT TARGET Doxygen::doxygen)
+if(NOT TARGET Doxygen::doxygen)
     message(STATUS "doxygen executable not found -- skipping docs target")
     return()
-endif ()
+endif()
 
 set(doxygen_output_directory "${CMAKE_BINARY_DIR}/docs")
 set(doxygen_include_path "${CMAKE_CURRENT_SOURCE_DIR}/src")
 set(doxygen_index_file "${doxygen_output_directory}/html/index.html")
 set(doxyfile "${CMAKE_CURRENT_SOURCE_DIR}/docs/Doxyfile")
 
-file(GLOB_RECURSE
-     doxygen_input
-     docs/*.md
-     include/*.h
-     include/*.cpp
-     include/*.md
-     src/*.h
-     src/*.cpp
-     src/*.md
-     Builds/*.md
-     *.md)
+file(
+    GLOB_RECURSE doxygen_input
+    docs/*.md
+    include/*.h
+    include/*.cpp
+    include/*.md
+    src/*.h
+    src/*.cpp
+    src/*.md
+    Builds/*.md
+    *.md
+)
 list(APPEND doxygen_input external/README.md)
 set(dependencies "${doxygen_input}" "${doxyfile}")
 
-function (verbose_find_path variable name)
+function(verbose_find_path variable name)
     # find_path sets a CACHE variable, so don't try using a "local" variable.
     find_path(${variable} "${name}" ${ARGN})
-    if (NOT ${variable})
+    if(NOT ${variable})
         message(NOTICE "could not find ${name}")
-    else ()
+    else()
         message(STATUS "found ${name}: ${${variable}}/${name}")
-    endif ()
-endfunction ()
+    endif()
+endfunction()
 
-verbose_find_path(doxygen_plantuml_jar_path plantuml.jar PATH_SUFFIXES share/plantuml)
+verbose_find_path(
+    doxygen_plantuml_jar_path
+    plantuml.jar
+    PATH_SUFFIXES share/plantuml
+)
 verbose_find_path(doxygen_dot_path dot)
 
 # https://en.cppreference.com/w/Cppreference:Archives
 # https://stackoverflow.com/questions/60822559/how-to-move-a-file-download-from-configure-step-to-build-step
 set(download_script "${CMAKE_BINARY_DIR}/docs/download-cppreference.cmake")
-file(WRITE "${download_script}"
-     "file(DOWNLOAD \
+file(
+    WRITE "${download_script}"
+    "file(DOWNLOAD \
     https://github.com/PeterFeicht/cppreference-doc/releases/download/v20250209/html-book-20250209.zip \
     ${CMAKE_BINARY_DIR}/docs/cppreference.zip \
     EXPECTED_HASH MD5=bda585f72fbca4b817b29a3d5746567b \
   )\n \
   execute_process( \
     COMMAND \"${CMAKE_COMMAND}\" -E tar -xf cppreference.zip \
-  )\n")
+  )\n"
+)
 set(tagfile "${CMAKE_BINARY_DIR}/docs/cppreference-doxygen-web.tag.xml")
-add_custom_command(OUTPUT "${tagfile}" COMMAND "${CMAKE_COMMAND}" -P "${download_script}"
-                   WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/docs")
+add_custom_command(
+    OUTPUT "${tagfile}"
+    COMMAND "${CMAKE_COMMAND}" -P "${download_script}"
+    WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/docs"
+)
 set(doxygen_tagfiles "${tagfile}=http://en.cppreference.com/w/")
 
 add_custom_command(
     OUTPUT "${doxygen_index_file}"
-    COMMAND "${CMAKE_COMMAND}" -E env "DOXYGEN_OUTPUT_DIRECTORY=${doxygen_output_directory}"
-            "DOXYGEN_INCLUDE_PATH=${doxygen_include_path}" "DOXYGEN_TAGFILES=${doxygen_tagfiles}"
-            "DOXYGEN_PLANTUML_JAR_PATH=${doxygen_plantuml_jar_path}"
-            "DOXYGEN_DOT_PATH=${doxygen_dot_path}" "${DOXYGEN_EXECUTABLE}" "${doxyfile}"
+    COMMAND
+        "${CMAKE_COMMAND}" -E env
+        "DOXYGEN_OUTPUT_DIRECTORY=${doxygen_output_directory}"
+        "DOXYGEN_INCLUDE_PATH=${doxygen_include_path}"
+        "DOXYGEN_TAGFILES=${doxygen_tagfiles}"
+        "DOXYGEN_PLANTUML_JAR_PATH=${doxygen_plantuml_jar_path}"
+        "DOXYGEN_DOT_PATH=${doxygen_dot_path}" "${DOXYGEN_EXECUTABLE}"
+        "${doxyfile}"
     WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-    DEPENDS "${dependencies}" "${tagfile}")
-add_custom_target(docs DEPENDS "${doxygen_index_file}" SOURCES "${dependencies}")
+    DEPENDS "${dependencies}" "${tagfile}"
+)
+add_custom_target(
+    docs
+    DEPENDS "${doxygen_index_file}"
+    SOURCES "${dependencies}"
+)

cmake/XrplInstall.cmake

@@ -6,56 +6,72 @@ include(create_symbolic_link)
 
 # If no suffix is defined for executables (e.g. Windows uses .exe but Linux
 # and macOS use none), then explicitly set it to the empty string.
-if (NOT DEFINED suffix)
+if(NOT DEFINED suffix)
     set(suffix "")
-endif ()
+endif()
 
-install(TARGETS common
-                opts
-                xrpl_boost
-                xrpl_libs
-                xrpl_syslibs
-                xrpl.imports.main
-                xrpl.libpb
-                xrpl.libxrpl
-                xrpl.libxrpl.basics
-                xrpl.libxrpl.beast
-                xrpl.libxrpl.conditions
-                xrpl.libxrpl.core
-                xrpl.libxrpl.crypto
-                xrpl.libxrpl.json
-                xrpl.libxrpl.rdb
-                xrpl.libxrpl.ledger
-                xrpl.libxrpl.net
-                xrpl.libxrpl.nodestore
-                xrpl.libxrpl.protocol
-                xrpl.libxrpl.resource
-                xrpl.libxrpl.server
-                xrpl.libxrpl.shamap
-                xrpl.libxrpl.tx
-                antithesis-sdk-cpp
-        EXPORT XrplExports
-        LIBRARY DESTINATION lib
-        ARCHIVE DESTINATION lib
-        RUNTIME DESTINATION bin
-        INCLUDES
-        DESTINATION include)
+install(
+    TARGETS
+        common
+        opts
+        xrpl_boost
+        xrpl_libs
+        xrpl_syslibs
+        xrpl.imports.main
+        xrpl.libpb
+        xrpl.libxrpl
+        xrpl.libxrpl.basics
+        xrpl.libxrpl.beast
+        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
+        xrpl.libxrpl.tx
+        antithesis-sdk-cpp
+    EXPORT XrplExports
+    LIBRARY DESTINATION lib
+    ARCHIVE DESTINATION lib
+    RUNTIME DESTINATION bin
+    INCLUDES DESTINATION include
+)
 
-install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/xrpl"
-        DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
+install(
+    DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/include/xrpl"
+    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+)
 
-install(EXPORT XrplExports FILE XrplTargets.cmake NAMESPACE Xrpl:: DESTINATION lib/cmake/xrpl)
+install(
+    EXPORT XrplExports
+    FILE XrplTargets.cmake
+    NAMESPACE Xrpl::
+    DESTINATION lib/cmake/xrpl
+)
 include(CMakePackageConfigHelpers)
-write_basic_package_version_file(XrplConfigVersion.cmake VERSION ${xrpld_version}
-                                 COMPATIBILITY SameMajorVersion)
+write_basic_package_version_file(
+    XrplConfigVersion.cmake
+    VERSION ${xrpld_version}
+    COMPATIBILITY SameMajorVersion
+)
 
-if (is_root_project AND TARGET xrpld)
+if(is_root_project AND TARGET xrpld)
     install(TARGETS xrpld RUNTIME DESTINATION bin)
     set_target_properties(xrpld PROPERTIES INSTALL_RPATH_USE_LINK_PATH ON)
     # sample configs should not overwrite existing files
     # install if-not-exists workaround as suggested by
     # https://cmake.org/Bug/view.php?id=12646
-    install(CODE "
+    install(
+        CODE
+            "
     macro (copy_if_not_exists SRC DEST NEWNAME)
       if (NOT EXISTS \"\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/\${DEST}/\${NEWNAME}\")
         file (INSTALL FILE_PERMISSIONS OWNER_READ OWNER_WRITE DESTINATION \"\${CMAKE_INSTALL_PREFIX}/\${DEST}\" FILES \"\${SRC}\" RENAME \"\${NEWNAME}\")
@@ -65,14 +81,22 @@ if (is_root_project AND TARGET xrpld)
     endmacro()
     copy_if_not_exists(\"${CMAKE_CURRENT_SOURCE_DIR}/cfg/xrpld-example.cfg\" etc xrpld.cfg)
     copy_if_not_exists(\"${CMAKE_CURRENT_SOURCE_DIR}/cfg/validators-example.txt\" etc validators.txt)
-  ")
-    install(CODE "
+  "
+    )
+    install(
+        CODE
+            "
     set(CMAKE_MODULE_PATH \"${CMAKE_MODULE_PATH}\")
     include(create_symbolic_link)
     create_symbolic_link(xrpld${suffix} \
        \$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_BINDIR}/rippled${suffix})
-  ")
-endif ()
+  "
+    )
+endif()
 
-install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/cmake/XrplConfig.cmake
-              ${CMAKE_CURRENT_BINARY_DIR}/XrplConfigVersion.cmake DESTINATION lib/cmake/xrpl)
+install(
+    FILES
+        ${CMAKE_CURRENT_SOURCE_DIR}/cmake/XrplConfig.cmake
+        ${CMAKE_CURRENT_BINARY_DIR}/XrplConfigVersion.cmake
+    DESTINATION lib/cmake/xrpl
+)

cmake/XrplInterface.cmake

@@ -5,47 +5,55 @@
 include(CompilationEnv)
 
 # Set defaults for optional variables to avoid uninitialized variable warnings
-if (NOT DEFINED voidstar)
+if(NOT DEFINED voidstar)
     set(voidstar OFF)
-endif ()
+endif()
 
 add_library(opts INTERFACE)
 add_library(Xrpl::opts ALIAS opts)
 target_compile_definitions(
     opts
-    INTERFACE BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS
-              BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT
-              BOOST_CONTAINER_FWD_BAD_DEQUE
-              HAS_UNCAUGHT_EXCEPTIONS=1
-              $<$<BOOL:${boost_show_deprecated}>:
-              BOOST_ASIO_NO_DEPRECATED
-              BOOST_FILESYSTEM_NO_DEPRECATED
-              >
-              $<$<NOT:$<BOOL:${boost_show_deprecated}>>:
-              BOOST_COROUTINES_NO_DEPRECATION_WARNING
-              BOOST_BEAST_ALLOW_DEPRECATED
-              BOOST_FILESYSTEM_DEPRECATED
-              >
-              $<$<BOOL:${beast_no_unit_test_inline}>:BEAST_NO_UNIT_TEST_INLINE=1>
-              $<$<BOOL:${beast_disable_autolink}>:BEAST_DONT_AUTOLINK_TO_WIN32_LIBRARIES=1>
-              $<$<BOOL:${single_io_service_thread}>:XRPL_SINGLE_IO_SERVICE_THREAD=1>
-              $<$<BOOL:${voidstar}>:ENABLE_VOIDSTAR>)
+    INTERFACE
+        BOOST_ASIO_DISABLE_HANDLER_TYPE_REQUIREMENTS
+        BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT
+        BOOST_CONTAINER_FWD_BAD_DEQUE
+        HAS_UNCAUGHT_EXCEPTIONS=1
+        $<$<BOOL:${boost_show_deprecated}>:
+        BOOST_ASIO_NO_DEPRECATED
+        BOOST_FILESYSTEM_NO_DEPRECATED
+        >
+        $<$<NOT:$<BOOL:${boost_show_deprecated}>>:
+        BOOST_COROUTINES_NO_DEPRECATION_WARNING
+        BOOST_BEAST_ALLOW_DEPRECATED
+        BOOST_FILESYSTEM_DEPRECATED
+        >
+        $<$<BOOL:${beast_no_unit_test_inline}>:BEAST_NO_UNIT_TEST_INLINE=1>
+        $<$<BOOL:${beast_disable_autolink}>:BEAST_DONT_AUTOLINK_TO_WIN32_LIBRARIES=1>
+        $<$<BOOL:${single_io_service_thread}>:XRPL_SINGLE_IO_SERVICE_THREAD=1>
+        $<$<BOOL:${voidstar}>:ENABLE_VOIDSTAR>
+)
 target_compile_options(
     opts
-    INTERFACE $<$<AND:$<BOOL:${is_gcc}>,$<COMPILE_LANGUAGE:CXX>>:-Wsuggest-override>
-              $<$<BOOL:${is_gcc}>:-Wno-maybe-uninitialized>
-              $<$<BOOL:${perf}>:-fno-omit-frame-pointer>
-              $<$<BOOL:${profile}>:-pg>
-              $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
+    INTERFACE
+        $<$<AND:$<BOOL:${is_gcc}>,$<COMPILE_LANGUAGE:CXX>>:-Wsuggest-override>
+        $<$<BOOL:${is_gcc}>:-Wno-maybe-uninitialized>
+        $<$<BOOL:${perf}>:-fno-omit-frame-pointer>
+        $<$<BOOL:${profile}>:-pg>
+        $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>
+)
 
-target_link_libraries(opts INTERFACE $<$<BOOL:${profile}>:-pg>
-                                     $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
+target_link_libraries(
+    opts
+    INTERFACE
+        $<$<BOOL:${profile}>:-pg>
+        $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>
+)
 
-if (jemalloc)
+if(jemalloc)
     find_package(jemalloc REQUIRED)
     target_compile_definitions(opts INTERFACE PROFILE_JEMALLOC)
     target_link_libraries(opts INTERFACE jemalloc::jemalloc)
-endif ()
+endif()
 
 #[===================================================================[
    xrpld transitive library deps via an interface library
@@ -55,31 +63,33 @@ add_library(xrpl_syslibs INTERFACE)
 add_library(Xrpl::syslibs ALIAS xrpl_syslibs)
 target_link_libraries(
     xrpl_syslibs
-    INTERFACE $<$<BOOL:${is_msvc}>:
-              legacy_stdio_definitions.lib
-              Shlwapi
-              kernel32
-              user32
-              gdi32
-              winspool
-              comdlg32
-              advapi32
-              shell32
-              ole32
-              oleaut32
-              uuid
-              odbc32
-              odbccp32
-              crypt32
-              >
-              $<$<NOT:$<BOOL:${is_msvc}>>:dl>
-              $<$<NOT:$<OR:$<BOOL:${is_msvc}>,$<BOOL:${is_macos}>>>:rt>)
+    INTERFACE
+        $<$<BOOL:${is_msvc}>:
+        legacy_stdio_definitions.lib
+        Shlwapi
+        kernel32
+        user32
+        gdi32
+        winspool
+        comdlg32
+        advapi32
+        shell32
+        ole32
+        oleaut32
+        uuid
+        odbc32
+        odbccp32
+        crypt32
+        >
+        $<$<NOT:$<BOOL:${is_msvc}>>:dl>
+        $<$<NOT:$<OR:$<BOOL:${is_msvc}>,$<BOOL:${is_macos}>>>:rt>
+)
 
-if (NOT is_msvc)
+if(NOT is_msvc)
     set(THREADS_PREFER_PTHREAD_FLAG ON)
     find_package(Threads)
     target_link_libraries(xrpl_syslibs INTERFACE Threads::Threads)
-endif ()
+endif()
 
 add_library(xrpl_libs INTERFACE)
 add_library(Xrpl::libs ALIAS xrpl_libs)

cmake/XrplProtocolAutogen.cmake

@@ -0,0 +1,214 @@
+#[===================================================================[
+   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(AUTOGEN_TEST_DIR
+        "${CMAKE_CURRENT_SOURCE_DIR}/src/tests/libxrpl/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")
+    file(MAKE_DIRECTORY "${AUTOGEN_TEST_DIR}/ledger_objects")
+    file(MAKE_DIRECTORY "${AUTOGEN_TEST_DIR}/transactions")
+
+    # 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 and tests 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" --test-dir
+            "${AUTOGEN_TEST_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 and tests 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" --test-dir
+            "${AUTOGEN_TEST_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/TransactionTests.cpp.mako"
+                "${SCRIPTS_DIR}/templates/LedgerEntry.h.mako"
+                "${SCRIPTS_DIR}/templates/LedgerEntryTests.cpp.mako"
+                "${REQUIREMENTS_FILE}"
+    )
+endfunction()

cmake/XrplSanitizers.cmake

@@ -44,23 +44,26 @@ include(CompilationEnv)
 
 # Read environment variable
 set(SANITIZERS "")
-if (DEFINED ENV{SANITIZERS})
+if(DEFINED ENV{SANITIZERS})
     set(SANITIZERS "$ENV{SANITIZERS}")
-endif ()
+endif()
 
 # Set SANITIZERS_ENABLED flag for use in other modules
-if (SANITIZERS MATCHES "address|thread|undefinedbehavior")
+if(SANITIZERS MATCHES "address|thread|undefinedbehavior")
     set(SANITIZERS_ENABLED TRUE)
-else ()
+else()
     set(SANITIZERS_ENABLED FALSE)
     return()
-endif ()
+endif()
 
 # Sanitizers are not supported on Windows/MSVC
-if (is_msvc)
-    message(FATAL_ERROR "Sanitizers are not supported on Windows/MSVC. "
-                        "Please unset the SANITIZERS environment variable.")
-endif ()
+if(is_msvc)
+    message(
+        FATAL_ERROR
+        "Sanitizers are not supported on Windows/MSVC. "
+        "Please unset the SANITIZERS environment variable."
+    )
+endif()
 
 message(STATUS "Configuring sanitizers: ${SANITIZERS}")
 
@@ -74,24 +77,30 @@ set(san_list "${SANITIZERS}")
 string(REPLACE "," ";" san_list "${san_list}")
 separate_arguments(san_list)
 
-foreach (san IN LISTS san_list)
-    if (san STREQUAL "address")
+foreach(san IN LISTS san_list)
+    if(san STREQUAL "address")
         set(enable_asan TRUE)
-    elseif (san STREQUAL "thread")
+    elseif(san STREQUAL "thread")
         set(enable_tsan TRUE)
-    elseif (san STREQUAL "undefinedbehavior")
+    elseif(san STREQUAL "undefinedbehavior")
         set(enable_ubsan TRUE)
-    else ()
-        message(FATAL_ERROR "Unsupported sanitizer type: ${san}"
-                            "Supported: address, thread, undefinedbehavior and their combinations.")
-    endif ()
-endforeach ()
+    else()
+        message(
+            FATAL_ERROR
+            "Unsupported sanitizer type: ${san}"
+            "Supported: address, thread, undefinedbehavior and their combinations."
+        )
+    endif()
+endforeach()
 
 # Validate sanitizer compatibility
-if (enable_asan AND enable_tsan)
-    message(FATAL_ERROR "AddressSanitizer and ThreadSanitizer are incompatible and cannot be enabled simultaneously. "
-                        "Use 'address' or 'thread', optionally with 'undefinedbehavior'.")
-endif ()
+if(enable_asan AND enable_tsan)
+    message(
+        FATAL_ERROR
+        "AddressSanitizer and ThreadSanitizer are incompatible and cannot be enabled simultaneously. "
+        "Use 'address' or 'thread', optionally with 'undefinedbehavior'."
+    )
+endif()
 
 # Frame pointer is required for meaningful stack traces. Sanitizers recommend minimum of -O1 for reasonable performance
 set(SANITIZERS_COMPILE_FLAGS "-fno-omit-frame-pointer" "-O1")
@@ -99,66 +108,79 @@ set(SANITIZERS_COMPILE_FLAGS "-fno-omit-frame-pointer" "-O1")
 # Build the sanitizer flags list
 set(SANITIZER_TYPES)
 
-if (enable_asan)
+if(enable_asan)
     list(APPEND SANITIZER_TYPES "address")
-elseif (enable_tsan)
+elseif(enable_tsan)
     list(APPEND SANITIZER_TYPES "thread")
-endif ()
+endif()
 
-if (enable_ubsan)
+if(enable_ubsan)
     # UB sanitizer flags
     list(APPEND SANITIZER_TYPES "undefined" "float-divide-by-zero")
-    if (is_clang)
+    if(is_clang)
         # Clang supports additional UB checks. More info here
         # https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html
         list(APPEND SANITIZER_TYPES "unsigned-integer-overflow")
-    endif ()
-endif ()
+    endif()
+endif()
 
 # Configure code model for GCC on amd64 Use large code model for ASAN to avoid relocation errors Use medium code model
 # for TSAN (large is not compatible with TSAN)
 set(SANITIZERS_RELOCATION_FLAGS)
 
 # Compiler-specific configuration
-if (is_gcc)
+if(is_gcc)
     # Disable mold, gold and lld linkers for GCC with sanitizers Use default linker (bfd/ld) which is more lenient with
     # mixed code models This is needed since the size of instrumented binary exceeds the limits set by mold, lld and
     # gold linkers
     set(use_mold OFF CACHE BOOL "Use mold linker" FORCE)
     set(use_gold OFF CACHE BOOL "Use gold linker" FORCE)
     set(use_lld OFF CACHE BOOL "Use lld linker" FORCE)
-    message(STATUS "  Disabled mold, gold, and lld linkers for GCC with sanitizers")
+    message(
+        STATUS
+        "  Disabled mold, gold, and lld linkers for GCC with sanitizers"
+    )
 
     # Suppress false positive warnings in GCC with stringop-overflow
     list(APPEND SANITIZERS_COMPILE_FLAGS "-Wno-stringop-overflow")
 
-    if (is_amd64 AND enable_asan)
+    if(is_amd64 AND enable_asan)
         message(STATUS "  Using large code model (-mcmodel=large)")
         list(APPEND SANITIZERS_COMPILE_FLAGS "-mcmodel=large")
         list(APPEND SANITIZERS_RELOCATION_FLAGS "-mcmodel=large")
-    elseif (enable_tsan)
+    elseif(enable_tsan)
         # GCC doesn't support atomic_thread_fence with tsan. Suppress warnings.
         list(APPEND SANITIZERS_COMPILE_FLAGS "-Wno-tsan")
         message(STATUS "  Using medium code model (-mcmodel=medium)")
         list(APPEND SANITIZERS_COMPILE_FLAGS "-mcmodel=medium")
         list(APPEND SANITIZERS_RELOCATION_FLAGS "-mcmodel=medium")
-    endif ()
+    endif()
 
     # Join sanitizer flags with commas for -fsanitize option
     list(JOIN SANITIZER_TYPES "," SANITIZER_TYPES_STR)
 
     # Add sanitizer to compile and link flags
     list(APPEND SANITIZERS_COMPILE_FLAGS "-fsanitize=${SANITIZER_TYPES_STR}")
-    set(SANITIZERS_LINK_FLAGS "${SANITIZERS_RELOCATION_FLAGS}" "-fsanitize=${SANITIZER_TYPES_STR}")
-
-elseif (is_clang)
+    set(SANITIZERS_LINK_FLAGS
+        "${SANITIZERS_RELOCATION_FLAGS}"
+        "-fsanitize=${SANITIZER_TYPES_STR}"
+    )
+elseif(is_clang)
     # Add ignorelist for Clang (GCC doesn't support this) Use CMAKE_SOURCE_DIR to get the path to the ignorelist
-    set(IGNORELIST_PATH "${CMAKE_SOURCE_DIR}/sanitizers/suppressions/sanitizer-ignorelist.txt")
-    if (NOT EXISTS "${IGNORELIST_PATH}")
-        message(FATAL_ERROR "Sanitizer ignorelist not found: ${IGNORELIST_PATH}")
-    endif ()
+    set(IGNORELIST_PATH
+        "${CMAKE_SOURCE_DIR}/sanitizers/suppressions/sanitizer-ignorelist.txt"
+    )
+    if(NOT EXISTS "${IGNORELIST_PATH}")
+        message(
+            FATAL_ERROR
+            "Sanitizer ignorelist not found: ${IGNORELIST_PATH}"
+        )
+    endif()
 
-    list(APPEND SANITIZERS_COMPILE_FLAGS "-fsanitize-ignorelist=${IGNORELIST_PATH}")
+    list(
+        APPEND SANITIZERS_COMPILE_FLAGS
+        "-fsanitize-ignorelist=${IGNORELIST_PATH}"
+    )
     message(STATUS "  Using sanitizer ignorelist: ${IGNORELIST_PATH}")
 
     # Join sanitizer flags with commas for -fsanitize option
@@ -167,31 +189,35 @@ elseif (is_clang)
     # Add sanitizer to compile and link flags
     list(APPEND SANITIZERS_COMPILE_FLAGS "-fsanitize=${SANITIZER_TYPES_STR}")
     set(SANITIZERS_LINK_FLAGS "-fsanitize=${SANITIZER_TYPES_STR}")
-endif ()
+endif()
 
 message(STATUS "  Compile flags: ${SANITIZERS_COMPILE_FLAGS}")
 message(STATUS "  Link flags: ${SANITIZERS_LINK_FLAGS}")
 
 # Apply the sanitizer flags to the 'common' interface library This is the same library used by XrplCompiler.cmake
-target_compile_options(common INTERFACE $<$<COMPILE_LANGUAGE:CXX>:${SANITIZERS_COMPILE_FLAGS}>
-                                        $<$<COMPILE_LANGUAGE:C>:${SANITIZERS_COMPILE_FLAGS}>)
+target_compile_options(
+    common
+    INTERFACE
+        $<$<COMPILE_LANGUAGE:CXX>:${SANITIZERS_COMPILE_FLAGS}>
+        $<$<COMPILE_LANGUAGE:C>:${SANITIZERS_COMPILE_FLAGS}>
+)
 
 # Apply linker flags
 target_link_options(common INTERFACE ${SANITIZERS_LINK_FLAGS})
 
 # Define SANITIZERS macro for BuildInfo.cpp
 set(sanitizers_list)
-if (enable_asan)
+if(enable_asan)
     list(APPEND sanitizers_list "ASAN")
-endif ()
-if (enable_tsan)
+endif()
+if(enable_tsan)
     list(APPEND sanitizers_list "TSAN")
-endif ()
-if (enable_ubsan)
+endif()
+if(enable_ubsan)
     list(APPEND sanitizers_list "UBSAN")
-endif ()
+endif()
 
-if (sanitizers_list)
+if(sanitizers_list)
     list(JOIN sanitizers_list "." sanitizers_str)
     target_compile_definitions(common INTERFACE SANITIZERS=${sanitizers_str})
-endif ()
+endif()

cmake/XrplSanity.cmake

@@ -7,40 +7,49 @@ include(CompilationEnv)
 get_property(is_multiconfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
 
 set(CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING "" FORCE)
-if (NOT is_multiconfig)
-    if (NOT CMAKE_BUILD_TYPE)
+if(NOT is_multiconfig)
+    if(NOT CMAKE_BUILD_TYPE)
         message(STATUS "Build type not specified - defaulting to Release")
         set(CMAKE_BUILD_TYPE Release CACHE STRING "build type" FORCE)
-    elseif (NOT (CMAKE_BUILD_TYPE STREQUAL Debug OR CMAKE_BUILD_TYPE STREQUAL Release))
+    elseif(
+        NOT (CMAKE_BUILD_TYPE STREQUAL Debug OR CMAKE_BUILD_TYPE STREQUAL Release)
+    )
         # for simplicity, these are the only two config types we care about. Limiting the build types simplifies dealing
         # with external project builds especially
-        message(FATAL_ERROR " *** Only Debug or Release build types are currently supported ***")
-    endif ()
-endif ()
+        message(
+            FATAL_ERROR
+            " *** Only Debug or Release build types are currently supported ***"
+        )
+    endif()
+endif()
 
-if (is_clang) # both Clang and AppleClang
-    if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS
-                                                        16.0)
+if(is_clang) # both Clang and AppleClang
+    if(
+        "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang"
+        AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 16.0
+    )
         message(FATAL_ERROR "This project requires clang 16 or later")
-    endif ()
-elseif (is_gcc)
-    if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12.0)
+    endif()
+elseif(is_gcc)
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 12.0)
         message(FATAL_ERROR "This project requires GCC 12 or later")
-    endif ()
-endif ()
+    endif()
+endif()
 
 # check for in-source build and fail
-if ("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")
-    message(FATAL_ERROR "Builds (in-source) are not allowed in "
-                        "${CMAKE_CURRENT_SOURCE_DIR}. Please remove CMakeCache.txt and the CMakeFiles "
-                        "directory from ${CMAKE_CURRENT_SOURCE_DIR} and try building in a separate directory."
+if("${CMAKE_CURRENT_SOURCE_DIR}" STREQUAL "${CMAKE_BINARY_DIR}")
+    message(
+        FATAL_ERROR
+        "Builds (in-source) are not allowed in "
+        "${CMAKE_CURRENT_SOURCE_DIR}. Please remove CMakeCache.txt and the CMakeFiles "
+        "directory from ${CMAKE_CURRENT_SOURCE_DIR} and try building in a separate directory."
     )
-endif ()
+endif()
 
-if (MSVC AND CMAKE_GENERATOR_PLATFORM STREQUAL "Win32")
+if(MSVC AND CMAKE_GENERATOR_PLATFORM STREQUAL "Win32")
     message(FATAL_ERROR "Visual Studio 32-bit build is not supported.")
-endif ()
+endif()
 
-if (APPLE AND NOT HOMEBREW)
+if(APPLE AND NOT HOMEBREW)
     find_program(HOMEBREW brew)
-endif ()
+endif()

cmake/XrplSettings.cmake

@@ -5,59 +5,67 @@
 include(CompilationEnv)
 
 set(is_ci FALSE)
-if (DEFINED ENV{CI})
-    if ("$ENV{CI}" STREQUAL "true")
+if(DEFINED ENV{CI})
+    if("$ENV{CI}" STREQUAL "true")
         set(is_ci TRUE)
-    endif ()
-endif ()
+    endif()
+endif()
 
 get_directory_property(has_parent PARENT_DIRECTORY)
-if (has_parent)
+if(has_parent)
     set(is_root_project OFF)
-else ()
+else()
     set(is_root_project ON)
-endif ()
+endif()
 
 option(assert "Enables asserts, even in release builds" OFF)
 
 option(xrpld "Build xrpld" ON)
 
 option(tests "Build tests" ON)
-if (tests)
+if(tests)
     # This setting allows making a separate workflow to test fees other than default 10
-    if (NOT UNIT_TEST_REFERENCE_FEE)
+    if(NOT UNIT_TEST_REFERENCE_FEE)
         set(UNIT_TEST_REFERENCE_FEE "10" CACHE STRING "")
-    endif ()
-endif ()
+    endif()
+endif()
 
 option(unity "Creates a build using UNITY support in cmake." OFF)
-if (unity)
-    if (NOT is_ci)
+if(unity)
+    if(NOT is_ci)
         set(CMAKE_UNITY_BUILD_BATCH_SIZE 15 CACHE STRING "")
-    endif ()
+    endif()
     set(CMAKE_UNITY_BUILD ON CACHE BOOL "Do a unity build")
-endif ()
+endif()
 
-if (is_clang AND is_linux)
+if(is_clang AND is_linux)
     option(voidstar "Enable Antithesis instrumentation." OFF)
-endif ()
+endif()
 
-if (is_gcc OR is_clang)
+if(is_gcc OR is_clang)
     include(ProcessorCount)
     ProcessorCount(PROCESSOR_COUNT)
 
     option(coverage "Generates coverage info." OFF)
     option(profile "Add profiling flags" OFF)
-    set(coverage_format "html-details" CACHE STRING "Output format of the coverage report.")
-    set(coverage_extra_args "" CACHE STRING "Additional arguments to pass to gcovr.")
+    set(coverage_format
+        "html-details"
+        CACHE STRING
+        "Output format of the coverage report."
+    )
+    set(coverage_extra_args
+        ""
+        CACHE STRING
+        "Additional arguments to pass to gcovr."
+    )
     option(wextra "compile with extra gcc/clang warnings enabled" ON)
-else ()
+else()
     set(profile OFF CACHE BOOL "gcc/clang only" FORCE)
     set(coverage OFF CACHE BOOL "gcc/clang only" FORCE)
     set(wextra OFF CACHE BOOL "gcc/clang only" FORCE)
-endif ()
+endif()
 
-if (is_linux AND NOT SANITIZER)
+if(is_linux AND NOT SANITIZER)
     option(BUILD_SHARED_LIBS "build shared xrpl libraries" OFF)
     option(static "link protobuf, openssl, libc++, and boost statically" ON)
     option(perf "Enables flags that assist with perf recording" OFF)
@@ -65,53 +73,83 @@ if (is_linux AND NOT SANITIZER)
     option(use_mold "enables detection of mold (binutils) linker" ON)
     # Set a default value for the log flag based on the build type. This provides a sensible default (on for debug, off
     # for release) while still allowing the user to override it for any build.
-    if (CMAKE_BUILD_TYPE STREQUAL "Debug")
+    if(CMAKE_BUILD_TYPE STREQUAL "Debug")
         set(TRUNCATED_LOGS_DEFAULT ON)
-    else ()
+    else()
         set(TRUNCATED_LOGS_DEFAULT OFF)
-    endif ()
-    option(TRUNCATED_THREAD_NAME_LOGS "Show warnings about truncated thread names on Linux."
-           ${TRUNCATED_LOGS_DEFAULT})
-    if (TRUNCATED_THREAD_NAME_LOGS)
+    endif()
+    option(
+        TRUNCATED_THREAD_NAME_LOGS
+        "Show warnings about truncated thread names on Linux."
+        ${TRUNCATED_LOGS_DEFAULT}
+    )
+    if(TRUNCATED_THREAD_NAME_LOGS)
         add_compile_definitions(TRUNCATED_THREAD_NAME_LOGS)
-    endif ()
-else ()
+    endif()
+else()
     # we are not ready to allow shared-libs on windows because it would require export declarations. On macos it's more
     # feasible, but static openssl produces odd linker errors, thus we disable shared lib builds for now.
-    set(BUILD_SHARED_LIBS OFF CACHE BOOL "build shared xrpl libraries - OFF for win/macos" FORCE)
+    set(BUILD_SHARED_LIBS
+        OFF
+        CACHE BOOL
+        "build shared xrpl libraries - OFF for win/macos"
+        FORCE
+    )
     set(static ON CACHE BOOL "static link, linux only. ON for WIN/macos" FORCE)
     set(perf OFF CACHE BOOL "perf flags, linux only" FORCE)
     set(use_gold OFF CACHE BOOL "gold linker, linux only" FORCE)
     set(use_mold OFF CACHE BOOL "mold linker, linux only" FORCE)
-endif ()
+endif()
 
-if (is_clang)
+if(is_clang)
     option(use_lld "enables detection of lld linker" ON)
-else ()
+else()
     set(use_lld OFF CACHE BOOL "try lld linker, clang only" FORCE)
-endif ()
+endif()
 
 option(jemalloc "Enables jemalloc for heap profiling" OFF)
 option(werr "treat warnings as errors" OFF)
-option(local_protobuf
-       "Force a local build of protobuf instead of looking for an installed version." OFF)
-option(local_grpc "Force a local build of gRPC instead of looking for an installed version." OFF)
+option(
+    local_protobuf
+    "Force a local build of protobuf instead of looking for an installed version."
+    OFF
+)
+option(
+    local_grpc
+    "Force a local build of gRPC instead of looking for an installed version."
+    OFF
+)
 
 # the remaining options are obscure and rarely used
-option(beast_no_unit_test_inline
-       "Prevents unit test definitions from being inserted into global table" OFF)
-option(single_io_service_thread "Restricts the number of threads calling io_context::run to one. \
-  This can be useful when debugging." OFF)
-option(boost_show_deprecated "Allow boost to fail on deprecated usage. Only useful if you're trying\
-  to find deprecated calls." OFF)
+option(
+    beast_no_unit_test_inline
+    "Prevents unit test definitions from being inserted into global table"
+    OFF
+)
+option(
+    single_io_service_thread
+    "Restricts the number of threads calling io_context::run to one. \
+  This can be useful when debugging."
+    OFF
+)
+option(
+    boost_show_deprecated
+    "Allow boost to fail on deprecated usage. Only useful if you're trying\
+  to find deprecated calls."
+    OFF
+)
 
-if (WIN32)
-    option(beast_disable_autolink "Disables autolinking of system libraries on WIN32" OFF)
-else ()
+if(WIN32)
+    option(
+        beast_disable_autolink
+        "Disables autolinking of system libraries on WIN32"
+        OFF
+    )
+else()
     set(beast_disable_autolink OFF CACHE BOOL "WIN32 only" FORCE)
-endif ()
+endif()
 
-if (coverage)
+if(coverage)
     message(STATUS "coverage build requested - forcing Debug build")
     set(CMAKE_BUILD_TYPE Debug CACHE STRING "build type" FORCE)
-endif ()
+endif()

cmake/XrplValidatorKeys.cmake

@@ -1,20 +1,26 @@
-option(validator_keys
-       "Enables building of validator-keys tool as a separate target (imported via FetchContent)"
-       OFF)
+option(
+    validator_keys
+    "Enables building of validator-keys tool as a separate target (imported via FetchContent)"
+    OFF
+)
 
-if (validator_keys)
+if(validator_keys)
     git_branch(current_branch)
     # default to tracking VK master branch unless we are on release
-    if (NOT (current_branch STREQUAL "release"))
+    if(NOT (current_branch STREQUAL "release"))
         set(current_branch "master")
-    endif ()
+    endif()
     message(STATUS "Tracking ValidatorKeys branch: ${current_branch}")
 
     FetchContent_Declare(
-        validator_keys GIT_REPOSITORY https://github.com/ripple/validator-keys-tool.git
-        GIT_TAG "${current_branch}")
+        validator_keys
+        GIT_REPOSITORY https://github.com/ripple/validator-keys-tool.git
+        GIT_TAG "${current_branch}"
+    )
     FetchContent_MakeAvailable(validator_keys)
-    set_target_properties(validator-keys PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}")
+    set_target_properties(
+        validator-keys
+        PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}"
+    )
     install(TARGETS validator-keys RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
-
-endif ()
+endif()

cmake/XrplVersion.cmake

@@ -3,13 +3,13 @@
 #]===================================================================]
 
 file(STRINGS src/libxrpl/protocol/BuildInfo.cpp BUILD_INFO)
-foreach (line_ ${BUILD_INFO})
-    if (line_ MATCHES "versionString[ ]*=[ ]*\"(.+)\"")
+foreach(line_ ${BUILD_INFO})
+    if(line_ MATCHES "versionString[ ]*=[ ]*\"(.+)\"")
         set(xrpld_version ${CMAKE_MATCH_1})
-    endif ()
-endforeach ()
-if (xrpld_version)
+    endif()
+endforeach()
+if(xrpld_version)
     message(STATUS "xrpld version: ${xrpld_version}")
-else ()
+else()
     message(FATAL_ERROR "unable to determine xrpld version")
-endif ()
+endif()

cmake/add_module.cmake

@@ -12,15 +12,29 @@ include(isolate_headers)
 # add_module(parent a)
 # add_module(parent b)
 # target_link_libraries(project.libparent.b PUBLIC project.libparent.a)
-function (add_module parent name)
+function(add_module parent name)
     set(target ${PROJECT_NAME}.lib${parent}.${name})
     add_library(${target} OBJECT)
-    file(GLOB_RECURSE sources CONFIGURE_DEPENDS
-         "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}/*.cpp")
+    file(
+        GLOB_RECURSE sources
+        CONFIGURE_DEPENDS
+        "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}/*.cpp"
+    )
     target_sources(${target} PRIVATE ${sources})
-    target_include_directories(${target} PUBLIC "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
-    isolate_headers(${target} "${CMAKE_CURRENT_SOURCE_DIR}/include"
-                    "${CMAKE_CURRENT_SOURCE_DIR}/include/${parent}/${name}" PUBLIC)
-    isolate_headers(${target} "${CMAKE_CURRENT_SOURCE_DIR}/src"
-                    "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}" PRIVATE)
-endfunction ()
+    target_include_directories(
+        ${target}
+        PUBLIC "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+    )
+    isolate_headers(
+        ${target}
+        "${CMAKE_CURRENT_SOURCE_DIR}/include"
+        "${CMAKE_CURRENT_SOURCE_DIR}/include/${parent}/${name}"
+        PUBLIC
+    )
+    isolate_headers(
+        ${target}
+        "${CMAKE_CURRENT_SOURCE_DIR}/src"
+        "${CMAKE_CURRENT_SOURCE_DIR}/src/lib${parent}/${name}"
+        PRIVATE
+    )
+endfunction()

cmake/create_symbolic_link.cmake

@@ -1,19 +1,21 @@
 # file(CREATE_SYMLINK) only works on Windows with administrator privileges. https://stackoverflow.com/a/61244115/618906
-function (create_symbolic_link target link)
-    if (WIN32)
-        if (NOT IS_SYMLINK "${link}")
-            if (NOT IS_ABSOLUTE "${target}")
+function(create_symbolic_link target link)
+    if(WIN32)
+        if(NOT IS_SYMLINK "${link}")
+            if(NOT IS_ABSOLUTE "${target}")
                 # Relative links work do not work on Windows.
                 set(target "${link}/../${target}")
-            endif ()
+            endif()
             file(TO_NATIVE_PATH "${target}" target)
             file(TO_NATIVE_PATH "${link}" link)
-            execute_process(COMMAND cmd.exe /c mklink /J "${link}" "${target}")
-        endif ()
-    else ()
+            execute_process(
+                COMMAND cmd.exe /c mklink /J "${link}" "${target}"
+            )
+        endif()
+    else()
         file(CREATE_LINK "${target}" "${link}" SYMBOLIC)
-    endif ()
-    if (NOT IS_SYMLINK "${link}")
+    endif()
+    if(NOT IS_SYMLINK "${link}")
         message(ERROR "failed to create symlink: <${link}>")
-    endif ()
-endfunction ()
+    endif()
+endfunction()

cmake/deps/Boost.cmake

@@ -1,45 +1,60 @@
 include(CompilationEnv)
 include(XrplSanitizers)
 
-find_package(Boost REQUIRED
-             COMPONENTS chrono
-                        container
-                        coroutine
-                        date_time
-                        filesystem
-                        json
-                        program_options
-                        regex
-                        system
-                        thread)
+find_package(
+    Boost
+    REQUIRED
+    COMPONENTS
+        chrono
+        container
+        coroutine
+        date_time
+        filesystem
+        json
+        program_options
+        regex
+        system
+        thread
+)
 
 add_library(xrpl_boost INTERFACE)
 add_library(Xrpl::boost ALIAS xrpl_boost)
 
 target_link_libraries(
     xrpl_boost
-    INTERFACE Boost::headers
-              Boost::chrono
-              Boost::container
-              Boost::coroutine
-              Boost::date_time
-              Boost::filesystem
-              Boost::json
-              Boost::process
-              Boost::program_options
-              Boost::regex
-              Boost::thread)
-if (Boost_COMPILER)
+    INTERFACE
+        Boost::headers
+        Boost::chrono
+        Boost::container
+        Boost::coroutine
+        Boost::date_time
+        Boost::filesystem
+        Boost::json
+        Boost::process
+        Boost::program_options
+        Boost::regex
+        Boost::thread
+)
+if(Boost_COMPILER)
     target_link_libraries(xrpl_boost INTERFACE Boost::disable_autolinking)
-endif ()
-if (SANITIZERS_ENABLED AND is_clang)
+endif()
+if(SANITIZERS_ENABLED AND is_clang)
     # TODO: gcc does not support -fsanitize-blacklist...can we do something else for gcc ?
-    if (NOT Boost_INCLUDE_DIRS AND TARGET Boost::headers)
-        get_target_property(Boost_INCLUDE_DIRS Boost::headers INTERFACE_INCLUDE_DIRECTORIES)
-    endif ()
+    if(NOT Boost_INCLUDE_DIRS AND TARGET Boost::headers)
+        get_target_property(
+            Boost_INCLUDE_DIRS
+            Boost::headers
+            INTERFACE_INCLUDE_DIRECTORIES
+        )
+    endif()
     message(STATUS "Adding [${Boost_INCLUDE_DIRS}] to sanitizer blacklist")
-    file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt "src:${Boost_INCLUDE_DIRS}/*")
+    file(
+        WRITE ${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt
+        "src:${Boost_INCLUDE_DIRS}/*"
+    )
     target_compile_options(
-        opts INTERFACE # ignore boost headers for sanitizing
-                       -fsanitize-blacklist=${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt)
-endif ()
+        opts
+        INTERFACE # ignore boost headers for sanitizing
+            -fsanitize-blacklist=${CMAKE_CURRENT_BINARY_DIR}/san_bl.txt
+    )
+endif()

cmake/isolate_headers.cmake

@@ -37,7 +37,7 @@ include(create_symbolic_link)
 # `${CMAKE_CURRENT_BINARY_DIR}/include/${target}`.
 #
 # isolate_headers(target A B scope)
-function (isolate_headers target A B scope)
+function(isolate_headers target A B scope)
     file(RELATIVE_PATH C "${A}" "${B}")
     set(X "${CMAKE_CURRENT_BINARY_DIR}/modules/${target}")
     set(Y "${X}/${C}")
@@ -45,4 +45,4 @@ function (isolate_headers target A B scope)
     file(MAKE_DIRECTORY "${parent}")
     create_symbolic_link("${B}" "${Y}")
     target_include_directories(${target} ${scope} "$<BUILD_INTERFACE:${X}>")
-endfunction ()
+endfunction()

cmake/target_link_modules.cmake

@@ -6,9 +6,9 @@
 # target_link_libraries(project.libparent.b PUBLIC project.libparent.a)
 # add_library(project.libparent)
 # target_link_modules(parent PUBLIC a b)
-function (target_link_modules parent scope)
+function(target_link_modules parent scope)
     set(library ${PROJECT_NAME}.lib${parent})
-    foreach (name ${ARGN})
+    foreach(name ${ARGN})
         set(module ${library}.${name})
         get_target_property(sources ${library} SOURCES)
         list(LENGTH sources before)
@@ -17,8 +17,11 @@ function (target_link_modules parent scope)
         list(REMOVE_ITEM sources ${dupes})
         list(LENGTH sources after)
         math(EXPR actual "${before} - ${after}")
-        message(STATUS "${module} with ${expected} sources took ${actual} sources from ${library}")
+        message(
+            STATUS
+            "${module} with ${expected} sources took ${actual} sources from ${library}"
+        )
         set_target_properties(${library} PROPERTIES SOURCES "${sources}")
         target_link_libraries(${library} ${scope} ${module})
-    endforeach ()
-endfunction ()
+    endforeach()
+endfunction()

cmake/target_protobuf_sources.cmake

@@ -35,20 +35,31 @@ find_package(Protobuf REQUIRED)
 #     This prefix should appear at the start of all your consumer includes.
 # ARGN:
 #     A list of .proto files.
-function (target_protobuf_sources target prefix)
+function(target_protobuf_sources target prefix)
     set(dir "${CMAKE_CURRENT_BINARY_DIR}/pb-${target}")
     file(MAKE_DIRECTORY "${dir}/${prefix}")
 
-    protobuf_generate(TARGET ${target} PROTOC_OUT_DIR "${dir}/${prefix}" "${ARGN}")
+    protobuf_generate(
+        TARGET ${target}
+        PROTOC_OUT_DIR "${dir}/${prefix}"
+        "${ARGN}"
+    )
     target_include_directories(
-        ${target} SYSTEM
+        ${target}
+        SYSTEM
         PUBLIC # Allows #include <package/path/to/file.proto> used by consumer files.
-               $<BUILD_INTERFACE:${dir}>
-               # Allows #include "path/to/file.proto" used by generated files.
-               $<BUILD_INTERFACE:${dir}/${prefix}>
-               # Allows #include <package/path/to/file.proto> used by consumer files.
-               $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-               # Allows #include "path/to/file.proto" used by generated files.
-               $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/${prefix}>)
-    install(DIRECTORY ${dir}/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} FILES_MATCHING PATTERN "*.h")
-endfunction ()
+            $<BUILD_INTERFACE:${dir}>
+            # Allows #include "path/to/file.proto" used by generated files.
+            $<BUILD_INTERFACE:${dir}/${prefix}>
+            # Allows #include <package/path/to/file.proto> used by consumer files.
+            $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+            # Allows #include "path/to/file.proto" used by generated files.
+            $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}/${prefix}>
+    )
+    install(
+        DIRECTORY ${dir}/
+        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+        FILES_MATCHING
+        PATTERN "*.h"
+    )
+endfunction()

cspell.config.yaml

@@ -71,14 +71,12 @@ words:
   - coldwallet
   - compr
   - conanfile
-  - cppcoro
   - conanrun
   - confs
   - connectability
   - coro
   - coros
   - cowid
-  - cppcoro
   - cryptocondition
   - cryptoconditional
   - cryptoconditions
@@ -101,14 +99,11 @@ words:
   - endmacro
   - exceptioned
   - Falco
-  - fcontext
   - finalizers
   - firewalled
-  - fcontext
   - fmtdur
   - fsanitize
   - funclets
-  - gantt
   - gcov
   - gcovr
   - ghead
@@ -181,6 +176,8 @@ words:
   - nixfmt
   - nixos
   - nixpkgs
+  - NOLINT
+  - NOLINTNEXTLINE
   - nonxrp
   - noripple
   - nudb
@@ -190,7 +187,6 @@ words:
   - ostr
   - pargs
   - partitioner
-  - pratik
   - paychan
   - paychans
   - permdex
@@ -198,7 +194,6 @@ words:
   - permissioned
   - pointee
   - populator
-  - pratik
   - preauth
   - preauthorization
   - preauthorize
@@ -213,7 +208,6 @@ words:
   - queuable
   - Raphson
   - replayer
-  - repost
   - rerere
   - retriable
   - RIPD
@@ -244,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/detail/transactions.macro

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

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() const
+    {
+        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,82 @@
+#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)
+    {
+        auto entryType = static_cast<LedgerEntryType>(ledgerEntryType);
+        auto const& soTemplate =
+            LedgerFormats::getInstance().findByType(entryType)->getSOTemplate();
+        object_.set(soTemplate);
+        object_[sfLedgerEntryType] = ledgerEntryType;
+        object_[sfFlags] = flags;
+    }
+
+    /**
+     * @brief Validate the ledger entry
+     * @return true if validation passes, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    validate() const
+    {
+        if (!object_.isFieldPresent(sfLedgerEntryType))
+        {
+            return false;
+        }
+        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/Owning.h

@@ -0,0 +1,123 @@
+#pragma once
+
+#include <utility>
+
+namespace xrpl::protocol_autogen {
+
+/**
+ * A wrapper that owns an object and provides access through a typed wrapper.
+ *
+ * This is useful when you want to hold both the raw underlying object (like SLE or STTx)
+ * and its type-safe wrapper together with proper ownership semantics.
+ *
+ * The class is non-copyable and non-movable because the wrapper holds a reference
+ * to the owned object.
+ *
+ * @tparam TObject The underlying object type (e.g., SLE, STTx)
+ * @tparam TWrapper The typed wrapper class (e.g., AccountRoot, Payment)
+ *
+ * Example usage:
+ * @code
+ *     // From a builder
+ *     auto owned = accountRootBuilder.buildOwning(index);
+ *     owned->getBalance();      // Access via typed wrapper
+ *     owned.object();           // Access raw SLE
+ *
+ *     // Direct construction
+ *     Owning<SLE, AccountRoot> owned{std::move(sle)};
+ * @endcode
+ */
+template <typename TObject, typename TWrapper>
+class Owning
+{
+public:
+    /**
+     * Construct by taking ownership of the object.
+     * @param obj The object to own (will be moved from)
+     */
+    explicit Owning(TObject obj) : object_(std::move(obj)), wrapper_(object_)
+    {
+    }
+
+    // Non-copyable and non-movable (wrapper holds reference to object_)
+    Owning(Owning const&) = delete;
+    Owning&
+    operator=(Owning const&) = delete;
+    Owning(Owning&&) = delete;
+    Owning&
+    operator=(Owning&&) = delete;
+
+    /**
+     * Access the typed wrapper.
+     */
+    [[nodiscard]]
+    TWrapper&
+    get()
+    {
+        return wrapper_;
+    }
+
+    [[nodiscard]]
+    TWrapper const&
+    get() const
+    {
+        return wrapper_;
+    }
+
+    /**
+     * Dereference to access the wrapper.
+     */
+    [[nodiscard]]
+    TWrapper&
+    operator*()
+    {
+        return wrapper_;
+    }
+
+    [[nodiscard]]
+    TWrapper const&
+    operator*() const
+    {
+        return wrapper_;
+    }
+
+    /**
+     * Arrow operator for convenient wrapper access.
+     */
+    [[nodiscard]]
+    TWrapper*
+    operator->()
+    {
+        return &wrapper_;
+    }
+
+    [[nodiscard]]
+    TWrapper const*
+    operator->() const
+    {
+        return &wrapper_;
+    }
+
+    /**
+     * Access the underlying object directly.
+     */
+    [[nodiscard]]
+    TObject&
+    object()
+    {
+        return object_;
+    }
+
+    [[nodiscard]]
+    TObject const&
+    object() const
+    {
+        return object_;
+    }
+
+private:
+    TObject object_;    // Must be declared first (initialised first)
+    TWrapper wrapper_;  // Holds reference to object_
+};
+
+}  // namespace xrpl::protocol_autogen

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

include/xrpl/protocol_autogen/TransactionBase.h

@@ -0,0 +1,455 @@
+#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(std::string& reason) const
+    {
+        if (!protocol_autogen::validateSTObject(
+                tx_, TxFormats::getInstance().findByType(tx_.getTxnType())->getSOTemplate()))
+        {
+            reason = "Transaction failed schema validation";
+            return false;
+        }
+
+        // Pseudo transactions are not submitted to the network
+        if (isPseudoTx(tx_))
+        {
+            return true;
+        }
+        return passesLocalChecks(tx_, reason);
+    }
+
+    /**
+     * @brief Get the transaction type.
+     * @return The type of this transaction
+     */
+    [[nodiscard]]
+    xrpl::TxType
+    getTransactionType() const
+    {
+        return tx_.getTxnType();
+    }
+
+    /**
+     * @brief Get the account initiating the transaction (sfAccount).
+     *
+     * This field is REQUIRED for all transactions.
+     * @return The account ID of the transaction sender
+     */
+    [[nodiscard]]
+    AccountID
+    getAccount() const
+    {
+        return tx_.at(sfAccount);
+    }
+
+    /**
+     * @brief Get the sequence number of the transaction (sfSequence).
+     *
+     * This field is REQUIRED for all transactions.
+     * @return The sequence number
+     */
+    [[nodiscard]]
+    std::uint32_t
+    getSequence() const
+    {
+        return tx_.at(sfSequence);
+    }
+
+    /**
+     * @brief Get the transaction fee (sfFee).
+     *
+     * This field is REQUIRED for all transactions.
+     * @return The fee amount
+     */
+    [[nodiscard]]
+    STAmount
+    getFee() const
+    {
+        return tx_.at(sfFee);
+    }
+
+    /**
+     * @brief Get the signing public key (sfSigningPubKey).
+     *
+     * This field is REQUIRED for all transactions.
+     * @return The public key used for signing as a blob
+     */
+    [[nodiscard]]
+    Blob
+    getSigningPubKey() const
+    {
+        return tx_.getFieldVL(sfSigningPubKey);
+    }
+
+    /**
+     * @brief Get the transaction flags (sfFlags).
+     *
+     * This field is OPTIONAL.
+     * @return The flags value if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<uint32_t>
+    getFlags() const
+    {
+        if (tx_.isFieldPresent(sfFlags))
+            return tx_.at(sfFlags);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has flags set.
+     * @return true if sfFlags is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasFlags() const
+    {
+        return tx_.isFieldPresent(sfFlags);
+    }
+
+    /**
+     * @brief Get the source tag (sfSourceTag).
+     *
+     * This field is OPTIONAL and used to identify the source of a payment.
+     * @return The source tag value if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<uint32_t>
+    getSourceTag() const
+    {
+        if (tx_.isFieldPresent(sfSourceTag))
+            return tx_.at(sfSourceTag);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has a source tag.
+     * @return true if sfSourceTag is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasSourceTag() const
+    {
+        return tx_.isFieldPresent(sfSourceTag);
+    }
+
+    /**
+     * @brief Get the previous transaction ID (sfPreviousTxnID).
+     *
+     * This field is OPTIONAL and used for transaction chaining.
+     * @return The previous transaction ID if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<uint256>
+    getPreviousTxnID() const
+    {
+        if (tx_.isFieldPresent(sfPreviousTxnID))
+            return tx_.at(sfPreviousTxnID);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has a previous transaction ID.
+     * @return true if sfPreviousTxnID is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasPreviousTxnID() const
+    {
+        return tx_.isFieldPresent(sfPreviousTxnID);
+    }
+
+    /**
+     * @brief Get the last ledger sequence (sfLastLedgerSequence).
+     *
+     * This field is OPTIONAL and specifies the latest ledger sequence
+     * in which this transaction can be included.
+     * @return The last ledger sequence if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<uint32_t>
+    getLastLedgerSequence() const
+    {
+        if (tx_.isFieldPresent(sfLastLedgerSequence))
+            return tx_.at(sfLastLedgerSequence);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has a last ledger sequence.
+     * @return true if sfLastLedgerSequence is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasLastLedgerSequence() const
+    {
+        return tx_.isFieldPresent(sfLastLedgerSequence);
+    }
+
+    /**
+     * @brief Get the account transaction ID (sfAccountTxnID).
+     *
+     * This field is OPTIONAL and used to track transaction sequences.
+     * @return The account transaction ID if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<uint256>
+    getAccountTxnID() const
+    {
+        if (tx_.isFieldPresent(sfAccountTxnID))
+            return tx_.at(sfAccountTxnID);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has an account transaction ID.
+     * @return true if sfAccountTxnID is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasAccountTxnID() const
+    {
+        return tx_.isFieldPresent(sfAccountTxnID);
+    }
+
+    /**
+     * @brief Get the operation limit (sfOperationLimit).
+     *
+     * This field is OPTIONAL and limits the number of operations in a transaction.
+     * @return The operation limit if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<uint32_t>
+    getOperationLimit() const
+    {
+        if (tx_.isFieldPresent(sfOperationLimit))
+            return tx_.at(sfOperationLimit);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has an operation limit.
+     * @return true if sfOperationLimit is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasOperationLimit() const
+    {
+        return tx_.isFieldPresent(sfOperationLimit);
+    }
+
+    /**
+     * @brief Get the memos array (sfMemos).
+     *
+     * This field is OPTIONAL and contains arbitrary data attached to the transaction.
+     * @note This is an untyped field (STArray).
+     * @return A reference wrapper to the memos array if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<std::reference_wrapper<STArray const>>
+    getMemos() const
+    {
+        if (tx_.isFieldPresent(sfMemos))
+            return tx_.getFieldArray(sfMemos);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has memos.
+     * @return true if sfMemos is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasMemos() const
+    {
+        return tx_.isFieldPresent(sfMemos);
+    }
+
+    /**
+     * @brief Get the ticket sequence (sfTicketSequence).
+     *
+     * This field is OPTIONAL and used when consuming a ticket instead of a sequence number.
+     * @return The ticket sequence if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<uint32_t>
+    getTicketSequence() const
+    {
+        if (tx_.isFieldPresent(sfTicketSequence))
+            return tx_.at(sfTicketSequence);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has a ticket sequence.
+     * @return true if sfTicketSequence is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasTicketSequence() const
+    {
+        return tx_.isFieldPresent(sfTicketSequence);
+    }
+
+    /**
+     * @brief Get the transaction signature (sfTxnSignature).
+     *
+     * This field is OPTIONAL and contains the signature for single-signed transactions.
+     * @return The transaction signature as a blob if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<Blob>
+    getTxnSignature() const
+    {
+        if (tx_.isFieldPresent(sfTxnSignature))
+            return tx_.getFieldVL(sfTxnSignature);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has a transaction signature.
+     * @return true if sfTxnSignature is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasTxnSignature() const
+    {
+        return tx_.isFieldPresent(sfTxnSignature);
+    }
+
+    /**
+     * @brief Get the signers array (sfSigners).
+     *
+     * This field is OPTIONAL and contains the list of signers for multi-signed transactions.
+     * @note This is an untyped field (STArray).
+     * @return A reference wrapper to the signers array if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<std::reference_wrapper<STArray const>>
+    getSigners() const
+    {
+        if (tx_.isFieldPresent(sfSigners))
+            return tx_.getFieldArray(sfSigners);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has signers.
+     * @return true if sfSigners is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasSigners() const
+    {
+        return tx_.isFieldPresent(sfSigners);
+    }
+
+    /**
+     * @brief Get the network ID (sfNetworkID).
+     *
+     * This field is OPTIONAL and identifies the network this transaction is intended for.
+     * @return The network ID if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<uint32_t>
+    getNetworkID() const
+    {
+        if (tx_.isFieldPresent(sfNetworkID))
+            return tx_.at(sfNetworkID);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has a network ID.
+     * @return true if sfNetworkID is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasNetworkID() const
+    {
+        return tx_.isFieldPresent(sfNetworkID);
+    }
+
+    /**
+     * @brief Get the delegate account (sfDelegate).
+     *
+     * This field is OPTIONAL and specifies a delegate account for the transaction.
+     * @return The delegate account ID if present, std::nullopt otherwise
+     */
+    [[nodiscard]]
+    std::optional<AccountID>
+    getDelegate() const
+    {
+        if (tx_.isFieldPresent(sfDelegate))
+            return tx_.at(sfDelegate);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if the transaction has a delegate account.
+     * @return true if sfDelegate is present, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    hasDelegate() const
+    {
+        return tx_.isFieldPresent(sfDelegate);
+    }
+
+    /**
+     * @brief Get the underlying STTx object.
+     *
+     * Provides direct access to the wrapped transaction object for cases
+     * where the type-safe accessors are insufficient.
+     * @return A constant reference to the underlying STTx object
+     */
+    [[nodiscard]]
+    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,199 @@
+#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/STTx.h>
+#include <xrpl/protocol/STXChainBridge.h>
+#include <xrpl/protocol/SecretKey.h>
+#include <xrpl/protocol/Serializer.h>
+#include <xrpl/protocol/TxFormats.h>
+#include <xrpl/protocol/jss.h>
+#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)
+    {
+        auto txType = static_cast<TxType>(transactionType);
+        auto const& soTemplate = TxFormats::getInstance().findByType(txType)->getSOTemplate();
+        object_.set(soTemplate);
+
+        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(std::string& reason) const
+    {
+        if (!object_.isFieldPresent(sfTransactionType))
+        {
+            return false;
+        }
+
+        auto transactionType = static_cast<TxType>(object_.getFieldU16(sfTransactionType));
+        if (!protocol_autogen::validateSTObject(
+                object_, TxFormats::getInstance().findByType(transactionType)->getSOTemplate()))
+        {
+            reason = "Transaction failed schema validation";
+            return false;
+        }
+
+        // Pseudo transactions are not submitted to the network
+        if (isPseudoTx(object_))
+        {
+            return true;
+        }
+        return passesLocalChecks(object_, reason);
+    }
+
+    /**
+     * 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);
+    }
+
+protected:
+    /**
+     * Sign the transaction with the given keys.
+     *
+     * This sets the SigningPubKey field and computes the TxnSignature.
+     *
+     * @param publicKey The public key for signing
+     * @param secretKey The secret key for signing
+     * @return Reference to the derived builder for method chaining.
+     */
+    Derived&
+    sign(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        // Set the signing public key
+        object_.setFieldVL(sfSigningPubKey, publicKey.slice());
+
+        // Build the signing data: HashPrefix::txSign + serialized object
+        // (without signing fields)
+        Serializer s;
+        s.add32(HashPrefix::txSign);
+        object_.addWithoutSigningFields(s);
+
+        // Sign and set the signature
+        auto const sig = xrpl::sign(publicKey, secretKey, s.slice());
+        object_.setFieldVL(sfTxnSignature, sig);
+
+        return static_cast<Derived&>(*this);
+    }
+
+    STObject object_{sfTransaction};
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/Utils.h

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

include/xrpl/protocol_autogen/ledger_objects/AMM.h

@@ -0,0 +1,348 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, AMM>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, AMM>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/AccountRoot.h

@@ -0,0 +1,728 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, AccountRoot>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, AccountRoot>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/Amendments.h

@@ -0,0 +1,207 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, Amendments>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, Amendments>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/Bridge.h

@@ -0,0 +1,314 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, Bridge>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, Bridge>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/Check.h

@@ -0,0 +1,382 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, Check>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, Check>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/Credential.h

@@ -0,0 +1,308 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, Credential>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, Credential>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/DID.h

@@ -0,0 +1,264 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, DID>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, DID>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/Delegate.h

@@ -0,0 +1,219 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, Delegate>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, Delegate>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/DepositPreauth.h

@@ -0,0 +1,235 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, DepositPreauth>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, DepositPreauth>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/DirectoryNode.h

@@ -0,0 +1,490 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, DirectoryNode>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, DirectoryNode>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/Escrow.h

@@ -0,0 +1,488 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, Escrow>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, Escrow>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/FeeSettings.h

@@ -0,0 +1,356 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, FeeSettings>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, FeeSettings>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/LedgerHashes.h

@@ -0,0 +1,168 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, LedgerHashes>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, LedgerHashes>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/Loan.h

@@ -0,0 +1,816 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, Loan>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, Loan>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/LoanBroker.h

@@ -0,0 +1,524 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, LoanBroker>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, LoanBroker>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/MPToken.h

@@ -0,0 +1,256 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, MPToken>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, MPToken>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/MPTokenIssuance.h

@@ -0,0 +1,428 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, MPTokenIssuance>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, MPTokenIssuance>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/NFTokenOffer.h

@@ -0,0 +1,300 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, NFTokenOffer>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, NFTokenOffer>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/NFTokenPage.h

@@ -0,0 +1,213 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, NFTokenPage>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, NFTokenPage>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/NegativeUNL.h

@@ -0,0 +1,237 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, NegativeUNL>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, NegativeUNL>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/Offer.h

@@ -0,0 +1,375 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, Offer>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, Offer>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/Oracle.h

@@ -0,0 +1,323 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, Oracle>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, Oracle>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/PayChannel.h

@@ -0,0 +1,464 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, PayChannel>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, PayChannel>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/PermissionedDomain.h

@@ -0,0 +1,219 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, PermissionedDomain>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, PermissionedDomain>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/RippleState.h

@@ -0,0 +1,376 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, RippleState>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, RippleState>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/SignerList.h

@@ -0,0 +1,249 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, SignerList>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, SignerList>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/Ticket.h

@@ -0,0 +1,196 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, Ticket>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, Ticket>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/Vault.h

@@ -0,0 +1,464 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, Vault>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, Vault>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/XChainOwnedClaimID.h

@@ -0,0 +1,285 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, XChainOwnedClaimID>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, XChainOwnedClaimID>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/ledger_objects/XChainOwnedCreateAccountClaimID.h

@@ -0,0 +1,241 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     */
+    protocol_autogen::Owning<SLE, XChainOwnedCreateAccountClaimID>
+    build(uint256 const& index)
+    {
+        return protocol_autogen::Owning<SLE, XChainOwnedCreateAccountClaimID>{SLE{object_, index}};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/transactions/AMMBid.h

@@ -0,0 +1,232 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     * @param publicKey The public key for signing
+     * @param secretKey The secret key for signing
+     * @return The constructed transaction wrapper.
+     */
+    protocol_autogen::Owning<STTx, AMMBid>
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return protocol_autogen::Owning<STTx, AMMBid>{STTx{std::move(object_)}};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/AMMClawback.h

@@ -0,0 +1,192 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     * @param publicKey The public key for signing
+     * @param secretKey The secret key for signing
+     * @return The constructed transaction wrapper.
+     */
+    protocol_autogen::Owning<STTx, AMMClawback>
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return protocol_autogen::Owning<STTx, AMMClawback>{STTx{std::move(object_)}};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/AMMCreate.h

@@ -0,0 +1,160 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     * @param publicKey The public key for signing
+     * @param secretKey The secret key for signing
+     * @return The constructed transaction wrapper.
+     */
+    protocol_autogen::Owning<STTx, AMMCreate>
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return protocol_autogen::Owning<STTx, AMMCreate>{STTx{std::move(object_)}};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/AMMDelete.h

@@ -0,0 +1,138 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     * @param publicKey The public key for signing
+     * @param secretKey The secret key for signing
+     * @return The constructed transaction wrapper.
+     */
+    protocol_autogen::Owning<STTx, AMMDelete>
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return protocol_autogen::Owning<STTx, AMMDelete>{STTx{std::move(object_)}};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/AMMDeposit.h

@@ -0,0 +1,298 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     * @param publicKey The public key for signing
+     * @param secretKey The secret key for signing
+     * @return The constructed transaction wrapper.
+     */
+    protocol_autogen::Owning<STTx, AMMDeposit>
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return protocol_autogen::Owning<STTx, AMMDeposit>{STTx{std::move(object_)}};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/AMMVote.h

@@ -0,0 +1,160 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     * @param publicKey The public key for signing
+     * @param secretKey The secret key for signing
+     * @return The constructed transaction wrapper.
+     */
+    protocol_autogen::Owning<STTx, AMMVote>
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return protocol_autogen::Owning<STTx, AMMVote>{STTx{std::move(object_)}};
+    }
+};
+
+}  // namespace xrpl::transactions

include/xrpl/protocol_autogen/transactions/AMMWithdraw.h

@@ -0,0 +1,266 @@
+// This file is auto-generated. Do not edit.
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/Owning.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.
+     * @param publicKey The public key for signing
+     * @param secretKey The secret key for signing
+     * @return The constructed transaction wrapper.
+     */
+    protocol_autogen::Owning<STTx, AMMWithdraw>
+    build(PublicKey const& publicKey, SecretKey const& secretKey)
+    {
+        sign(publicKey, secretKey);
+        return protocol_autogen::Owning<STTx, AMMWithdraw>{STTx{std::move(object_)}};
+    }
+};
+
+}  // namespace xrpl::transactions