Updated the template

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

.github/workflows/pre-commit.yml

@@ -14,4 +14,4 @@ jobs:
     uses: XRPLF/actions/.github/workflows/pre-commit.yml@320be44621ca2a080f05aeb15817c44b84518108
     with:
       runs_on: ubuntu-latest
-      container: '{ "image": "ghcr.io/xrplf/ci/tools-rippled-pre-commit:sha-ab4d1f0" }'
+      container: '{ "image": "ghcr.io/xrplf/ci/tools-rippled-pre-commit:sha-41ec7c1" }'

.gitignore

@@ -42,6 +42,9 @@ gmon.out
 # Locally patched Conan recipes
 external/conan-center-index/
 
+# Local conan directory
+.conan
+
 # XCode IDE.
 *.pbxuser
 !default.pbxuser
@@ -72,5 +75,12 @@ DerivedData
 /.claude
 /CLAUDE.md
 
+# Direnv's directory
+/.direnv
+
 # clangd cache
 /.cache
+
+# Auto-generated protocol wrapper classes (generated at CMake configure time)
+/include/xrpl/protocol_autogen/transactions/
+/include/xrpl/protocol_autogen/ledger_objects/

.pre-commit-config.yaml

@@ -57,6 +57,16 @@ repos:
           - .git/COMMIT_EDITMSG
         stages: [commit-msg]
 
+  - repo: local
+    hooks:
+      - id: nix-fmt
+        name: Format Nix files
+        entry: nix --extra-experimental-features 'nix-command flakes' fmt
+        language: system
+        types:
+          - nix
+        pass_filenames: true
+
 exclude: |
   (?x)^(
       external/.*|

cmake/XrplCore.cmake

@@ -74,15 +74,23 @@ add_module(xrpl protocol)
 target_link_libraries(xrpl.libxrpl.protocol PUBLIC xrpl.libxrpl.crypto xrpl.libxrpl.json)
 
 # Level 05
+add_module(xrpl protocol_autogen)
+target_link_libraries(xrpl.libxrpl.protocol_autogen PUBLIC xrpl.libxrpl.protocol)
+
+# Set up code generation for protocol_autogen module
+include(XrplProtocolAutogen)
+setup_protocol_autogen()
+
+# Level 06
 add_module(xrpl core)
 target_link_libraries(xrpl.libxrpl.core PUBLIC xrpl.libxrpl.basics xrpl.libxrpl.json
                                                xrpl.libxrpl.protocol)
 
-# Level 06
+# 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)
@@ -140,6 +148,7 @@ target_link_modules(
     net
     nodestore
     protocol
+    protocol_autogen
     rdb
     resource
     server

cmake/XrplInstall.cmake

@@ -29,6 +29,7 @@ install(TARGETS common
                 xrpl.libxrpl.net
                 xrpl.libxrpl.nodestore
                 xrpl.libxrpl.protocol
+                xrpl.libxrpl.protocol_autogen
                 xrpl.libxrpl.resource
                 xrpl.libxrpl.server
                 xrpl.libxrpl.shamap

cmake/XrplProtocolAutogen.cmake

@@ -0,0 +1,132 @@
+#[===================================================================[
+   Protocol Autogen - Code generation for protocol wrapper classes
+#]===================================================================]
+
+# Function to set up code generation for protocol_autogen module
+# This runs at configure time to generate C++ wrapper classes from macro files
+function (setup_protocol_autogen)
+    # Directory paths
+    set(MACRO_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include/xrpl/protocol/detail")
+    set(AUTOGEN_HEADER_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include/xrpl/protocol_autogen")
+    set(SCRIPTS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/scripts")
+
+    # Input macro files
+    set(TRANSACTIONS_MACRO "${MACRO_DIR}/transactions.macro")
+    set(LEDGER_ENTRIES_MACRO "${MACRO_DIR}/ledger_entries.macro")
+    set(SFIELDS_MACRO "${MACRO_DIR}/sfields.macro")
+
+    # Python scripts
+    set(GENERATE_TX_SCRIPT "${SCRIPTS_DIR}/generate_tx_classes.py")
+    set(GENERATE_LEDGER_SCRIPT "${SCRIPTS_DIR}/generate_ledger_classes.py")
+    set(REQUIREMENTS_FILE "${SCRIPTS_DIR}/requirements.txt")
+
+    # Create output directories
+    file(MAKE_DIRECTORY "${AUTOGEN_HEADER_DIR}/transactions")
+    file(MAKE_DIRECTORY "${AUTOGEN_HEADER_DIR}/ledger_objects")
+
+    # Find Python3 - check if already found by Conan or find it ourselves
+    if (NOT Python3_EXECUTABLE)
+        find_package(Python3 COMPONENTS Interpreter QUIET)
+    endif ()
+
+    if (NOT Python3_EXECUTABLE)
+        # Try finding python3 executable directly
+        find_program(Python3_EXECUTABLE NAMES python3 python)
+    endif ()
+
+    if (NOT Python3_EXECUTABLE)
+        message(FATAL_ERROR "Python3 not found. Code generation cannot proceed.")
+        return()
+    endif ()
+
+    message(STATUS "Using Python3 for code generation: ${Python3_EXECUTABLE}")
+
+    # Set up Python virtual environment for code generation
+    set(VENV_DIR "${CMAKE_CURRENT_BINARY_DIR}/codegen_venv")
+
+    # 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 ()
+
+    # 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 ()
+
+    # Generate transaction classes at configure time
+    message(STATUS "Generating transaction classes from transactions.macro...")
+    execute_process(COMMAND ${VENV_PYTHON} "${GENERATE_TX_SCRIPT}" "${TRANSACTIONS_MACRO}"
+                            --header-dir "${AUTOGEN_HEADER_DIR}/transactions" --sfields-macro
+                            "${SFIELDS_MACRO}"
+                    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+                    RESULT_VARIABLE TX_GEN_RESULT
+                    OUTPUT_VARIABLE TX_GEN_OUTPUT
+                    ERROR_VARIABLE TX_GEN_ERROR)
+    if (NOT TX_GEN_RESULT EQUAL 0)
+        message(FATAL_ERROR "Failed to generate transaction classes:\n${TX_GEN_ERROR}")
+    else ()
+        message(STATUS "Transaction classes generated successfully")
+    endif ()
+
+    # Generate ledger entry classes at configure time
+    message(STATUS "Generating ledger entry classes from ledger_entries.macro...")
+    execute_process(COMMAND ${VENV_PYTHON} "${GENERATE_LEDGER_SCRIPT}" "${LEDGER_ENTRIES_MACRO}"
+                            --header-dir "${AUTOGEN_HEADER_DIR}/ledger_objects" --sfields-macro
+                            "${SFIELDS_MACRO}"
+                    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
+                    RESULT_VARIABLE LEDGER_GEN_RESULT
+                    OUTPUT_VARIABLE LEDGER_GEN_OUTPUT
+                    ERROR_VARIABLE LEDGER_GEN_ERROR)
+    if (NOT LEDGER_GEN_RESULT EQUAL 0)
+        message(FATAL_ERROR "Failed to generate ledger entry classes:\n${LEDGER_GEN_ERROR}")
+    else ()
+        message(STATUS "Ledger entry classes generated successfully")
+    endif ()
+
+    # Add the generated header directory to the module's include path
+    target_include_directories(
+        xrpl.libxrpl.protocol_autogen PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+                                             $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
+
+    # Install generated headers
+    install(DIRECTORY "${AUTOGEN_HEADER_DIR}/"
+            DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/xrpl/protocol_autogen" FILES_MATCHING
+            PATTERN "*.h")
+endfunction ()

cspell.config.yaml

@@ -173,6 +173,9 @@ words:
   - nftokens
   - nftpage
   - nikb
+  - nixfmt
+  - nixos
+  - nixpkgs
   - nonxrp
   - noripple
   - nudb

docs/build/environment.md

@@ -3,6 +3,8 @@ environment complete with Git, Python, Conan, CMake, and a C++ compiler.
 This document exists to help readers set one up on any of the Big Three
 platforms: Linux, macOS, or Windows.
 
+As an alternative to system packages, the Nix development shell can be used to provide a development environment. See [using nix development shell](./nix.md) for more details.
+
 [BUILD.md]: ../../BUILD.md
 
 ## Linux

docs/build/nix.md

@@ -0,0 +1,95 @@
+# Using Nix Development Shell for xrpld Development
+
+This guide explains how to use Nix to set up a reproducible development environment for xrpld. Using Nix eliminates the need to manually install utilities and ensures consistent tooling across different machines.
+
+## Benefits of Using Nix
+
+- **Reproducible environment**: Everyone gets the same versions of tools and compilers
+- **No system pollution**: Dependencies are isolated and don't affect your system packages
+- **Multiple compiler versions**: Easily switch between different GCC and Clang versions
+- **Quick setup**: Get started with a single command
+- **Works on Linux and macOS**: Consistent experience across platforms
+
+## Install Nix
+
+Please follow [the official installation instructions of nix package manager](https://nixos.org/download/) for your system.
+
+## Entering the Development Shell
+
+### Basic Usage
+
+From the root of the xrpld repository, enter the default development shell:
+
+```bash
+nix --experimental-features 'nix-command flakes' develop
+```
+
+This will:
+
+- Download and set up all required development tools (CMake, Ninja, Conan, etc.)
+- Configure the appropriate compiler for your platform:
+  - **macOS**: Apple Clang (default system compiler)
+  - **Linux**: GCC 15
+
+The first time you run this command, it will take a few minutes to download and build the environment. Subsequent runs will be much faster.
+
+> [!TIP]
+> To avoid typing `--experimental-features 'nix-command flakes'` every time, you can permanently enable flakes by creating `~/.config/nix/nix.conf`:
+>
+> ```bash
+> mkdir -p ~/.config/nix
+> echo "experimental-features = nix-command flakes" >> ~/.config/nix/nix.conf
+> ```
+>
+> After this, you can simply use `nix develop` instead.
+
+> [!NOTE]
+> The examples below assume you've enabled flakes in your config. If you haven't, add `--experimental-features 'nix-command flakes'` after each `nix` command.
+
+### Choosing a different compiler
+
+A compiler can be chosen by providing its name with the `.#` prefix, e.g. `nix develop .#gcc15`.
+Use `nix flake show` to see all the available development shells.
+
+Use `nix develop .#no_compiler` to use the compiler from your system.
+
+### Example Usage
+
+```bash
+# Use GCC 14
+nix develop .#gcc14
+
+# Use Clang 19
+nix develop .#clang19
+
+# Use default for your platform
+nix develop
+```
+
+### Using a different shell
+
+`nix develop` opens bash by default. If you want to use another shell this could be done by adding `-c` flag. For example:
+
+```bash
+nix develop -c zsh
+```
+
+## Building xrpld with Nix
+
+Once inside the Nix development shell, follow the standard [build instructions](../../BUILD.md#steps). The Nix shell provides all necessary tools (CMake, Ninja, Conan, etc.).
+
+## Automatic Activation with direnv
+
+[direnv](https://direnv.net/) or [nix-direnv](https://github.com/nix-community/nix-direnv) can automatically activate the Nix development shell when you enter the repository directory.
+
+## Conan and Prebuilt Packages
+
+Please note that there is no guarantee that binaries from conan cache will work when using nix. If you encounter any errors, please use `--build '*'` to force conan to compile everything from source:
+
+```bash
+conan install .. --output-folder . --build '*' --settings build_type=Release
+```
+
+## Updating `flake.lock` file
+
+To update `flake.lock` to the latest revision use `nix flake update` command.

flake.lock

@@ -0,0 +1,26 @@
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1769461804,
+        "narHash": "sha256-6h5sROT/3CTHvzPy9koKBmoCa2eJKh4fzQK8eYFEgl8=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "b579d443b37c9c5373044201ea77604e37e748c8",
+        "type": "github"
+      },
+      "original": {
+        "id": "nixpkgs",
+        "ref": "nixos-unstable",
+        "type": "indirect"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,16 @@
+{
+  description = "Nix related things for xrpld";
+  inputs = {
+    nixpkgs.url = "nixpkgs/nixos-unstable";
+  };
+
+  outputs =
+    { nixpkgs, ... }:
+    let
+      forEachSystem = (import ./nix/utils.nix { inherit nixpkgs; }).forEachSystem;
+    in
+    {
+      devShells = forEachSystem (import ./nix/devshell.nix);
+      formatter = forEachSystem ({ pkgs, ... }: pkgs.nixfmt);
+    };
+}

include/xrpl/protocol_autogen/LedgerEntryBase.h

@@ -0,0 +1,133 @@
+#pragma once
+
+#include <xrpl/protocol/LedgerFormats.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STLedgerEntry.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 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,75 @@
+#pragma once
+
+#include <xrpl/json/json_value.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STObject.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:
+    /**
+     * 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);
+    }
+
+    /**
+     * @brief Factory method to create a new instance of the derived builder.
+     *
+     * Creates a default-constructed builder instance. It is recommended to use
+     * this factory method instead of directly constructing the derived type to
+     * avoid creating unnecessary temporary objects.
+     * @return A new instance of the derived builder type
+     */
+    static Derived
+    create()
+    {
+        return Derived{};
+    }
+
+    /**
+     * @brief Factory method to create an instance of the derived builder from an existing SLE.
+     *
+     * Creates a builder instance initialized with data from an existing serialized
+     * ledger entry. It is recommended to use this factory method instead of directly
+     * constructing the derived type to avoid creating unnecessary temporary objects.
+     * @param sle The existing serialized ledger entry to initialize from
+     * @return A new instance of the derived builder type initialized with the SLE data
+     */
+    static Derived
+    create(SLE const& sle)
+    {
+        return Derived{sle};
+    }
+
+protected:
+    STObject object_{sfLedgerEntry};
+};
+
+}  // namespace xrpl::ledger_entries

include/xrpl/protocol_autogen/README.md

@@ -0,0 +1,64 @@
+<!-- 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 Jinja2 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
+- `Jinja2` - Template engine
+
+These are isolated in a virtual environment and won't affect your system Python installation.
+
+## Version Control
+
+The generated `.h` files are **not checked into version control** - they are listed in `.gitignore`.
+This means:
+
+- Every developer needs Python 3 installed to configure the project
+- CI/CD systems must run CMake configure to generate the files
+- Generated files are always fresh and match the current macro definitions
+
+## Modifying Generated Code
+
+**Do not manually edit files in this directory.** 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 Jinja2 templates in `scripts/templates/`
+- Edit the generation scripts in `scripts/`
+- Update Python dependencies in `scripts/requirements.txt`
+- Run CMake configure to regenerate

include/xrpl/protocol_autogen/TransactionBase.h

@@ -0,0 +1,442 @@
+#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 <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 using passesLocalChecks.
+     * @param reason Output parameter for validation failure reason
+     * @return true if validation passes, false otherwise
+     */
+    [[nodiscard]]
+    bool
+    validate(std::string& reason) const
+    {
+        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,128 @@
+#pragma once
+
+#include <xrpl/json/json_value.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/jss.h>
+
+namespace xrpl::transactions {
+
+/**
+ * Base class for all transaction builders.
+ * Provides common field setters that are available for all transaction types.
+ */
+template <typename Derived>
+class TransactionBuilderBase
+{
+public:
+    /**
+     * 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)
+    {
+        set(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)
+    {
+        set(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)
+    {
+        set(object_, sfSequence, value);
+        return static_cast<Derived&>(*this);
+    }
+
+    /**
+     * Set the signing public key.
+     * @param value Public key (typically as a hex string)
+     * @return Reference to the derived builder for method chaining.
+     */
+    Derived&
+    setSigningPubKey(Blob const& value)
+    {
+        set(object_, sfSigningPubKey, 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)
+    {
+        set(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)
+    {
+        set(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)
+    {
+        set(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(STUInt256 const& value)
+    {
+        set(object_, sfAccountTxnID, value);
+        return static_cast<Derived&>(*this);
+    }
+
+    /**
+     * @brief Factory method to create an instance of the derived builder.
+     *
+     * @return A new instance of the derived builder type
+     */
+    static Derived
+    create()
+    {
+        return Derived{};
+    }
+
+protected:
+    STObject object_{sfTransaction};
+};
+
+}  // namespace xrpl::transactions

nix/devshell.nix

@@ -0,0 +1,140 @@
+{ pkgs, ... }:
+let
+  commonPackages = with pkgs; [
+    ccache
+    cmake
+    conan
+    gcovr
+    git
+    gnumake
+    llvmPackages_21.clang-tools
+    ninja
+    perl # needed for openssl
+    pkg-config
+    pre-commit
+    python314
+  ];
+
+  # Supported compiler versions
+  gccVersion = pkgs.lib.range 13 15;
+  clangVersions = pkgs.lib.range 18 21;
+
+  defaultCompiler = if pkgs.stdenv.isDarwin then "apple-clang" else "gcc";
+  defaultGccVersion = pkgs.lib.last gccVersion;
+  defaultClangVersion = pkgs.lib.last clangVersions;
+
+  strToCompilerEnv =
+    compiler: version:
+    (
+      if compiler == "gcc" then
+        let
+          gccPkg = pkgs."gcc${toString version}Stdenv" or null;
+        in
+        if gccPkg != null && builtins.elem version gccVersion then
+          gccPkg
+        else
+          throw "Invalid GCC version: ${toString version}. Must be one of: ${toString gccVersion}"
+      else if compiler == "clang" then
+        let
+          clangPkg = pkgs."llvmPackages_${toString version}".stdenv or null;
+        in
+        if clangPkg != null && builtins.elem version clangVersions then
+          clangPkg
+        else
+          throw "Invalid Clang version: ${toString version}. Must be one of: ${toString clangVersions}"
+      else if compiler == "apple-clang" || compiler == "none" then
+        pkgs.stdenvNoCC
+      else
+        throw "Invalid compiler: ${compiler}. Must be one of: gcc, clang, apple-clang, none"
+    );
+
+  # Helper function to create a shell with a specific compiler
+  makeShell =
+    {
+      compiler ? defaultCompiler,
+      version ? (
+        if compiler == "gcc" then
+          defaultGccVersion
+        else if compiler == "clang" then
+          defaultClangVersion
+        else
+          null
+      ),
+    }:
+    let
+      compilerStdEnv = strToCompilerEnv compiler version;
+
+      compilerName =
+        if compiler == "apple-clang" then
+          "clang"
+        else if compiler == "none" then
+          null
+        else
+          compiler;
+
+      gccOnMacWarning =
+        if pkgs.stdenv.isDarwin && compiler == "gcc" then
+          ''
+            echo "WARNING: Using GCC on macOS with Conan may not work."
+            echo "         Consider using 'nix develop .#clang' or the default shell instead."
+            echo ""
+          ''
+        else
+          "";
+
+      compilerVersion =
+        if compilerName != null then
+          ''
+            echo "Compiler: "
+            ${compilerName} --version
+          ''
+        else
+          ''
+            echo "No compiler specified - using system compiler"
+          '';
+
+      shellAttrs = {
+        packages = commonPackages;
+
+        shellHook = ''
+          echo "Welcome to xrpld development shell";
+          ${gccOnMacWarning}${compilerVersion}
+        '';
+      };
+    in
+    pkgs.mkShell.override { stdenv = compilerStdEnv; } shellAttrs;
+
+  # Generate shells for each compiler version
+  gccShells = builtins.listToAttrs (
+    map (version: {
+      name = "gcc${toString version}";
+      value = makeShell {
+        compiler = "gcc";
+        version = version;
+      };
+    }) gccVersion
+  );
+
+  clangShells = builtins.listToAttrs (
+    map (version: {
+      name = "clang${toString version}";
+      value = makeShell {
+        compiler = "clang";
+        version = version;
+      };
+    }) clangVersions
+  );
+
+in
+gccShells
+// clangShells
+// {
+  # Default shells
+  default = makeShell { };
+  gcc = makeShell { compiler = "gcc"; };
+  clang = makeShell { compiler = "clang"; };
+
+  # No compiler
+  no-compiler = makeShell { compiler = "none"; };
+  apple-clang = makeShell { compiler = "apple-clang"; };
+}

nix/utils.nix

@@ -0,0 +1,19 @@
+{ nixpkgs }:
+{
+  forEachSystem =
+    function:
+    nixpkgs.lib.genAttrs
+      [
+        "x86_64-linux"
+        "aarch64-linux"
+        "x86_64-darwin"
+        "aarch64-darwin"
+      ]
+      (
+        system:
+        function {
+          inherit system;
+          pkgs = import nixpkgs { inherit system; };
+        }
+      );
+}

scripts/generate_ledger_classes.py

@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+"""
+Generate C++ wrapper classes for XRP Ledger entry types from ledger_entries.macro.
+
+This script parses the ledger_entries.macro file and generates type-safe wrapper
+classes for each ledger entry type, similar to the transaction wrapper classes.
+
+Uses pcpp to preprocess the macro file and pyparsing to parse the DSL.
+"""
+
+# cspell:words sfields
+
+import io
+import argparse
+from pathlib import Path
+from jinja2 import Environment, FileSystemLoader
+import pyparsing as pp
+
+# Import common utilities
+from macro_parser_common import CppCleaner, parse_sfields_macro, parse_field_list
+
+
+def create_ledger_entry_parser():
+    """Create a pyparsing parser for LEDGER_ENTRY macros.
+
+    This parser extracts the full LEDGER_ENTRY macro call and parses its arguments
+    using pyparsing's nesting-aware delimited list parsing.
+    """
+    # Match the exact words
+    ledger_entry = pp.Keyword("LEDGER_ENTRY") | pp.Keyword("LEDGER_ENTRY_DUPLICATE")
+
+    # Define nested structures so pyparsing protects them
+    nested_braces = pp.original_text_for(pp.nested_expr("{", "}"))
+    nested_parens = pp.original_text_for(pp.nested_expr("(", ")"))
+
+    # Define standard text (anything that isn't a comma, parens, or braces)
+    plain_text = pp.Word(pp.printables + " \t\n", exclude_chars=",{}()")
+
+    # A single argument is any combination of the above
+    single_arg = pp.Combine(pp.OneOrMore(nested_braces | nested_parens | plain_text))
+    single_arg.set_parse_action(lambda t: t[0].strip())
+
+    # The arguments are a delimited list
+    args_list = pp.DelimitedList(single_arg)
+
+    # The full macro: LEDGER_ENTRY(args) or LEDGER_ENTRY_DUPLICATE(args)
+    macro_parser = (
+        ledger_entry + pp.Suppress("(") + pp.Group(args_list)("args") + pp.Suppress(")")
+    )
+
+    return macro_parser
+
+
+def parse_ledger_entry_args(args_list):
+    """Parse the arguments of a LEDGER_ENTRY macro call.
+
+    Args:
+        args_list: A list of parsed arguments from pyparsing, e.g.,
+                   ['ltACCOUNT_ROOT', '0x0061', 'AccountRoot', 'account', '({...})']
+
+    Returns:
+        A dict with parsed ledger entry information.
+    """
+    if len(args_list) < 5:
+        raise ValueError(
+            f"Expected at least 5 parts in LEDGER_ENTRY, got {len(args_list)}: {args_list}"
+        )
+
+    tag = args_list[0]
+    value = args_list[1]
+    name = args_list[2]
+    rpc_name = args_list[3]
+    fields_str = args_list[4]
+
+    # Parse fields: ({field1, field2, ...})
+    fields = parse_field_list(fields_str)
+
+    return {
+        "tag": tag,
+        "value": value,
+        "name": name,
+        "rpc_name": rpc_name,
+        "fields": fields,
+    }
+
+
+def parse_macro_file(file_path):
+    """Parse the ledger_entries.macro file and return a list of ledger entry definitions.
+
+    Uses pcpp to preprocess the file and pyparsing to parse the LEDGER_ENTRY macros.
+    """
+    with open(file_path, "r") as f:
+        c_code = f.read()
+
+    # Step 1: Clean the C++ code using pcpp
+    cleaner = CppCleaner("LEDGER_ENTRY_INCLUDE")
+    cleaner.parse(c_code)
+
+    out = io.StringIO()
+    cleaner.write(out)
+    clean_text = out.getvalue()
+
+    # Step 2: Parse the clean text using pyparsing
+    parser = create_ledger_entry_parser()
+    entries = []
+
+    for match, _, _ in parser.scan_string(clean_text):
+        # Extract the macro name and arguments
+        raw_args = match.args
+
+        # Parse the arguments
+        entry_data = parse_ledger_entry_args(raw_args)
+        entries.append(entry_data)
+
+    return entries
+
+
+def generate_cpp_class(entry_info, header_dir, jinja_env, field_types):
+    """Generate C++ header file for a ledger entry type."""
+    # Enrich field information with type data
+    for field in entry_info["fields"]:
+        field_name = field["name"]
+        if field_name in field_types:
+            field["typed"] = field_types[field_name]["typed"]
+            field["stiSuffix"] = field_types[field_name]["stiSuffix"]
+            field["typeData"] = field_types[field_name]["typeData"]
+        else:
+            # Unknown field - assume typed for safety
+            field["typed"] = True
+            field["stiSuffix"] = None
+            field["typeData"] = None
+
+    template = jinja_env.get_template("LedgerEntry.h.jinja2")
+
+    # Render the template
+    header_content = template.render(
+        name=entry_info["name"],
+        tag=entry_info["tag"],
+        value=entry_info["value"],
+        rpc_name=entry_info["rpc_name"],
+        fields=entry_info["fields"],
+    )
+
+    # Write header file
+    header_path = Path(header_dir) / f"{entry_info['name']}.h"
+    with open(header_path, "w") as f:
+        f.write(header_content)
+
+    print(f"Generated {header_path}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate C++ ledger entry classes from ledger_entries.macro"
+    )
+    parser.add_argument("macro_path", help="Path to ledger_entries.macro")
+    parser.add_argument(
+        "--header-dir",
+        help="Output directory for header files",
+        default="include/xrpl/protocol/ledger_objects",
+    )
+    parser.add_argument(
+        "--sfields-macro",
+        help="Path to sfields.macro (default: auto-detect from macro_path)",
+    )
+
+    args = parser.parse_args()
+
+    # Auto-detect sfields.macro path if not provided
+    if args.sfields_macro:
+        sfields_path = Path(args.sfields_macro)
+    else:
+        # Assume sfields.macro is in the same directory as ledger_entries.macro
+        macro_path = Path(args.macro_path)
+        sfields_path = macro_path.parent / "sfields.macro"
+
+    # Parse sfields.macro to get field type information
+    print(f"Parsing {sfields_path}...")
+    field_types = parse_sfields_macro(sfields_path)
+    print(
+        f"Found {len(field_types)} field definitions ({sum(1 for f in field_types.values() if f['typed'])} typed, {sum(1 for f in field_types.values() if not f['typed'])} untyped)\n"
+    )
+
+    # Parse the file
+    entries = parse_macro_file(args.macro_path)
+
+    print(f"Found {len(entries)} ledger entries\n")
+
+    for entry in entries:
+        print(f"Ledger Entry: {entry['name']}")
+        print(f"  Tag: {entry['tag']}")
+        print(f"  Value: {entry['value']}")
+        print(f"  RPC Name: {entry['rpc_name']}")
+        print(f"  Fields: {len(entry['fields'])}")
+        for field in entry["fields"]:
+            mpt_info = f" ({field['mpt_support']})" if "mpt_support" in field else ""
+            print(f"    - {field['name']}: {field['requirement']}{mpt_info}")
+        print()
+
+    # Set up Jinja2 environment
+    script_dir = Path(__file__).parent
+    template_dir = script_dir / "templates"
+    jinja_env = Environment(loader=FileSystemLoader(str(template_dir)))
+
+    # Generate C++ classes
+    header_dir = Path(args.header_dir)
+    header_dir.mkdir(parents=True, exist_ok=True)
+
+    for entry in entries:
+        generate_cpp_class(entry, header_dir, jinja_env, field_types)
+
+    print(f"\nGenerated {len(entries)} ledger entry classes")
+
+
+if __name__ == "__main__":
+    main()

scripts/generate_tx_classes.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+"""
+Parse transactions.macro file to extract transaction information
+and generate C++ classes for each transaction type.
+
+Uses pcpp to preprocess the macro file and pyparsing to parse the DSL.
+"""
+# cspell:words sfields
+
+import io
+import argparse
+from pathlib import Path
+from jinja2 import Environment, FileSystemLoader
+import pyparsing as pp
+
+# Import common utilities
+from macro_parser_common import CppCleaner, parse_sfields_macro, parse_field_list
+
+
+def create_transaction_parser():
+    """Create a pyparsing parser for TRANSACTION macros.
+
+    This parser extracts the full TRANSACTION macro call and parses its arguments
+    using pyparsing's nesting-aware delimited list parsing.
+    """
+    # Define nested structures so pyparsing protects them
+    nested_braces = pp.original_text_for(pp.nested_expr("{", "}"))
+    nested_parens = pp.original_text_for(pp.nested_expr("(", ")"))
+
+    # Define standard text (anything that isn't a comma, parens, or braces)
+    plain_text = pp.Word(pp.printables + " \t\n", exclude_chars=",{}()")
+
+    # A single argument is any combination of the above
+    single_arg = pp.Combine(pp.OneOrMore(nested_braces | nested_parens | plain_text))
+    single_arg.set_parse_action(lambda t: t[0].strip())
+
+    # The arguments are a delimited list
+    args_list = pp.DelimitedList(single_arg)
+
+    # The full macro: TRANSACTION(args)
+    macro_parser = (
+        pp.Keyword("TRANSACTION")
+        + pp.Suppress("(")
+        + pp.Group(args_list)("args")
+        + pp.Suppress(")")
+    )
+
+    return macro_parser
+
+
+def parse_transaction_args(args_list):
+    """Parse the arguments of a TRANSACTION macro call.
+
+    Args:
+        args_list: A list of parsed arguments from pyparsing, e.g.,
+                   ['ttPAYMENT', '0', 'Payment', 'Delegation::delegable',
+                    'uint256{}', 'createAcct', '({...})']
+
+    Returns:
+        A dict with parsed transaction information.
+    """
+    if len(args_list) < 7:
+        raise ValueError(
+            f"Expected at least 7 parts in TRANSACTION, got {len(args_list)}: {args_list}"
+        )
+
+    tag = args_list[0]
+    value = args_list[1]
+    name = args_list[2]
+    delegable = args_list[3]
+    amendments = args_list[4]
+    privileges = args_list[5]
+    fields_str = args_list[6]
+
+    # Parse fields: ({field1, field2, ...})
+    fields = parse_field_list(fields_str)
+
+    return {
+        "tag": tag,
+        "value": value,
+        "name": name,
+        "delegable": delegable,
+        "amendments": amendments,
+        "privileges": privileges,
+        "fields": fields,
+    }
+
+
+def parse_macro_file(filepath):
+    """Parse the transactions.macro file.
+
+    Uses pcpp to preprocess the file and pyparsing to parse the TRANSACTION macros.
+    """
+    with open(filepath, "r") as f:
+        c_code = f.read()
+
+    # Step 1: Clean the C++ code using pcpp
+    cleaner = CppCleaner("TRANSACTION_INCLUDE")
+    cleaner.parse(c_code)
+
+    out = io.StringIO()
+    cleaner.write(out)
+    clean_text = out.getvalue()
+
+    # Step 2: Parse the clean text using pyparsing
+    parser = create_transaction_parser()
+    transactions = []
+
+    for match, _, _ in parser.scan_string(clean_text):
+        # Extract the macro name and arguments
+        raw_args = match.args
+
+        # Parse the arguments
+        tx_data = parse_transaction_args(raw_args)
+        transactions.append(tx_data)
+
+    return transactions
+
+
+def generate_cpp_class(tx_info, header_dir, jinja_env, field_types):
+    """Generate a header-only template class for a transaction using Jinja2 templates."""
+    class_name = tx_info["name"]
+
+    # Enrich field information with type data
+    for field in tx_info["fields"]:
+        field_name = field["name"]
+        if field_name in field_types:
+            field["typed"] = field_types[field_name]["typed"]
+            field["stiSuffix"] = field_types[field_name]["stiSuffix"]
+            field["typeData"] = field_types[field_name]["typeData"]
+        else:
+            # Unknown field - assume typed for safety
+            field["typed"] = True
+            field["stiSuffix"] = None
+            field["typeData"] = None
+
+    # Load template
+    header_template = jinja_env.get_template("Transaction.h.jinja2")
+
+    # Render header
+    header_content = header_template.render(tx_info)
+    header_path = header_dir / f"{class_name}.h"
+    with open(header_path, "w") as f:
+        f.write(header_content)
+
+    return header_path
+
+
+# TransactionBase is a static file in the repository at:
+# - include/xrpl/protocol/TransactionBase.h
+# - src/libxrpl/protocol/TransactionBase.cpp
+# It is NOT generated by this script.
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate C++ transaction classes from transactions.macro"
+    )
+    parser.add_argument("macro_path", help="Path to transactions.macro")
+    parser.add_argument(
+        "--header-dir",
+        help="Output directory for header files",
+        default="include/xrpl/protocol/transactions",
+    )
+    parser.add_argument(
+        "--sfields-macro",
+        help="Path to sfields.macro (default: auto-detect from macro_path)",
+    )
+
+    args = parser.parse_args()
+
+    # Auto-detect sfields.macro path if not provided
+    if args.sfields_macro:
+        sfields_path = Path(args.sfields_macro)
+    else:
+        # Assume sfields.macro is in the same directory as transactions.macro
+        macro_path = Path(args.macro_path)
+        sfields_path = macro_path.parent / "sfields.macro"
+
+    # Parse sfields.macro to get field type information
+    print(f"Parsing {sfields_path}...")
+    field_types = parse_sfields_macro(sfields_path)
+    print(
+        f"Found {len(field_types)} field definitions ({sum(1 for f in field_types.values() if f['typed'])} typed, {sum(1 for f in field_types.values() if not f['typed'])} untyped)\n"
+    )
+
+    # Parse the file
+    transactions = parse_macro_file(args.macro_path)
+
+    print(f"Found {len(transactions)} transactions\n")
+
+    for tx in transactions:
+        print(f"Transaction: {tx['name']}")
+        print(f"  Tag: {tx['tag']}")
+        print(f"  Value: {tx['value']}")
+        print(f"  Fields: {len(tx['fields'])}")
+        for field in tx["fields"]:
+            print(f"    - {field['name']}: {field['requirement']}")
+        print()
+
+    # Set up output directory
+    header_dir = Path(args.header_dir)
+    header_dir.mkdir(parents=True, exist_ok=True)
+
+    print(f"\nGenerating header-only template classes...")
+    print(f"  Headers: {header_dir}\n")
+
+    # Set up Jinja2 environment
+    script_dir = Path(__file__).parent
+    template_dir = script_dir / "templates"
+    jinja_env = Environment(loader=FileSystemLoader(template_dir))
+
+    generated_files = []
+    for tx_info in transactions:
+        header_path = generate_cpp_class(tx_info, header_dir, jinja_env, field_types)
+        generated_files.append(header_path)
+        print(f"  Generated: {tx_info['name']}.h")
+
+    print(
+        f"\n✓ Successfully generated {len(transactions)} transaction classes ({len(generated_files)} header files)"
+    )
+    print(f"  Headers: {header_dir.absolute()}")
+
+
+if __name__ == "__main__":
+    main()

scripts/macro_parser_common.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""
+Common utilities for parsing XRP Ledger macro files.
+
+This module provides shared functionality for parsing transactions.macro
+and ledger_entries.macro files using pcpp and pyparsing.
+"""
+# cspell:words sfields
+
+import re
+import pyparsing as pp
+from pcpp import Preprocessor
+
+
+class CppCleaner(Preprocessor):
+    """C preprocessor that removes C++ noise while preserving macro calls."""
+
+    def __init__(self, macro_include_name):
+        """
+        Initialize the preprocessor.
+
+        Args:
+            macro_include_name: The name of the include flag to set to 0
+                               (e.g., "TRANSACTION_INCLUDE" or "LEDGER_ENTRY_INCLUDE")
+        """
+        super(CppCleaner, self).__init__()
+        # Define flags so #if blocks evaluate correctly
+        # We set the include flag to 0 so includes are skipped
+        self.define(f"{macro_include_name} 0")
+        # Suppress line directives
+        self.line_directive = None
+
+    def on_error(self, file, line, msg):
+        # Ignore #error directives
+        pass
+
+    def on_include_not_found(
+        self, is_malformed, is_system_include, curdir, includepath
+    ):
+        # Ignore missing headers
+        pass
+
+
+def parse_sfields_macro(sfields_path):
+    """
+    Parse sfields.macro to determine which fields are typed vs untyped.
+
+    Returns a dict mapping field names to their type information:
+    {
+        'sfMemos': {'typed': False, 'stiSuffix': 'ARRAY', 'typeData': {...}},
+        'sfAmount': {'typed': True, 'stiSuffix': 'AMOUNT', 'typeData': {...}},
+        ...
+    }
+    """
+    # Mapping from STI suffix to C++ type for untyped fields
+    UNTYPED_TYPE_MAP = {
+        "ARRAY": {
+            "getter_method": "getFieldArray",
+            "setter_method": "setFieldArray",
+            "setter_use_brackets": False,
+            "setter_type": "STArray const&",
+            "return_type": "STArray const&",
+            "return_type_optional": "std::optional<std::reference_wrapper<STArray const>>",
+        },
+        "OBJECT": {
+            "getter_method": "getFieldObject",
+            "setter_method": "setFieldObject",
+            "setter_use_brackets": False,
+            "setter_type": "STObject const&",
+            "return_type": "STObject",
+            "return_type_optional": "std::optional<STObject>",
+        },
+        "PATHSET": {
+            "getter_method": "getFieldPathSet",
+            "setter_method": "setFieldPathSet",
+            "setter_use_brackets": False,
+            "setter_type": "STPathSet const&",
+            "return_type": "STPathSet const&",
+            "return_type_optional": "std::optional<std::reference_wrapper<STPathSet const>>",
+        },
+    }
+
+    field_info = {}
+
+    with open(sfields_path, "r") as f:
+        content = f.read()
+
+    # Parse TYPED_SFIELD entries
+    # Format: TYPED_SFIELD(sfName, stiSuffix, fieldValue, ...)
+    typed_pattern = r"TYPED_SFIELD\s*\(\s*(\w+)\s*,\s*(\w+)\s*,"
+    for match in re.finditer(typed_pattern, content):
+        field_name = match.group(1)
+        sti_suffix = match.group(2)
+        field_info[field_name] = {
+            "typed": True,
+            "stiSuffix": sti_suffix,
+            "typeData": {
+                "getter_method": "at",
+                "setter_method": "",
+                "setter_use_brackets": True,
+                "setter_type": f"SF_{sti_suffix}::type::value_type const&",
+                "return_type": f"SF_{sti_suffix}::type::value_type",
+                "return_type_optional": f"std::optional<SF_{sti_suffix}::type::value_type>",
+            },
+        }
+
+    # Parse UNTYPED_SFIELD entries
+    # Format: UNTYPED_SFIELD(sfName, stiSuffix, fieldValue, ...)
+    untyped_pattern = r"UNTYPED_SFIELD\s*\(\s*(\w+)\s*,\s*(\w+)\s*,"
+    for match in re.finditer(untyped_pattern, content):
+        field_name = match.group(1)
+        sti_suffix = match.group(2)
+        type_data = UNTYPED_TYPE_MAP.get(
+            sti_suffix, UNTYPED_TYPE_MAP.get("OBJECT")
+        )  # Default to OBJECT
+        field_info[field_name] = {
+            "typed": False,
+            "stiSuffix": sti_suffix,
+            "typeData": type_data,
+        }
+
+    return field_info
+
+
+def create_field_list_parser():
+    """Create a pyparsing parser for field lists like '({...})'."""
+    # A field identifier (e.g., sfDestination, soeREQUIRED, soeMPTSupported)
+    field_identifier = pp.Word(pp.alphas + "_", pp.alphanums + "_")
+
+    # A single field definition: {sfName, soeREQUIRED, ...}
+    # Allow optional trailing comma inside the braces
+    field_def = (
+        pp.Suppress("{")
+        + pp.Group(pp.DelimitedList(field_identifier) + pp.Optional(pp.Suppress(",")))(
+            "parts"
+        )
+        + pp.Suppress("}")
+    )
+
+    # The field list: ({field1, field2, ...}) or ({}) for empty lists
+    # Allow optional trailing comma after the last field definition
+    field_list = (
+        pp.Suppress("(")
+        + pp.Suppress("{")
+        + pp.Group(
+            pp.Optional(pp.DelimitedList(field_def) + pp.Optional(pp.Suppress(",")))
+        )("fields")
+        + pp.Suppress("}")
+        + pp.Suppress(")")
+    )
+
+    return field_list
+
+
+def parse_field_list(fields_str):
+    """Parse a field list string like '({...})' using pyparsing.
+
+    Args:
+        fields_str: A string like '({
+            {sfDestination, soeREQUIRED},
+            {sfAmount, soeREQUIRED, soeMPTSupported}
+        })'
+
+    Returns:
+        A list of field dicts with 'name', 'requirement', 'flags', and 'supports_mpt'.
+    """
+    parser = create_field_list_parser()
+
+    try:
+        result = parser.parse_string(fields_str, parse_all=True)
+        fields = []
+
+        for field_parts in result.fields:
+            if len(field_parts) < 2:
+                continue
+
+            field_name = field_parts[0]
+            requirement = field_parts[1]
+            flags = list(field_parts[2:]) if len(field_parts) > 2 else []
+            supports_mpt = "soeMPTSupported" in flags
+
+            fields.append(
+                {
+                    "name": field_name,
+                    "requirement": requirement,
+                    "flags": flags,
+                    "supports_mpt": supports_mpt,
+                }
+            )
+
+        return fields
+    except pp.ParseException as e:
+        raise ValueError(f"Failed to parse field list: {e}")

scripts/requirements.txt

@@ -0,0 +1,14 @@
+# Python dependencies for XRP Ledger code generation scripts
+#
+# These packages are required to run the code generation scripts that
+# parse macro files and generate C++ wrapper classes.
+# cspell:words pyparsing
+
+# C preprocessor for Python - used to preprocess macro files
+pcpp>=1.30
+
+# Parser combinator library - used to parse the macro DSL
+pyparsing>=3.0.0
+
+# Template engine - used to generate C++ code from templates
+Jinja2>=3.0.0

scripts/templates/LedgerEntry.h.jinja2

@@ -0,0 +1,176 @@
+#pragma once
+
+#include <xrpl/protocol/STLedgerEntry.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/LedgerEntryBase.h>
+#include <xrpl/protocol_autogen/LedgerEntryBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::ledger_entries {
+
+// Forward declaration
+class {{ name }}Builder;
+
+/**
+ * Ledger Entry: {{ name }}
+ * Type: {{ tag }} ({{ value }})
+ * RPC Name: {{ rpc_name }}
+ *
+ * Immutable wrapper around SLE providing type-safe field access.
+ * Use {{ name }}Builder to construct new ledger entries.
+ */
+class {{ name }} : public LedgerEntryBase
+{
+public:
+    static constexpr LedgerEntryType entryType = {{ tag }};
+
+    /**
+     * Construct a {{ name }} ledger entry wrapper from an existing SLE object.
+     * @throws std::runtime_error if the ledger entry type doesn't match.
+     */
+    explicit {{ name }}(SLE const& sle)
+        : LedgerEntryBase(sle)
+    {
+        // Verify ledger entry type
+        if (sle.getType() != entryType)
+        {
+            throw std::runtime_error("Invalid ledger entry type for {{ name }}");
+        }
+    }
+
+    // Ledger entry-specific field getters
+{%- for field in fields %}
+{%- if field.typed %}
+
+    /**
+     * Get {{ field.name }} ({{ field.requirement }})
+{%- if field.mpt_support %}
+     * MPT Support: {{ field.mpt_support }}
+{%- endif %}
+     */
+{%- if field.requirement == 'soeREQUIRED' %}
+    [[nodiscard]]
+    {{ field.typeData.return_type }}
+    get{{ field.name[2:] }}() const
+    {
+        return this->sle_.{{ field.typeData.getter_method }}({{ field.name }});
+    }
+{%- else %}
+    [[nodiscard]]
+    {{ field.typeData.return_type_optional }}
+    get{{ field.name[2:] }}() const
+    {
+        if (has{{ field.name[2:] }}())
+            return this->sle_.{{ field.typeData.getter_method }}({{ field.name }});
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    has{{ field.name[2:] }}() const
+    {
+        return this->sle_.isFieldPresent({{ field.name }});
+    }
+{%- endif %}
+{%- else %}
+
+    /**
+     * Get {{ field.name }} ({{ field.requirement }})
+{%- if field.mpt_support %}
+     * MPT Support: {{ field.mpt_support }}
+{%- endif %}
+     * Note: This is an untyped field ({{ field.cppType }}).
+     */
+{%- if field.requirement == 'soeREQUIRED' %}
+    [[nodiscard]]
+    {{ field.typeData.return_type }}
+    get{{ field.name[2:] }}() const
+    {
+        return this->sle_.{{ field.typeData.getter_method }}({{ field.name }});
+    }
+{%- else %}
+    [[nodiscard]]
+    {{ field.typeData.return_type_optional }}
+    get{{ field.name[2:] }}() const
+    {
+        if (this->sle_.isFieldPresent({{ field.name }}))
+            return this->sle_.{{ field.typeData.getter_method }}({{ field.name }});
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    has{{ field.name[2:] }}() const
+    {
+        return this->sle_.isFieldPresent({{ field.name }});
+    }
+{%- endif %}
+{%- endif %}
+{%- endfor %}
+};
+
+/**
+ * Builder for {{ name }} 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 {{ name }}Builder : public LedgerEntryBuilderBase<{{ name }}Builder>
+{
+public:
+    {{ name }}Builder()
+    {
+        // Initialize with ledger entry type
+        object_[sfLedgerEntryType] = {{ tag }};
+    }
+
+    {{ name }}Builder(SLE const& sle)
+    {
+        if (object_[sfLedgerEntryType] != {{ tag }})
+        {
+            throw std::runtime_error("Invalid ledger entry type for {{ name }}");
+        }
+        object_ = sle;
+    }
+
+    // Ledger entry-specific field setters
+{%- for field in fields %}
+
+    /**
+     * Set {{ field.name }} ({{ field.requirement }})
+{%- if field.mpt_support %}
+     * MPT Support: {{ field.mpt_support }}
+{%- endif %}
+     * @return Reference to this builder for method chaining.
+     */
+    {{ name }}Builder&
+    set{{ field.name[2:] }}({{ field.typeData.setter_type }} value)
+    {
+        {%- if field.stiSuffix == 'ISSUE' %}
+        object_[{{ field.name }}] = STIssue({{ field.name }}, value);
+        {%- elif field.typeData.setter_use_brackets %}
+        object_[{{ field.name }}] = value;
+        {%- else %}
+        object_.{{ field.typeData.setter_method }}({{ field.name }}, value);
+        {%- endif %}
+        return *this;
+    }
+{%- endfor %}
+
+    /**
+     * Build and return the completed {{ name }} wrapper.
+     * @return The constructed ledger entry wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid ledger entry.
+     */
+    {{ name }}
+    build(uint256 const& index)
+    {
+        return {{ name }}{SLE(object_, index)};
+    }
+};
+
+}  // namespace xrpl::ledger_entries

scripts/templates/Transaction.h.jinja2

@@ -0,0 +1,179 @@
+#pragma once
+
+#include <xrpl/protocol/STTx.h>
+#include <xrpl/protocol/STParsedJSON.h>
+#include <xrpl/protocol/jss.h>
+#include <xrpl/protocol_autogen/TransactionBase.h>
+#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
+#include <xrpl/json/json_value.h>
+
+#include <stdexcept>
+#include <optional>
+
+namespace xrpl::transactions {
+
+// Forward declaration
+class {{ name }}Builder;
+
+/**
+ * Transaction: {{ name }}
+ * Type: {{ tag }} ({{ value }})
+ * Delegable: {{ delegable }}
+ * Amendment: {{ amendments }}
+ * Privileges: {{ privileges }}
+ *
+ * Immutable wrapper around STTx providing type-safe field access.
+ * Use {{ name }}Builder to construct new transactions.
+ */
+class {{ name }} : public TransactionBase
+{
+public:
+    static constexpr xrpl::TxType txType = {{ tag }};
+
+    /**
+     * Construct a {{ name }} transaction wrapper from an existing STTx object.
+     * @throws std::runtime_error if the transaction type doesn't match.
+     */
+    explicit {{ name }}(STTx const& tx)
+        : TransactionBase(tx)
+    {
+        // Verify transaction type
+        if (tx.getTxnType() != txType)
+        {
+            throw std::runtime_error("Invalid transaction type for {{ name }}");
+        }
+    }
+
+    // Transaction-specific field getters
+{%- for field in fields %}
+{%- if field.typed %}
+
+    /**
+     * Get {{ field.name }} ({{ field.requirement }})
+{%- if field.supports_mpt %}
+     * Note: This field supports MPT (Multi-Purpose Token) amounts.
+{%- endif %}
+     */
+{%- if field.requirement == 'soeREQUIRED' %}
+    [[nodiscard]]
+    {{ field.typeData.return_type }}
+    get{{ field.name[2:] }}() const
+    {
+        return this->tx_.{{ field.typeData.getter_method }}({{ field.name }});
+    }
+{%- else %}
+    [[nodiscard]]
+    {{ field.typeData.return_type_optional }}
+    get{{ field.name[2:] }}() const
+    {
+        if (has{{ field.name[2:] }}())
+        {
+            return this->tx_.{{ field.typeData.getter_method }}({{ field.name }});
+        }
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    has{{ field.name[2:] }}() const
+    {
+        return this->tx_.isFieldPresent({{ field.name }});
+    }
+{%- endif %}
+{%- else %}
+    /**
+     * Get {{ field.name }} ({{ field.requirement }})
+{%- if field.supports_mpt %}
+     * Note: This field supports MPT (Multi-Purpose Token) amounts.
+{%- endif %}
+     * Note: This is an untyped field
+     */
+{%- if field.requirement == 'soeREQUIRED' %}
+    [[nodiscard]]
+    {{ field.typeData.return_type }}
+    get{{ field.name[2:] }}() const
+    {
+        return this->tx_.{{ field.typeData.getter_method }}({{ field.name }});
+    }
+{%- else %}
+    [[nodiscard]]
+    {{ field.typeData.return_type_optional }}
+    get{{ field.name[2:] }}() const
+    {
+        if (this->tx_.isFieldPresent({{ field.name }}))
+            return this->tx_.{{ field.typeData.getter_method }}({{ field.name }});
+        return std::nullopt;
+    }
+
+    [[nodiscard]]
+    bool
+    has{{ field.name[2:] }}() const
+    {
+        return this->tx_.isFieldPresent({{ field.name }});
+    }
+{%- endif %}
+{%- endif %}
+{%- endfor %}
+};
+
+/**
+ * Builder for {{ name }} 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 {{ name }}Builder : public TransactionBuilderBase<{{ name }}Builder>
+{
+public:
+    {{ name }}Builder()
+    {
+        // Initialize with transaction type
+        object_[sfTransactionType]  = {{ tag }};
+    }
+
+    {{ name }}Builder(STTx const& tx)
+    {
+        if (tx.getTxnType() != {{ tag }})
+        {
+            throw std::runtime_error("Invalid transaction type for {{ name }}Builder");
+        }
+        object_ = tx;
+    }
+
+    // Transaction-specific field setters
+{%- for field in fields %}
+
+    /**
+     * Set {{ field.name }} ({{ field.requirement }})
+{%- if field.supports_mpt %}
+     * Note: This field supports MPT (Multi-Purpose Token) amounts.
+{%- endif %}
+     * @return Reference to this builder for method chaining.
+     */
+    {{ name }}Builder&
+    set{{ field.name[2:] }}({{ field.typeData.setter_type }} value)
+    {
+        {%- if field.stiSuffix == 'ISSUE' %}
+        object_[{{ field.name }}] = STIssue({{ field.name }}, value);
+        {%- elif field.typeData.setter_use_brackets %}
+        object_[{{ field.name }}] = value;
+        {%- else %}
+        object_.{{ field.typeData.setter_method }}({{ field.name }}, value);
+        {%- endif %}
+        return *this;
+    }
+{%- endfor %}
+
+    /**
+     * Build and return the completed {{ name }} wrapper.
+     * @return The constructed transaction wrapper.
+     * @throws std::runtime_error if the JSON cannot be parsed into a valid transaction.
+     */
+    {{ name }}
+    build()
+    {
+        return {{ name }}(STTx(std::move(object_)));
+    }
+};
+
+}  // namespace xrpl::transactions

src/libxrpl/protocol_autogen/placeholder.cpp

@@ -0,0 +1 @@
+// This file is a placeholder to ensure the protocol_autogen module can be built.