fix: ci build action and coverage workflow fixes

- move --target before ${VERBOSE_FLAG} so [ci-ga-cmake-verbose] doesn't
  swallow the target argument
- add stdlib: default option for GCC entries (GCC doesn't support -stdlib flag)
- pass stdlib explicitly to coverage build step
- remove dead CMAKE_BUILD_PARALLEL_LEVEL export (doesn't persist across steps,
  and build step already uses --parallel)
- remove duplicate ccache config block

.codecov.yml

@@ -0,0 +1,6 @@
+coverage:
+  status:
+    project:
+      default:
+        target: 60%
+        threshold: 2%

.github/actions/xahau-ga-build/action.yml

@@ -2,6 +2,14 @@ name: build
 description: 'Builds the project with ccache integration'
 
 inputs:
+  cmake-target:
+    description: 'CMake target to build'
+    required: false
+    default: all
+  cmake-args:
+    description: 'Additional CMake arguments'
+    required: false
+    default: null
   generator:
     description: 'CMake generator to use'
     required: true
@@ -20,6 +28,10 @@ inputs:
     description: 'C++ compiler to use'
     required: false
     default: ''
+  gcov:
+    description: 'Gcov to use'
+    required: false
+    default: ''
   compiler-id:
     description: 'Unique identifier: compiler-version-stdlib[-gccversion] (e.g. clang-14-libstdcxx-gcc11, gcc-13-libstdcxx)'
     required: false
@@ -41,10 +53,11 @@ inputs:
     required: false
     default: 'dev'
   stdlib:
-    description: 'C++ standard library to use'
+    description: 'C++ standard library to use (default = compiler default, e.g. GCC always uses libstdc++)'
     required: true
     type: choice
     options:
+      - default
       - libstdcxx
       - libcxx
   clang_gcc_toolchain:
@@ -87,11 +100,6 @@ runs:
         export CCACHE_CONFIGPATH="$HOME/.config/ccache/ccache.conf"
         echo "CCACHE_CONFIGPATH=$CCACHE_CONFIGPATH" >> $GITHUB_ENV
 
-        # Keep config separate from cache_dir so configs aren't swapped when CCACHE_DIR changes between steps
-        mkdir -p ~/.config/ccache
-        export CCACHE_CONFIGPATH="$HOME/.config/ccache/ccache.conf"
-        echo "CCACHE_CONFIGPATH=$CCACHE_CONFIGPATH" >> $GITHUB_ENV
-
         # Configure ccache settings AFTER cache restore (prevents stale cached config)
         ccache --set-config=max_size=${{ inputs.ccache_max_size }}
         ccache --set-config=hash_dir=${{ inputs.ccache_hash_dir }}
@@ -122,6 +130,10 @@ runs:
           export CXX="${{ inputs.cxx }}"
         fi
 
+        if [ -n "${{ inputs.gcov }}" ]; then
+          ln -sf /usr/bin/${{ inputs.gcov }} /usr/local/bin/gcov
+        fi
+
         # Create wrapper toolchain that overlays ccache on top of Conan's toolchain
         # This enables ccache for the main app build without affecting Conan dependency builds
         if [ "${{ inputs.ccache_enabled }}" = "true" ]; then
@@ -183,7 +195,8 @@ runs:
           -G "${{ inputs.generator }}" \
           ${CMAKE_CXX_FLAGS:+-DCMAKE_CXX_FLAGS="$CMAKE_CXX_FLAGS"} \
           -DCMAKE_TOOLCHAIN_FILE:FILEPATH=${TOOLCHAIN_FILE} \
-          -DCMAKE_BUILD_TYPE=${{ inputs.configuration }}
+          -DCMAKE_BUILD_TYPE=${{ inputs.configuration }} \
+          ${{ inputs.cmake-args }}
 
     - name: Show ccache config before build
       if: inputs.ccache_enabled == 'true'
@@ -207,7 +220,7 @@ runs:
           VERBOSE_FLAG="-- -v"
         fi
 
-        cmake --build . --config ${{ inputs.configuration }} --parallel $(nproc) ${VERBOSE_FLAG}
+        cmake --build . --config ${{ inputs.configuration }} --parallel $(nproc) --target ${{ inputs.cmake-target }} ${VERBOSE_FLAG}
 
     - name: Show ccache statistics
       if: inputs.ccache_enabled == 'true'

.github/actions/xahau-ga-dependencies/action.yml

@@ -134,10 +134,17 @@ runs:
     - name: Export custom recipes
       shell: bash
       run: |
-        conan export external/snappy --version 1.1.10 --user xahaud --channel stable
-        conan export external/soci --version 4.0.3 --user xahaud --channel stable
-        conan export external/wasmedge --version 0.11.2 --user xahaud --channel stable
-
+        # Export snappy if not already exported
+        conan list snappy/1.1.10@xahaud/stable 2>/dev/null | (grep -q "not found" && exit 1 || exit 0) || \
+          conan export external/snappy --version 1.1.10 --user xahaud --channel stable
+        
+        # Export soci if not already exported
+        conan list soci/4.0.3@xahaud/stable 2>/dev/null | (grep -q "not found" && exit 1 || exit 0) || \
+          conan export external/soci --version 4.0.3 --user xahaud --channel stable
+        
+        # Export wasmedge if not already exported
+        conan list wasmedge/0.11.2@xahaud/stable 2>/dev/null | (grep -q "not found" && exit 1 || exit 0) || \
+          conan export external/wasmedge --version 0.11.2 --user xahaud --channel stable
     - name: Install dependencies
       shell: bash
       env:

.github/workflows/verify-generated-headers.yml

@@ -18,12 +18,23 @@ jobs:
             generator: bash ./hook/generate_sfcodes.sh
           - target: hook/tts.h
             generator: ./hook/generate_tts.sh
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
+    env:
+      CLANG_VERSION: 10
     name: ${{ matrix.target }}
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
 
+      - name: Download and install clang-format
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y libtinfo5
+          curl -LO https://github.com/llvm/llvm-project/releases/download/llvmorg-10.0.1/clang+llvm-10.0.1-x86_64-linux-gnu-ubuntu-16.04.tar.xz
+          tar -xf clang+llvm-10.0.1-x86_64-linux-gnu-ubuntu-16.04.tar.xz
+          sudo mv clang+llvm-10.0.1-x86_64-linux-gnu-ubuntu-16.04 /opt/clang-10
+          sudo ln -s /opt/clang-10/bin/clang-format /usr/local/bin/clang-format-10
+
       - name: Verify ${{ matrix.target }}
         run: |
           set -euo pipefail

.github/workflows/xahau-ga-macos.yml

@@ -43,14 +43,22 @@ jobs:
       # To isolate environments for each Runner, instead of installing globally with brew, 
       # use mise to isolate environments for each Runner directory.
       - name: Setup toolchain (mise)
-        uses: jdx/mise-action@v2
+        uses: jdx/mise-action@v3.6.1
         with:
+          cache: false
           install: true
+          mise_toml: |
+            [tools]
+            cmake = "3.23.1"
+            python = "3.12"
+            pipx = "latest"
+            conan = "2"
+            ninja = "latest"
+            ccache = "latest"
 
       - name: Install tools via mise
         run: |
           mise install
-          mise use cmake@3.23.1 python@3.12 pipx@latest conan@2 ninja@latest ccache@latest
           mise reshim
           echo "$HOME/.local/share/mise/shims" >> "$GITHUB_PATH"
 

.github/workflows/xahau-ga-nix.yml

@@ -46,8 +46,9 @@ jobs:
                   "cc": "gcc-11",
                   "cxx": "g++-11",
                   "compiler_version": 11,
-                  "stdlib": "libstdcxx",
-                  "configuration": "Debug"
+                  "stdlib": "default",
+                  "configuration": "Debug",
+                  "job_type": "build"
               },
               {
                   "compiler_id": "gcc-13-libstdcxx",
@@ -55,8 +56,20 @@ jobs:
                   "cc": "gcc-13",
                   "cxx": "g++-13",
                   "compiler_version": 13,
-                  "stdlib": "libstdcxx",
-                  "configuration": "Debug"
+                  "stdlib": "default",
+                  "configuration": "Debug",
+                  "job_type": "build"
+              },
+              {
+                  "compiler_id": "gcc-13-libstdcxx",
+                  "compiler": "gcc",
+                  "cc": "gcc-13",
+                  "cxx": "g++-13",
+                  "gcov": "gcov-13",
+                  "compiler_version": 13,
+                  "stdlib": "default",
+                  "configuration": "Debug",
+                  "job_type": "coverage"
               },
               {
                   "compiler_id": "clang-14-libstdcxx-gcc11",
@@ -66,7 +79,8 @@ jobs:
                   "compiler_version": 14,
                   "stdlib": "libstdcxx",
                   "clang_gcc_toolchain": 11,
-                  "configuration": "Debug"
+                  "configuration": "Debug",
+                  "job_type": "build"
               },
               {
                   "compiler_id": "clang-16-libstdcxx-gcc13",
@@ -76,7 +90,8 @@ jobs:
                   "compiler_version": 16,
                   "stdlib": "libstdcxx",
                   "clang_gcc_toolchain": 13,
-                  "configuration": "Debug"
+                  "configuration": "Debug",
+                  "job_type": "build"
               },
               {
                   "compiler_id": "clang-17-libcxx",
@@ -85,7 +100,8 @@ jobs:
                   "cxx": "clang++-17",
                   "compiler_version": 17,
                   "stdlib": "libcxx",
-                  "configuration": "Debug"
+                  "configuration": "Debug",
+                  "job_type": "build"
               },
               {
                   # Clang 18 - testing if it's faster than Clang 17 with libc++
@@ -96,14 +112,16 @@ jobs:
                   "cxx": "clang++-18",
                   "compiler_version": 18,
                   "stdlib": "libcxx",
-                  "configuration": "Debug"
+                  "configuration": "Debug",
+                  "job_type": "build"
               }
           ]
           
           # Minimal matrix for PRs and feature branches
           minimal_matrix = [
               full_matrix[1],  # gcc-13 (middle-ground gcc)
-              full_matrix[2]   # clang-14 (mature, stable clang)
+              full_matrix[2],  # gcc-13 coverage
+              full_matrix[3]   # clang-14 (mature, stable clang)
           ]
           
           # Determine which matrix to use based on the target branch
@@ -161,14 +179,21 @@ jobs:
           # Select the appropriate matrix
           if use_full:
               if force_full:
-                  print(f"Using FULL matrix (6 configs) - forced by [ci-nix-full-matrix] tag")
+                  print(f"Using FULL matrix (7 configs) - forced by [ci-nix-full-matrix] tag")
               else:
-                  print(f"Using FULL matrix (6 configs) - targeting main branch")
+                  print(f"Using FULL matrix (7 configs) - targeting main branch")
               matrix = full_matrix
           else:
-              print(f"Using MINIMAL matrix (2 configs) - feature branch/PR")
+              print(f"Using MINIMAL matrix (3 configs) - feature branch/PR")
               matrix = minimal_matrix
-          
+
+          # Add runs_on based on job_type
+          for entry in matrix:
+              if entry.get("job_type") == "coverage":
+                  entry["runs_on"] = '["self-hosted", "generic", 24.04]'
+              else:
+                  entry["runs_on"] = '["self-hosted", "generic", 20.04]'
+
           # Output the matrix as JSON
           output = json.dumps({"include": matrix})
           with open(os.environ['GITHUB_OUTPUT'], 'a') as f:
@@ -176,7 +201,7 @@ jobs:
 
   build:
     needs: matrix-setup
-    runs-on: [self-hosted, generic, 20.04]
+    runs-on: ${{ fromJSON(matrix.runs_on) }}
     container:
       image: ubuntu:24.04
       volumes:
@@ -205,7 +230,7 @@ jobs:
           apt-get install -y software-properties-common
           add-apt-repository ppa:ubuntu-toolchain-r/test -y
           apt-get update
-          apt-get install -y python3 python-is-python3 pipx
+          apt-get install -y git python3 python-is-python3 pipx
           pipx ensurepath
           apt-get install -y cmake ninja-build ${{ matrix.cc }} ${{ matrix.cxx }} ccache
           apt-get install -y perl # for openssl build
@@ -276,6 +301,12 @@ jobs:
           pipx install "conan>=2.0,<3"
           echo "$HOME/.local/bin" >> $GITHUB_PATH
 
+          # Install gcovr for coverage jobs
+          if [ "${{ matrix.job_type }}" = "coverage" ]; then
+            pipx install "gcovr>=7,<9"
+            apt-get install -y lcov
+          fi
+
       - name: Check environment
         run: |
           echo "PATH:"
@@ -285,6 +316,13 @@ jobs:
           which ${{ matrix.cc }} && ${{ matrix.cc }} --version || echo "${{ matrix.cc }} not found"
           which ${{ matrix.cxx }} && ${{ matrix.cxx }} --version || echo "${{ matrix.cxx }} not found"
           which ccache && ccache --version || echo "ccache not found"
+
+          # Check gcovr for coverage jobs
+          if [ "${{ matrix.job_type }}" = "coverage" ]; then
+            which gcov && gcov --version || echo "gcov not found"
+            which gcovr && gcovr --version || echo "gcovr not found"
+          fi
+
           echo "---- Full Environment ----"
           env
 
@@ -312,6 +350,7 @@ jobs:
           gha_cache_enabled: 'false' # Disable caching for self hosted runner
 
       - name: Build
+        if: matrix.job_type == 'build'
         uses: ./.github/actions/xahau-ga-build
         with:
           generator: Ninja
@@ -326,7 +365,26 @@ jobs:
           clang_gcc_toolchain: ${{ matrix.clang_gcc_toolchain || '' }}
           ccache_max_size: '100G'
 
+      - name: Build (Coverage)
+        if: matrix.job_type == 'coverage'
+        uses: ./.github/actions/xahau-ga-build
+        with:
+          generator: Ninja
+          configuration: ${{ matrix.configuration }}
+          build_dir: ${{ env.build_dir }}
+          cc: ${{ matrix.cc }}
+          cxx: ${{ matrix.cxx }}
+          gcov: ${{ matrix.gcov }}
+          compiler-id: ${{ matrix.compiler_id }}
+          cache_version: ${{ env.CACHE_VERSION }}
+          main_branch: ${{ env.MAIN_BRANCH_NAME }}
+          stdlib: ${{ matrix.stdlib }}
+          cmake-args: '-Dcoverage=ON -Dcoverage_format=xml -DCODE_COVERAGE_VERBOSE=ON -DCMAKE_CXX_FLAGS="-O0" -DCMAKE_C_FLAGS="-O0"'
+          cmake-target: 'coverage'
+          ccache_max_size: '100G'
+
       - name: Set artifact name
+        if: matrix.job_type == 'build'
         id: set-artifact-name
         run: |
           ARTIFACT_NAME="build-output-nix-${{ github.run_id }}-${{ matrix.compiler }}-${{ matrix.configuration }}"
@@ -339,6 +397,7 @@ jobs:
           ls -la ${{ env.build_dir }} || echo "Build directory not found or empty"
 
       - name: Run tests
+        if: matrix.job_type == 'build'
         run: |
           # Ensure the binary exists before trying to run
           if [ -f "${{ env.build_dir }}/rippled" ]; then
@@ -347,3 +406,33 @@ jobs:
              echo "Error: rippled executable not found in ${{ env.build_dir }}"
              exit 1
           fi
+
+      # Coverage-specific steps
+      - name: Move coverage report
+        if: matrix.job_type == 'coverage'
+        shell: bash
+        run: |
+          mv "${{ env.build_dir }}/coverage.xml" ./
+
+      - name: Archive coverage report
+        if: matrix.job_type == 'coverage'
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage.xml
+          path: coverage.xml
+          retention-days: 30
+
+      - name: Upload coverage report
+        if: matrix.job_type == 'coverage'
+        uses: wandalen/wretry.action/main@v3
+        with:
+          action: codecov/codecov-action@v4.3.0
+          with: |
+            files: coverage.xml
+            fail_ci_if_error: true
+            disable_search: true
+            verbose: true
+            plugin: noop
+            token: ${{ secrets.CODECOV_TOKEN }}
+          attempt_limit: 5
+          attempt_delay: 210000 # in milliseconds

.gitignore

@@ -121,5 +121,3 @@ CMakeUserPresets.json
 bld.rippled/
 
 generated
-guard_checker
-guard_checker.dSYM

BUILD.md

@@ -258,12 +258,72 @@ can't build earlier Boost versions.
    generator. Pass `--help` to see the rest of the command line options.
 
 
+## Coverage report
+
+The coverage report is intended for developers using compilers GCC
+or Clang (including Apple Clang). It is generated by the build target `coverage`,
+which is only enabled when the `coverage` option is set, e.g. with
+`--options coverage=True` in `conan` or `-Dcoverage=ON` variable in `cmake`
+
+Prerequisites for the coverage report:
+
+- [gcovr tool][gcovr] (can be installed e.g. with [pip][python-pip])
+- `gcov` for GCC (installed with the compiler by default) or
+- `llvm-cov` for Clang (installed with the compiler by default)
+- `Debug` build type
+
+A coverage report is created when the following steps are completed, in order:
+
+1. `rippled` binary built with instrumentation data, enabled by the `coverage`
+   option mentioned above
+2. completed run of unit tests, which populates coverage capture data
+3. completed run of the `gcovr` tool (which internally invokes either `gcov` or `llvm-cov`)
+   to assemble both instrumentation data and the coverage capture data into a coverage report
+
+The above steps are automated into a single target `coverage`. The instrumented
+`rippled` binary can also be used for regular development or testing work, at
+the cost of extra disk space utilization and a small performance hit
+(to store coverage capture). In case of a spurious failure of unit tests, it is
+possible to re-run the `coverage` target without rebuilding the `rippled` binary
+(since it is simply a dependency of the coverage report target). It is also possible
+to select only specific tests for the purpose of the coverage report, by setting
+the `coverage_test` variable in `cmake`
+
+The default coverage report format is `html-details`, but the user
+can override it to any of the formats listed in `Builds/CMake/CodeCoverage.cmake`
+by setting the `coverage_format` variable in `cmake`. It is also possible
+to generate more than one format at a time by setting the `coverage_extra_args`
+variable in `cmake`. The specific command line used to run the `gcovr` tool will be
+displayed if the `CODE_COVERAGE_VERBOSE` variable is set.
+
+By default, the code coverage tool runs parallel unit tests with `--unittest-jobs`
+ set to the number of available CPU cores. This may cause spurious test
+errors on Apple. Developers can override the number of unit test jobs with
+the `coverage_test_parallelism` variable in `cmake`.
+
+Example use with some cmake variables set:
+
+```
+cd .build
+conan install .. --output-folder . --build missing --settings build_type=Debug
+cmake -DCMAKE_BUILD_TYPE=Debug -Dcoverage=ON -Dcoverage_test_parallelism=2 -Dcoverage_format=html-details -Dcoverage_extra_args="--json coverage.json" -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake ..
+cmake --build . --target coverage
+```
+
+After the `coverage` target is completed, the generated coverage report will be
+stored inside the build directory, as either of:
+
+- file named `coverage.`_extension_ , with a suitable extension for the report format, or
+- directory named `coverage`, with the `index.html` and other files inside, for the `html-details` or `html-nested` report formats.
+
+
 ## Options
 
 | Option | Default Value | Description |
 | --- | ---| ---|
 | `assert` | OFF | Enable assertions.
 | `reporting` | OFF | Build the reporting mode feature. |
+| `coverage` | OFF | Prepare the coverage report. |
 | `tests` | ON | Build tests. |
 | `unity` | ON | Configure a unity build. |
 | `san` | N/A | Enable a sanitizer with Clang. Choices are `thread` and `address`. |
@@ -456,6 +516,10 @@ but it is more convenient to put them in a [profile][profile].
 
 [1]: https://github.com/conan-io/conan-center-index/issues/13168
 [5]: https://en.wikipedia.org/wiki/Unity_build
+[6]: https://github.com/boostorg/beast/issues/2648
+[7]: https://github.com/boostorg/beast/issues/2661
+[gcovr]: https://gcovr.com/en/stable/getting-started.html
+[python-pip]: https://packaging.python.org/en/latest/guides/installing-using-pip-and-virtual-environments/
 [build_type]: https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html
 [runtime]: https://cmake.org/cmake/help/latest/variable/CMAKE_MSVC_RUNTIME_LIBRARY.html
 [toolchain]: https://cmake.org/cmake/help/latest/manual/cmake-toolchains.7.html

Builds/CMake/CodeCoverage.cmake

@@ -0,0 +1,440 @@
+# Copyright (c) 2012 - 2017, Lars Bilke
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its contributors
+#    may be used to endorse or promote products derived from this software without
+#    specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# CHANGES:
+#
+# 2012-01-31, Lars Bilke
+# - Enable Code Coverage
+#
+# 2013-09-17, Joakim Söderberg
+# - Added support for Clang.
+# - Some additional usage instructions.
+#
+# 2016-02-03, Lars Bilke
+# - Refactored functions to use named parameters
+#
+# 2017-06-02, Lars Bilke
+# - Merged with modified version from github.com/ufz/ogs
+#
+# 2019-05-06, Anatolii Kurotych
+# - Remove unnecessary --coverage flag
+#
+# 2019-12-13, FeRD (Frank Dana)
+# - Deprecate COVERAGE_LCOVR_EXCLUDES and COVERAGE_GCOVR_EXCLUDES lists in favor
+#   of tool-agnostic COVERAGE_EXCLUDES variable, or EXCLUDE setup arguments.
+# - CMake 3.4+: All excludes can be specified relative to BASE_DIRECTORY
+# - All setup functions: accept BASE_DIRECTORY, EXCLUDE list
+# - Set lcov basedir with -b argument
+# - Add automatic --demangle-cpp in lcovr, if 'c++filt' is available (can be
+#   overridden with NO_DEMANGLE option in setup_target_for_coverage_lcovr().)
+# - Delete output dir, .info file on 'make clean'
+# - Remove Python detection, since version mismatches will break gcovr
+# - Minor cleanup (lowercase function names, update examples...)
+#
+# 2019-12-19, FeRD (Frank Dana)
+# - Rename Lcov outputs, make filtered file canonical, fix cleanup for targets
+#
+# 2020-01-19, Bob Apthorpe
+# - Added gfortran support
+#
+# 2020-02-17, FeRD (Frank Dana)
+# - Make all add_custom_target()s VERBATIM to auto-escape wildcard characters
+#   in EXCLUDEs, and remove manual escaping from gcovr targets
+#
+# 2021-01-19, Robin Mueller
+# - Add CODE_COVERAGE_VERBOSE option which will allow to print out commands which are run
+# - Added the option for users to set the GCOVR_ADDITIONAL_ARGS variable to supply additional
+#   flags to the gcovr command
+#
+# 2020-05-04, Mihchael Davis
+#     - Add -fprofile-abs-path to make gcno files contain absolute paths
+#     - Fix BASE_DIRECTORY not working when defined
+#     - Change BYPRODUCT from folder to index.html to stop ninja from complaining about double defines
+#
+# 2021-05-10, Martin Stump
+#     - Check if the generator is multi-config before warning about non-Debug builds
+#
+# 2022-02-22, Marko Wehle
+#     - Change gcovr output from -o <filename> for --xml <filename> and --html <filename> output respectively.
+#       This will allow for Multiple Output Formats at the same time by making use of GCOVR_ADDITIONAL_ARGS, e.g. GCOVR_ADDITIONAL_ARGS "--txt".
+#
+# 2022-09-28, Sebastian Mueller
+#     - fix append_coverage_compiler_flags_to_target to correctly add flags
+#     - replace "-fprofile-arcs -ftest-coverage" with "--coverage" (equivalent)
+#
+# 2024-01-04, Bronek Kozicki
+#     - remove setup_target_for_coverage_lcov (slow) and setup_target_for_coverage_fastcov (no support for Clang)
+#     - fix Clang support by adding find_program( ... llvm-cov )
+#     - add Apple Clang support by adding execute_process( COMMAND xcrun -f llvm-cov ... )
+#     - add CODE_COVERAGE_GCOV_TOOL to explicitly select gcov tool and disable find_program
+#     - replace both functions setup_target_for_coverage_gcovr_* with a single setup_target_for_coverage_gcovr
+#     - add support for all gcovr output formats
+#
+# USAGE:
+#
+# 1. Copy this file into your cmake modules path.
+#
+# 2. Add the following line to your CMakeLists.txt (best inside an if-condition
+#    using a CMake option() to enable it just optionally):
+#      include(CodeCoverage)
+#
+# 3. Append necessary compiler flags for all supported source files:
+#      append_coverage_compiler_flags()
+#    Or for specific target:
+#      append_coverage_compiler_flags_to_target(YOUR_TARGET_NAME)
+#
+# 3.a (OPTIONAL) Set appropriate optimization flags, e.g. -O0, -O1 or -Og
+#
+# 4. If you need to exclude additional directories from the report, specify them
+#    using full paths in the COVERAGE_EXCLUDES variable before calling
+#    setup_target_for_coverage_*().
+#    Example:
+#      set(COVERAGE_EXCLUDES
+#          '${PROJECT_SOURCE_DIR}/src/dir1/*'
+#          '/path/to/my/src/dir2/*')
+#    Or, use the EXCLUDE argument to setup_target_for_coverage_*().
+#    Example:
+#      setup_target_for_coverage_gcovr(
+#          NAME coverage
+#          EXECUTABLE testrunner
+#          EXCLUDE "${PROJECT_SOURCE_DIR}/src/dir1/*" "/path/to/my/src/dir2/*")
+#
+# 4.a NOTE: With CMake 3.4+, COVERAGE_EXCLUDES or EXCLUDE can also be set
+#     relative to the BASE_DIRECTORY (default: PROJECT_SOURCE_DIR)
+#     Example:
+#       set(COVERAGE_EXCLUDES "dir1/*")
+#       setup_target_for_coverage_gcovr(
+#           NAME coverage
+#           EXECUTABLE testrunner
+#           FORMAT html-details
+#           BASE_DIRECTORY "${PROJECT_SOURCE_DIR}/src"
+#           EXCLUDE "dir2/*")
+#
+# 4.b If you need to pass specific options to gcovr, specify them in
+#     GCOVR_ADDITIONAL_ARGS variable.
+#     Example:
+#       set (GCOVR_ADDITIONAL_ARGS --exclude-throw-branches --exclude-noncode-lines -s)
+#       setup_target_for_coverage_gcovr(
+#           NAME coverage
+#           EXECUTABLE testrunner
+#           EXCLUDE "src/dir1" "src/dir2")
+#
+# 5. Use the functions described below to create a custom make target which
+#    runs your test executable and produces a code coverage report.
+#
+# 6. Build a Debug build:
+#      cmake -DCMAKE_BUILD_TYPE=Debug ..
+#      make
+#      make my_coverage_target
+
+include(CMakeParseArguments)
+
+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)
+  set(GCOV_TOOL "${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()
+    find_program( LLVMCOV_PATH llvm-cov )
+  endif()
+  if(LLVMCOV_PATH)
+    set(GCOV_TOOL "${LLVMCOV_PATH} gcov")
+  endif()
+elseif("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
+  find_program( GCOV_PATH gcov )
+  set(GCOV_TOOL "${GCOV_PATH}")
+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")
+    message(FATAL_ERROR "Compiler is not GNU or Flang! Aborting...")
+  endif()
+endforeach()
+
+set(COVERAGE_COMPILER_FLAGS "-g --coverage"
+    CACHE INTERNAL "")
+if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
+    include(CheckCXXCompilerFlag)
+    check_cxx_compiler_flag(-fprofile-abs-path HAVE_cxx_fprofile_abs_path)
+    if(HAVE_cxx_fprofile_abs_path)
+        set(COVERAGE_CXX_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-abs-path")
+    endif()
+    include(CheckCCompilerFlag)
+    check_c_compiler_flag(-fprofile-abs-path HAVE_c_fprofile_abs_path)
+    if(HAVE_c_fprofile_abs_path)
+        set(COVERAGE_C_COMPILER_FLAGS "${COVERAGE_COMPILER_FLAGS} -fprofile-abs-path")
+    endif()
+endif()
+
+set(CMAKE_Fortran_FLAGS_COVERAGE
+    ${COVERAGE_COMPILER_FLAGS}
+    CACHE STRING "Flags used by the Fortran compiler during coverage builds."
+    FORCE )
+set(CMAKE_CXX_FLAGS_COVERAGE
+    ${COVERAGE_COMPILER_FLAGS}
+    CACHE STRING "Flags used by the C++ compiler during coverage builds."
+    FORCE )
+set(CMAKE_C_FLAGS_COVERAGE
+    ${COVERAGE_COMPILER_FLAGS}
+    CACHE STRING "Flags used by the C compiler during coverage builds."
+    FORCE )
+set(CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used for linking binaries during coverage builds."
+    FORCE )
+set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE
+    ""
+    CACHE STRING "Flags used by the shared libraries linker during coverage builds."
+    FORCE )
+mark_as_advanced(
+    CMAKE_Fortran_FLAGS_COVERAGE
+    CMAKE_CXX_FLAGS_COVERAGE
+    CMAKE_C_FLAGS_COVERAGE
+    CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    CMAKE_SHARED_LINKER_FLAGS_COVERAGE )
+
+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)
+
+if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_Fortran_COMPILER_ID STREQUAL "GNU")
+    link_libraries(gcov)
+endif()
+
+# Defines a target for running and collection code coverage information
+# Builds dependencies, runs the given executable and outputs reports.
+# NOTE! The executable should always have a ZERO as exit code otherwise
+# the coverage generation will not complete.
+#
+# setup_target_for_coverage_gcovr(
+#     NAME ctest_coverage                    # New target name
+#     EXECUTABLE ctest -j ${PROCESSOR_COUNT} # Executable in PROJECT_BINARY_DIR
+#     DEPENDENCIES executable_target         # Dependencies to build first
+#     BASE_DIRECTORY "../"                   # Base directory for report
+#                                            #  (defaults to PROJECT_SOURCE_DIR)
+#     FORMAT "cobertura"                     # Output format, one of:
+#                                            #  xml cobertura sonarqube json-summary
+#                                            #  json-details coveralls csv txt
+#                                            #  html-single html-nested html-details
+#                                            #  (xml is an alias to cobertura;
+#                                            #  if no format is set, defaults to xml)
+#     EXCLUDE "src/dir1/*" "src/dir2/*"      # Patterns to exclude (can be relative
+#                                            #  to BASE_DIRECTORY, with CMake 3.4+)
+# )
+# The user can set the variable GCOVR_ADDITIONAL_ARGS to supply additional flags to the
+# GCVOR command.
+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})
+
+    if(NOT GCOV_TOOL)
+        message(FATAL_ERROR "Could not find gcov or llvm-cov tool! Aborting...")
+    endif()
+
+    if(NOT GCOVR_PATH)
+        message(FATAL_ERROR "Could not find gcovr tool! Aborting...")
+    endif()
+
+    # Set base directory (as absolute path), or default to PROJECT_SOURCE_DIR
+    if(DEFINED Coverage_BASE_DIRECTORY)
+        get_filename_component(BASEDIR ${Coverage_BASE_DIRECTORY} ABSOLUTE)
+    else()
+        set(BASEDIR ${PROJECT_SOURCE_DIR})
+    endif()
+
+    if(NOT DEFINED Coverage_FORMAT)
+        set(Coverage_FORMAT xml)
+    endif()
+
+    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)
+        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")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --sonarqube "${GCOVR_OUTPUT_FILE}" )
+    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")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --json "${GCOVR_OUTPUT_FILE}" )
+        list(APPEND GCOVR_ADDITIONAL_ARGS --json-pretty)
+    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")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --csv "${GCOVR_OUTPUT_FILE}" )
+    elseif(Coverage_FORMAT STREQUAL "txt")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --txt "${GCOVR_OUTPUT_FILE}" )
+    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")
+        list(APPEND GCOVR_ADDITIONAL_ARGS --html-nested "${GCOVR_OUTPUT_FILE}" )
+    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()
+
+    # 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()
+        list(APPEND GCOVR_EXCLUDES "${EXCLUDE}")
+    endforeach()
+    list(REMOVE_DUPLICATES GCOVR_EXCLUDES)
+
+    # Combine excludes to several -e arguments
+    set(GCOVR_EXCLUDE_ARGS "")
+    foreach(EXCLUDE ${GCOVR_EXCLUDES})
+        list(APPEND GCOVR_EXCLUDE_ARGS "-e")
+        list(APPEND GCOVR_EXCLUDE_ARGS "${EXCLUDE}")
+    endforeach()
+
+    # Set up commands which will be run to generate coverage data
+    # Run tests
+    set(GCOVR_EXEC_TESTS_CMD
+        ${Coverage_EXECUTABLE} ${Coverage_EXECUTABLE_ARGS}
+    )
+
+    # Create folder
+    if(DEFINED GCOVR_CREATE_FOLDER)
+        set(GCOVR_FOLDER_CMD
+            ${CMAKE_COMMAND} -E make_directory ${GCOVR_CREATE_FOLDER})
+    else()
+        set(GCOVR_FOLDER_CMD echo) # dummy
+    endif()
+
+    # Running gcovr
+    set(GCOVR_CMD
+        ${GCOVR_PATH}
+        --gcov-executable ${GCOV_TOOL}
+        --gcov-ignore-parse-errors=negative_hits.warn_once_per_file
+        -r ${BASEDIR}
+        ${GCOVR_ADDITIONAL_ARGS}
+        ${GCOVR_EXCLUDE_ARGS}
+        --object-directory=${PROJECT_BINARY_DIR}
+    )
+
+    if(CODE_COVERAGE_VERBOSE)
+        message(STATUS "Executed command report")
+
+        message(STATUS "Command to run tests: ")
+        string(REPLACE ";" " " GCOVR_EXEC_TESTS_CMD_SPACED "${GCOVR_EXEC_TESTS_CMD}")
+        message(STATUS "${GCOVR_EXEC_TESTS_CMD_SPACED}")
+
+        if(NOT GCOVR_FOLDER_CMD STREQUAL "echo")
+            message(STATUS "Command to create a folder: ")
+            string(REPLACE ";" " " GCOVR_FOLDER_CMD_SPACED "${GCOVR_FOLDER_CMD}")
+            message(STATUS "${GCOVR_FOLDER_CMD_SPACED}")
+        endif()
+
+        message(STATUS "Command to generate gcovr coverage data: ")
+        string(REPLACE ";" " " GCOVR_CMD_SPACED "${GCOVR_CMD}")
+        message(STATUS "${GCOVR_CMD_SPACED}")
+    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."
+    )
+
+    # Show info where to find the report
+    add_custom_command(TARGET ${Coverage_NAME} POST_BUILD
+        COMMAND ;
+        COMMENT "Code coverage report saved in ${GCOVR_OUTPUT_FILE} formatted as ${Coverage_FORMAT}"
+    )
+endfunction() # setup_target_for_coverage_gcovr
+
+function(append_coverage_compiler_flags)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
+    set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} ${COVERAGE_COMPILER_FLAGS}" PARENT_SCOPE)
+    message(STATUS "Appending code coverage compiler flags: ${COVERAGE_COMPILER_FLAGS}")
+endfunction() # append_coverage_compiler_flags
+
+# Setup coverage for specific library
+function(append_coverage_compiler_flags_to_target name)
+    separate_arguments(_flag_list NATIVE_COMMAND "${COVERAGE_COMPILER_FLAGS}")
+    target_compile_options(${name} PRIVATE ${_flag_list})
+    if(CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_Fortran_COMPILER_ID STREQUAL "GNU")
+        target_link_libraries(${name} PRIVATE gcov)
+    endif()
+endfunction()

Builds/CMake/RippledCore.cmake

@@ -488,6 +488,7 @@ target_sources (rippled PRIVATE
   src/ripple/app/tx/impl/apply.cpp
   src/ripple/app/tx/impl/applySteps.cpp
   src/ripple/app/hook/impl/applyHook.cpp
+  src/ripple/app/hook/impl/HookAPI.cpp
   src/ripple/app/tx/impl/details/NFTokenUtils.cpp
   #[===============================[
      main sources:
@@ -749,6 +750,7 @@ if (tests)
     src/test/app/Freeze_test.cpp
     src/test/app/GenesisMint_test.cpp
     src/test/app/HashRouter_test.cpp
+    src/test/app/HookAPI_test.cpp
     src/test/app/Import_test.cpp
     src/test/app/Invoke_test.cpp
     src/test/app/LedgerHistory_test.cpp

Builds/CMake/RippledCov.cmake

@@ -2,97 +2,37 @@
    coverage report target
 #]===================================================================]
 
-if (coverage)
-  if (is_clang)
-    if (APPLE)
-      execute_process (COMMAND xcrun -f llvm-profdata
-        OUTPUT_VARIABLE LLVM_PROFDATA
-        OUTPUT_STRIP_TRAILING_WHITESPACE)
-    else ()
-      find_program (LLVM_PROFDATA llvm-profdata)
-    endif ()
-    if (NOT LLVM_PROFDATA)
-      message (WARNING "unable to find llvm-profdata - skipping coverage_report target")
-    endif ()
+if(NOT coverage)
+  message(FATAL_ERROR "Code coverage not enabled! Aborting ...")
+endif()
 
-    if (APPLE)
-      execute_process (COMMAND xcrun -f llvm-cov
-        OUTPUT_VARIABLE LLVM_COV
-        OUTPUT_STRIP_TRAILING_WHITESPACE)
-    else ()
-      find_program (LLVM_COV llvm-cov)
-    endif ()
-    if (NOT LLVM_COV)
-      message (WARNING "unable to find llvm-cov - skipping coverage_report target")
-    endif ()
+if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+  message(WARNING "Code coverage on Windows is not supported, ignoring 'coverage' flag")
+  return()
+endif()
 
-    set (extract_pattern "")
-    if (coverage_core_only)
-      set (extract_pattern "${CMAKE_CURRENT_SOURCE_DIR}/src/ripple/")
-    endif ()
+include(CodeCoverage)
 
-    if (LLVM_COV AND LLVM_PROFDATA)
-      add_custom_target (coverage_report
-        USES_TERMINAL
-        COMMAND ${CMAKE_COMMAND} -E echo "Generating coverage - results will be in ${CMAKE_BINARY_DIR}/coverage/index.html."
-        COMMAND ${CMAKE_COMMAND} -E echo "Running rippled tests."
-        COMMAND rippled --unittest$<$<BOOL:${coverage_test}>:=${coverage_test}> --quiet --unittest-log
-        COMMAND ${LLVM_PROFDATA}
-          merge -sparse default.profraw -o rip.profdata
-        COMMAND ${CMAKE_COMMAND} -E echo "Summary of coverage:"
-        COMMAND ${LLVM_COV}
-          report -instr-profile=rip.profdata
-          $<TARGET_FILE:rippled> ${extract_pattern}
-        # generate html report
-        COMMAND ${LLVM_COV}
-          show -format=html -output-dir=${CMAKE_BINARY_DIR}/coverage
-          -instr-profile=rip.profdata
-          $<TARGET_FILE:rippled> ${extract_pattern}
-        BYPRODUCTS coverage/index.html)
-    endif ()
-  elseif (is_gcc)
-    find_program (LCOV lcov)
-    if (NOT LCOV)
-      message (WARNING "unable to find lcov - skipping coverage_report target")
-    endif ()
+# The instructions for these commands come from the `CodeCoverage` module,
+# which was copied from https://github.com/bilke/cmake-modules, commit fb7d2a3,
+# then locally changed (see CHANGES: section in `CodeCoverage.cmake`)
 
-    find_program (GENHTML genhtml)
-    if (NOT GENHTML)
-      message (WARNING "unable to find genhtml - skipping coverage_report target")
-    endif ()
+set(GCOVR_ADDITIONAL_ARGS ${coverage_extra_args})
+if(NOT GCOVR_ADDITIONAL_ARGS STREQUAL "")
+  separate_arguments(GCOVR_ADDITIONAL_ARGS)
+endif()
 
-    set (extract_pattern "*")
-    if (coverage_core_only)
-      set (extract_pattern "*/src/ripple/*")
-    endif ()
+list(APPEND GCOVR_ADDITIONAL_ARGS
+  --exclude-throw-branches
+  --exclude-noncode-lines
+  --exclude-unreachable-branches -s
+  -j ${coverage_test_parallelism})
 
-    if (LCOV AND GENHTML)
-      add_custom_target (coverage_report
-        USES_TERMINAL
-        COMMAND ${CMAKE_COMMAND} -E echo "Generating coverage- results will be in ${CMAKE_BINARY_DIR}/coverage/index.html."
-        # create baseline info file
-        COMMAND ${LCOV}
-          --no-external -d "${CMAKE_CURRENT_SOURCE_DIR}" -c -d . -i -o baseline.info
-          | grep -v "ignoring data for external file"
-        # run tests
-        COMMAND ${CMAKE_COMMAND} -E echo "Running rippled tests for coverage report."
-        COMMAND rippled --unittest$<$<BOOL:${coverage_test}>:=${coverage_test}> --quiet --unittest-log
-        # Create test coverage data file
-        COMMAND ${LCOV}
-          --no-external -d "${CMAKE_CURRENT_SOURCE_DIR}" -c -d . -o tests.info
-          | grep -v "ignoring data for external file"
-        # Combine baseline and test coverage data
-        COMMAND ${LCOV}
-          -a baseline.info -a tests.info -o lcov-all.info
-        # extract our files
-        COMMAND ${LCOV}
-          -e lcov-all.info "${extract_pattern}" -o lcov.info
-        COMMAND ${CMAKE_COMMAND} -E echo "Summary of coverage:"
-        COMMAND ${LCOV} --summary lcov.info
-        # generate HTML report
-        COMMAND ${GENHTML}
-          -o ${CMAKE_BINARY_DIR}/coverage lcov.info
-        BYPRODUCTS coverage/index.html)
-    endif ()
-  endif ()
-endif ()
+setup_target_for_coverage_gcovr(
+  NAME coverage
+  FORMAT ${coverage_format}
+  EXECUTABLE rippled
+  EXECUTABLE_ARGS --unittest$<$<BOOL:${coverage_test}>:=${coverage_test}> --unittest-jobs ${coverage_test_parallelism} --quiet --unittest-log
+  EXCLUDE "src/test" "${CMAKE_BINARY_DIR}/proto_gen" "${CMAKE_BINARY_DIR}/proto_gen_grpc"
+  DEPENDENCIES rippled
+)

Builds/CMake/RippledInterface.cmake

@@ -23,15 +23,15 @@ target_compile_options (opts
   INTERFACE
     $<$<AND:$<BOOL:${is_gcc}>,$<COMPILE_LANGUAGE:CXX>>:-Wsuggest-override>
     $<$<BOOL:${perf}>:-fno-omit-frame-pointer>
-    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-fprofile-arcs -ftest-coverage>
-    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-fprofile-instr-generate -fcoverage-mapping>
+    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-g --coverage -fprofile-abs-path>
+    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-g --coverage>
     $<$<BOOL:${profile}>:-pg>
     $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
 
 target_link_libraries (opts
   INTERFACE
-    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-fprofile-arcs -ftest-coverage>
-    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-fprofile-instr-generate -fcoverage-mapping>
+    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-g --coverage -fprofile-abs-path>
+    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-g --coverage>
     $<$<BOOL:${profile}>:-pg>
     $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
 

Builds/CMake/RippledSanity.cmake

@@ -2,6 +2,8 @@
    convenience variables and sanity checks
 #]===================================================================]
 
+include(ProcessorCount)
+
 if (NOT ep_procs)
   ProcessorCount(ep_procs)
   if (ep_procs GREATER 1)

Builds/CMake/RippledSettings.cmake

@@ -2,121 +2,129 @@
    declare user options/settings
 #]===================================================================]
 
-option (assert "Enables asserts, even in release builds" OFF)
+include(ProcessorCount)
 
-option (reporting "Build rippled with reporting mode enabled" OFF)
+ProcessorCount(PROCESSOR_COUNT)
 
-option (tests "Build tests" ON)
+option(assert "Enables asserts, even in release builds" OFF)
 
-option (unity "Creates a build using UNITY support in cmake. This is the default" ON)
-if (unity)
-  if (NOT is_ci)
-    set (CMAKE_UNITY_BUILD_BATCH_SIZE 15 CACHE STRING "")
-  endif ()
-endif ()
-if (is_gcc OR is_clang)
-  option (coverage "Generates coverage info." OFF)
-  option (profile "Add profiling flags" OFF)
-  set (coverage_test "" CACHE STRING
+option(reporting "Build rippled with reporting mode enabled" OFF)
+
+option(tests "Build tests" ON)
+
+option(unity "Creates a build using UNITY support in cmake. This is the default" ON)
+if(unity)
+  if(NOT is_ci)
+    set(CMAKE_UNITY_BUILD_BATCH_SIZE 15 CACHE STRING "")
+  endif()
+endif()
+if(is_gcc OR is_clang)
+  option(coverage "Generates coverage info." OFF)
+  option(profile "Add profiling flags" OFF)
+  set(coverage_test_parallelism "${PROCESSOR_COUNT}" CACHE STRING
+    "Unit tests parallelism for the purpose of coverage report.")
+  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_test "" CACHE STRING
     "On gcc & clang, the specific unit test(s) to run for coverage. Default is all tests.")
-  if (coverage_test AND NOT coverage)
-    set (coverage ON CACHE BOOL "gcc/clang only" FORCE)
-  endif ()
-  option (coverage_core_only
-    "Include only src/ripple files when generating coverage report. \
-    Set to OFF to include all sources in coverage report."
-    ON)
-  option (wextra "compile with extra gcc/clang warnings enabled" ON)
-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 ()
-if (is_linux)
-  option (BUILD_SHARED_LIBS "build shared ripple libraries" OFF)
-  option (static "link protobuf, openssl, libc++, and boost statically" ON)
-  option (perf "Enables flags that assist with perf recording" OFF)
-  option (use_gold "enables detection of gold (binutils) linker" ON)
-else ()
+  if(coverage_test AND NOT coverage)
+    set(coverage ON CACHE BOOL "gcc/clang only" FORCE)
+  endif()
+  option(wextra "compile with extra gcc/clang warnings enabled" ON)
+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()
+if(is_linux)
+  option(BUILD_SHARED_LIBS "build shared ripple libraries" OFF)
+  option(static "link protobuf, openssl, libc++, and boost statically" ON)
+  option(perf "Enables flags that assist with perf recording" OFF)
+  option(use_gold "enables detection of gold (binutils) linker" ON)
+  option(use_mold "enables detection of mold (binutils) linker" ON)
+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 ripple 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)
-endif ()
-if (is_clang)
-  option (use_lld "enables detection of lld linker" ON)
-else ()
-  set (use_lld OFF CACHE BOOL "try lld linker, clang only" FORCE)
-endif ()
-option (jemalloc "Enables jemalloc for heap profiling" OFF)
-option (werr "treat warnings as errors" OFF)
-option (local_protobuf
+  set(BUILD_SHARED_LIBS OFF CACHE BOOL "build shared ripple 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()
+if(is_clang)
+  option(use_lld "enables detection of lld linker" ON)
+else()
+  set(use_lld OFF CACHE BOOL "try lld linker, clang only" FORCE)
+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
+option(local_grpc
   "Force a local build of gRPC instead of looking for an installed version." OFF)
 
 # this one is a string and therefore can't be an option
-set (san "" CACHE STRING "On gcc & clang, add sanitizer instrumentation")
-set_property (CACHE san PROPERTY STRINGS ";undefined;memory;address;thread")
-if (san)
-  string (TOLOWER ${san} san)
-  set (SAN_FLAG "-fsanitize=${san}")
-  set (SAN_LIB "")
-  if (is_gcc)
-    if (san STREQUAL "address")
-      set (SAN_LIB "asan")
-    elseif (san STREQUAL "thread")
-      set (SAN_LIB "tsan")
-    elseif (san STREQUAL "memory")
-      set (SAN_LIB "msan")
-    elseif (san STREQUAL "undefined")
-      set (SAN_LIB "ubsan")
-    endif ()
-  endif ()
-  set (_saved_CRL ${CMAKE_REQUIRED_LIBRARIES})
-  set (CMAKE_REQUIRED_LIBRARIES "${SAN_FLAG};${SAN_LIB}")
-  check_cxx_compiler_flag (${SAN_FLAG} COMPILER_SUPPORTS_SAN)
-  set (CMAKE_REQUIRED_LIBRARIES ${_saved_CRL})
-  if (NOT COMPILER_SUPPORTS_SAN)
-    message (FATAL_ERROR "${san} sanitizer does not seem to be supported by your compiler")
-  endif ()
-endif ()
-set (container_label "" CACHE STRING "tag to use for package building containers")
-option (packages_only
+set(san "" CACHE STRING "On gcc & clang, add sanitizer instrumentation")
+set_property(CACHE san PROPERTY STRINGS ";undefined;memory;address;thread")
+if(san)
+  string(TOLOWER ${san} san)
+  set(SAN_FLAG "-fsanitize=${san}")
+  set(SAN_LIB "")
+  if(is_gcc)
+    if(san STREQUAL "address")
+      set(SAN_LIB "asan")
+    elseif(san STREQUAL "thread")
+      set(SAN_LIB "tsan")
+    elseif(san STREQUAL "memory")
+      set(SAN_LIB "msan")
+    elseif(san STREQUAL "undefined")
+      set(SAN_LIB "ubsan")
+    endif()
+  endif()
+  set(_saved_CRL ${CMAKE_REQUIRED_LIBRARIES})
+  set(CMAKE_REQUIRED_LIBRARIES "${SAN_FLAG};${SAN_LIB}")
+  check_cxx_compiler_flag(${SAN_FLAG} COMPILER_SUPPORTS_SAN)
+  set(CMAKE_REQUIRED_LIBRARIES ${_saved_CRL})
+  if(NOT COMPILER_SUPPORTS_SAN)
+    message(FATAL_ERROR "${san} sanitizer does not seem to be supported by your compiler")
+  endif()
+endif()
+set(container_label "" CACHE STRING "tag to use for package building containers")
+option(packages_only
   "ONLY generate package building targets. This is special use-case and almost \
    certainly not what you want. Use with caution as you won't be able to build \
    any compiled targets locally." OFF)
-option (have_package_container
+option(have_package_container
   "Sometimes you already have the tagged container you want to use for package \
    building and you don't want docker to rebuild it. This flag will detach the \
    dependency of the package build from the container build. It's an advanced \
    use case and most likely you should not be touching this flag." OFF)
 
 # the remaining options are obscure and rarely used
-option (beast_no_unit_test_inline
+option(beast_no_unit_test_inline
   "Prevents unit test definitions from being inserted into global table"
   OFF)
-option (single_io_service_thread
+option(single_io_service_thread
   "Restricts the number of threads calling io_service::run to one. \
   This can be useful when debugging."
   OFF)
-option (boost_show_deprecated
+option(boost_show_deprecated
   "Allow boost to fail on deprecated usage. Only useful if you're trying\
   to find deprecated calls."
   OFF)
-option (beast_hashers
+option(beast_hashers
   "Use local implementations for sha/ripemd hashes (experimental, not recommended)"
   OFF)
 
-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 ()
-if (coverage)
-  message (STATUS "coverage build requested - forcing Debug build")
-  set (CMAKE_BUILD_TYPE Debug CACHE STRING "build type" FORCE)
-endif ()
+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()
+if(coverage)
+  message(STATUS "coverage build requested - forcing Debug build")
+  set(CMAKE_BUILD_TYPE Debug CACHE STRING "build type" FORCE)
+endif()

CMakeLists.txt

@@ -64,7 +64,6 @@ include (CheckCXXCompilerFlag)
 include (FetchContent)
 include (ExternalProject)
 include (CMakeFuncs) # must come *after* ExternalProject b/c it overrides one function in EP
-include (ProcessorCount)
 if (target)
   message (FATAL_ERROR "The target option has been removed - use native cmake options to control build")
 endif ()
@@ -143,11 +142,14 @@ target_link_libraries(ripple_libs INTERFACE
   SQLite::SQLite3
 )
 
+if(coverage)
+  include(RippledCov)
+endif()
+
 ###
 
 include(RippledCore)
 include(RippledInstall)
-include(RippledCov)
 include(RippledMultiConfig)
 include(RippledDocs)
 include(RippledValidatorKeys)

hook/extern.h

@@ -82,7 +82,7 @@ sto_erase(
     uint32_t field_id);
 
 extern int64_t
-etxn_burden(void);
+etxn_burden();
 
 extern int64_t
 etxn_details(uint32_t write_ptr, uint32_t write_len);
@@ -94,7 +94,7 @@ extern int64_t
 etxn_reserve(uint32_t count);
 
 extern int64_t
-etxn_generation(void);
+etxn_generation();
 
 extern int64_t
 etxn_nonce(uint32_t write_ptr, uint32_t write_len);
@@ -149,7 +149,7 @@ extern int64_t
 float_divide(int64_t float1, int64_t float2);
 
 extern int64_t
-float_one(void);
+float_one();
 
 extern int64_t
 float_mantissa(int64_t float1);
@@ -167,13 +167,13 @@ extern int64_t
 float_root(int64_t float1, uint32_t n);
 
 extern int64_t
-fee_base(void);
+fee_base();
 
 extern int64_t
-ledger_seq(void);
+ledger_seq();
 
 extern int64_t
-ledger_last_time(void);
+ledger_last_time();
 
 extern int64_t
 ledger_last_hash(uint32_t write_ptr, uint32_t write_len);
@@ -213,13 +213,13 @@ hook_param(
     uint32_t read_len);
 
 extern int64_t
-hook_again(void);
+hook_again();
 
 extern int64_t
 hook_skip(uint32_t read_ptr, uint32_t read_len, uint32_t flags);
 
 extern int64_t
-hook_pos(void);
+hook_pos();
 
 extern int64_t
 slot(uint32_t write_ptr, uint32_t write_len, uint32_t slot);
@@ -299,19 +299,19 @@ extern int64_t
 trace_float(uint32_t read_ptr, uint32_t read_len, int64_t float1);
 
 extern int64_t
-otxn_burden(void);
+otxn_burden();
 
 extern int64_t
 otxn_field(uint32_t write_ptr, uint32_t write_len, uint32_t field_id);
 
 extern int64_t
-otxn_generation(void);
+otxn_generation();
 
 extern int64_t
 otxn_id(uint32_t write_ptr, uint32_t write_len, uint32_t flags);
 
 extern int64_t
-otxn_type(void);
+otxn_type();
 
 extern int64_t
 otxn_slot(uint32_t slot_no);

hook/generate_extern.sh

@@ -4,7 +4,7 @@ set -eu
 SCRIPT_DIR=$(dirname "$0")
 SCRIPT_DIR=$(cd "$SCRIPT_DIR" && pwd)
 
-APPLY_HOOK="$SCRIPT_DIR/../src/ripple/app/hook/applyHook.h"
+APPLY_HOOK="$SCRIPT_DIR/../src/ripple/app/hook/hook_api.macro"
 
 {
     echo '// For documentation please see: https://xrpl-hooks.readme.io/reference/'
@@ -19,127 +19,36 @@ APPLY_HOOK="$SCRIPT_DIR/../src/ripple/app/hook/applyHook.h"
             return s;
         }
 
-        function emit(ret, name, argc, argt, argn) {
-            attr = (name == "_g") ? " __attribute__((noduplicate))" : "";
-            if (!first)
-                printf("\n");
-            first = 0;
-            printf("extern %s%s\n", ret, attr);
-            if (argc == 0) {
-                printf("%s(void);\n", name);
-                return;
-            }
-            if (argc <= 3) {
-                line = argt[1] " " argn[1];
-                for (i = 2; i <= argc; ++i)
-                    line = line ", " argt[i] " " argn[i];
-                printf("%s(%s);\n", name, line);
-                return;
-            }
-            printf("%s(\n", name);
-            for (i = 1; i <= argc; ++i) {
-                sep = (i < argc) ? "," : ");";
-                printf("    %s %s%s\n", argt[i], argn[i], sep);
-            }
-        }
-
-        function process(buffer, kind,    payload, parts, n, i, arg, tokens, argc, argt, argn) {
-            if (kind == "func")
-                sub(/^DECLARE_HOOK_FUNCTION[[:space:]]*\(/, "", buffer);
-            else
-                sub(/^DECLARE_HOOK_FUNCNARG[[:space:]]*\(/, "", buffer);
-            buffer = trim(buffer);
-            sub(/\)[[:space:]]*$/, "", buffer);
-            n = split(buffer, parts, ",");
-            for (i = 1; i <= n; ++i)
-                parts[i] = trim(parts[i]);
-            ret = parts[1];
-            name = parts[2];
-            argc = 0;
-            delete argt;
-            delete argn;
-            for (i = 3; i <= n; ++i) {
-                arg = parts[i];
-                if (arg == "")
-                    continue;
-                split(arg, tokens, /[[:space:]]+/);
-                if (length(tokens) < 2)
-                    continue;
-                ++argc;
-                argt[argc] = tokens[1];
-                argn[argc] = tokens[2];
-            }
-            emit(ret, name, argc, argt, argn);
-        }
-
-        BEGIN {
-            first = 1;
-            in_block = 0;
-            in_macro = 0;
-        }
-
         {
             line = $0;
-            if (in_block) {
-                if (line ~ /\*\//) {
-                    sub(/.*\*\//, "", line);
-                    in_block = 0;
-                }
-                else
-                    next;
-            }
-            while (line ~ /\/\*/) {
-                if (line ~ /\/\*.*\*\//) {
-                    gsub(/\/\*.*\*\//, "", line);
-                }
-                else {
-                    sub(/\/\*.*/, "", line);
-                    in_block = 1;
-                    break;
-                }
-            }
-            sub(/\/\/.*$/, "", line);
-            line = trim(line);
-            if (line == "")
-                next;
-
-            if (!in_macro && line ~ /^DECLARE_HOOK_FUNCTION\(/) {
-                buffer = line;
-                kind = "func";
-                if (line ~ /\);[[:space:]]*$/) {
-                    sub(/\);[[:space:]]*$/, "", buffer);
-                    process(buffer, kind);
-                }
-                else
-                    in_macro = 1;
+            
+            # Skip block comments
+            if (line ~ /\/\*/) {
                 next;
             }
-            if (!in_macro && line ~ /^DECLARE_HOOK_FUNCNARG\(/) {
-                buffer = line;
-                kind = "narg";
-                if (line ~ /\);[[:space:]]*$/) {
-                    sub(/\);[[:space:]]*$/, "", buffer);
-                    process(buffer, kind);
+            
+            # Look for comment lines that start with // and contain function signature
+            if (line ~ /^[[:space:]]*\/\/[[:space:]]*[a-zA-Z_][a-zA-Z0-9_]*[[:space:]]+[a-zA-Z_][a-zA-Z0-9_]*[[:space:]]*\(/) {
+                # Remove leading // and trim
+                sub(/^[[:space:]]*\/\/[[:space:]]*/, "", line);
+                line = trim(line);
+                
+                # Check if function name is "_g" to add attribute
+                if (line ~ /[[:space:]]+_g[[:space:]]*\(/) {
+                    # Insert __attribute__((noduplicate)) before _g
+                    sub(/[[:space:]]+_g/, " __attribute__((noduplicate)) _g", line);
                 }
-                else
-                    in_macro = 1;
-                next;
+                
+                # printf("\n");
+                
+                printf("extern %s\n\n", line);
             }
-            if (in_macro) {
-                buffer = buffer " " line;
-                if (line ~ /\);[[:space:]]*$/) {
-                    sub(/\);[[:space:]]*$/, "", buffer);
-                    process(buffer, kind);
-                    in_macro = 0;
-                }
-            }
-        }
-
-        END {
-            printf("\n");
         }
     ' "$APPLY_HOOK"
 
     echo '#define HOOK_EXTERN'
     echo '#endif  // HOOK_EXTERN'
-}
+} | (
+    cd "$SCRIPT_DIR/.."
+    clang-format --style=file -
+)

src/ripple/app/hook/Enum.h

@@ -5,6 +5,28 @@
 #include <vector>
 #ifndef HOOKENUM_INCLUDED
 #define HOOKENUM_INCLUDED 1
+
+#ifndef GUARD_CHECKER_BUILD
+#include <ripple/basics/base_uint.h>
+#include <ripple/protocol/Feature.h>
+#include <ripple/protocol/Rules.h>
+#else
+// Override uint256, Feature and Rules for guard checker build
+#define uint256 std::string
+#define featureHooksUpdate1 "1"
+#define fix20250131 "1"
+namespace hook_api {
+struct Rules
+{
+    constexpr bool
+    enabled(const uint256& feature) const
+    {
+        return true;
+    }
+};
+}  // namespace hook_api
+#endif
+
 namespace ripple {
 enum HookSetOperation : int8_t {
     hsoINVALID = -1,
@@ -367,110 +389,59 @@ const uint8_t max_emit = 255;
 const uint8_t max_params = 16;
 const double fee_base_multiplier = 1.1f;
 
-#define I32 0x7FU
-#define I64 0x7EU
-
-#define HOOK_WRAP_PARAMS(...) __VA_ARGS__
-#define HOOK_API_DEFINITION(RETURN_TYPE, FUNCTION_NAME, PARAMS_TUPLE) \
-    {                                                                 \
-#FUNCTION_NAME,                                               \
-        {                                                             \
-            RETURN_TYPE, HOOK_WRAP_PARAMS PARAMS_TUPLE                \
-        }                                                             \
-    }
-
 using APIWhitelist = std::map<std::string, std::vector<uint8_t>>;
 
 // RH NOTE: Find descriptions of api functions in ./impl/applyHook.cpp and
 // hookapi.h (include for hooks) this is a map of the api name to its return
 // code (vec[0] and its parameters vec[>0]) as wasm type codes
-static const APIWhitelist import_whitelist{
-    // clang-format off
-    HOOK_API_DEFINITION(I32, _g, (I32, I32)),
-    HOOK_API_DEFINITION(I64, accept, (I32, I32, I64)),
-    HOOK_API_DEFINITION(I64, rollback, (I32, I32, I64)),
-    HOOK_API_DEFINITION(I64, util_raddr, (I32, I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, util_accid, (I32, I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, util_verify, (I32, I32, I32, I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, util_sha512h, (I32, I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, util_keylet, (I32, I32, I32, I32, I32, I32, I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, sto_validate, (I32, I32)),
-    HOOK_API_DEFINITION(I64, sto_subfield, (I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, sto_subarray, (I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, sto_emplace, (I32, I32, I32, I32, I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, sto_erase, (I32, I32, I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, etxn_burden, ()),
-    HOOK_API_DEFINITION(I64, etxn_details, (I32, I32)),
-    HOOK_API_DEFINITION(I64, etxn_fee_base, (I32, I32)),
-    HOOK_API_DEFINITION(I64, etxn_reserve, (I32)),
-    HOOK_API_DEFINITION(I64, etxn_generation, ()),
-    HOOK_API_DEFINITION(I64, etxn_nonce, (I32, I32)),
-    HOOK_API_DEFINITION(I64, emit, (I32, I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, float_set, (I32, I64)),
-    HOOK_API_DEFINITION(I64, float_multiply, (I64, I64)),
-    HOOK_API_DEFINITION(I64, float_mulratio, (I64, I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, float_negate, (I64)),
-    HOOK_API_DEFINITION(I64, float_compare, (I64, I64, I32)),
-    HOOK_API_DEFINITION(I64, float_sum, (I64, I64)),
-    HOOK_API_DEFINITION(I64, float_sto, (I32, I32, I32, I32, I32, I32, I64, I32)),
-    HOOK_API_DEFINITION(I64, float_sto_set, (I32, I32)),
-    HOOK_API_DEFINITION(I64, float_invert, (I64)),
-    HOOK_API_DEFINITION(I64, float_divide, (I64, I64)),
-    HOOK_API_DEFINITION(I64, float_one, ()),
-    HOOK_API_DEFINITION(I64, float_mantissa, (I64)),
-    HOOK_API_DEFINITION(I64, float_sign, (I64)),
-    HOOK_API_DEFINITION(I64, float_int, (I64, I32, I32)),
-    HOOK_API_DEFINITION(I64, float_log, (I64)),
-    HOOK_API_DEFINITION(I64, float_root, (I64, I32)),
-    HOOK_API_DEFINITION(I64, fee_base, ()),
-    HOOK_API_DEFINITION(I64, ledger_seq, ()),
-    HOOK_API_DEFINITION(I64, ledger_last_time, ()),
-    HOOK_API_DEFINITION(I64, ledger_last_hash, (I32, I32)),
-    HOOK_API_DEFINITION(I64, ledger_nonce, (I32, I32)),
-    HOOK_API_DEFINITION(I64, ledger_keylet, (I32, I32, I32, I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, hook_account, (I32, I32)),
-    HOOK_API_DEFINITION(I64, hook_hash, (I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, hook_param_set, (I32, I32, I32, I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, hook_param, (I32, I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, hook_again, ()),
-    HOOK_API_DEFINITION(I64, hook_skip, (I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, hook_pos, ()),
-    HOOK_API_DEFINITION(I64, slot, (I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, slot_clear, (I32)),
-    HOOK_API_DEFINITION(I64, slot_count, (I32)),
-    HOOK_API_DEFINITION(I64, slot_set, (I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, slot_size, (I32)),
-    HOOK_API_DEFINITION(I64, slot_subarray, (I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, slot_subfield, (I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, slot_type, (I32, I32)),
-    HOOK_API_DEFINITION(I64, slot_float, (I32)),
-    HOOK_API_DEFINITION(I64, state_set, (I32, I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, state_foreign_set, (I32, I32, I32, I32, I32, I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, state, (I32, I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, state_foreign, (I32, I32, I32, I32, I32, I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, trace, (I32, I32, I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, trace_num, (I32, I32, I64)),
-    HOOK_API_DEFINITION(I64, trace_float, (I32, I32, I64)),
-    HOOK_API_DEFINITION(I64, otxn_burden, ()),
-    HOOK_API_DEFINITION(I64, otxn_field, (I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, otxn_generation, ()),
-    HOOK_API_DEFINITION(I64, otxn_id, (I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, otxn_type, ()),
-    HOOK_API_DEFINITION(I64, otxn_slot, (I32)),
-    HOOK_API_DEFINITION(I64, otxn_param, (I32, I32, I32, I32)),
-    HOOK_API_DEFINITION(I64, meta_slot, (I32)),
-    // clang-format on
-};
+inline APIWhitelist
+getImportWhitelist(Rules const& rules)
+{
+    APIWhitelist whitelist;
 
-// featureHooks1
-static const APIWhitelist import_whitelist_1{
-    // clang-format off
-    HOOK_API_DEFINITION(I64, xpop_slot, (I32, I32)),
-    // clang-format on
-};
+#pragma push_macro("HOOK_API_DEFINITION")
+#undef HOOK_API_DEFINITION
+
+#define int64_t 0x7EU
+#define int32_t 0x7FU
+#define uint32_t 0x7FU
+
+#define HOOK_WRAP_PARAMS(...) __VA_ARGS__
+
+#define HOOK_API_DEFINITION(                                \
+    RETURN_TYPE, FUNCTION_NAME, PARAMS_TUPLE, AMENDMENT)    \
+    if (AMENDMENT == uint256{} || rules.enabled(AMENDMENT)) \
+        whitelist[#FUNCTION_NAME] = {                       \
+            RETURN_TYPE, HOOK_WRAP_PARAMS PARAMS_TUPLE};
+
+#include "hook_api.macro"
+
+#undef HOOK_API_DEFINITION
+#undef HOOK_WRAP_PARAMS
+#undef int64_t
+#undef int32_t
+#undef uint32_t
+#pragma pop_macro("HOOK_API_DEFINITION")
+
+    return whitelist;
+}
 
 #undef HOOK_API_DEFINITION
 #undef I32
 #undef I64
+
+enum GuardRulesVersion : uint64_t {
+    GuardRuleFix20250131 = 0x00000001,
+};
+
+inline uint64_t
+getGuardRulesVersion(Rules const& rules)
+{
+    uint64_t version = 0;
+    if (rules.enabled(fix20250131))
+        version |= GuardRuleFix20250131;
+    return version;
+}
+
 };  // namespace hook_api
 #endif

src/ripple/app/hook/Guard.h

@@ -5,7 +5,6 @@
 #include <memory>
 #include <optional>
 #include <ostream>
-#include <set>
 #include <stack>
 #include <string>
 #include <string_view>
@@ -283,8 +282,7 @@ check_guard(
      * might have unforeseen consequences, without also rolling back further
      * changes that are fine.
      */
-    uint64_t rulesVersion = 0,
-    std::set<int>* out_callees = nullptr
+    uint64_t rulesVersion = 0
 
 )
 {
@@ -494,27 +492,17 @@ check_guard(
         {
             REQUIRE(1);
             uint64_t callee_idx = LEB();
-
-            // record user-defined function calls if tracking is enabled
+            // disallow calling of user defined functions inside a hook
             if (callee_idx > last_import_idx)
             {
-                if (out_callees != nullptr)
-                {
-                    // record the callee for call graph analysis
-                    out_callees->insert(callee_idx);
-                }
-                else
-                {
-                    // if not tracking, maintain original behavior: reject
-                    GUARDLOG(hook::log::CALL_ILLEGAL)
-                        << "GuardCheck "
-                        << "Hook calls a function outside of the whitelisted "
-                           "imports "
-                        << "codesec: " << codesec << " hook byte offset: " << i
-                        << "\n";
+                GUARDLOG(hook::log::CALL_ILLEGAL)
+                    << "GuardCheck "
+                    << "Hook calls a function outside of the whitelisted "
+                       "imports "
+                    << "codesec: " << codesec << " hook byte offset: " << i
+                    << "\n";
 
-                    return {};
-                }
+                return {};
             }
 
             // enforce guard call limit
@@ -646,7 +634,7 @@ check_guard(
             }
             else if (fc_type == 10)  // memory.copy
             {
-                if (rulesVersion & 0x02U)
+                if (rulesVersion & hook_api::GuardRuleFix20250131)
                     GUARD_ERROR("Memory.copy instruction is not allowed.");
 
                 REQUIRE(2);
@@ -654,7 +642,7 @@ check_guard(
             }
             else if (fc_type == 11)  // memory.fill
             {
-                if (rulesVersion & 0x02U)
+                if (rulesVersion & hook_api::GuardRuleFix20250131)
                     GUARD_ERROR("Memory.fill instruction is not allowed.");
 
                 ADVANCE(1);
@@ -838,6 +826,7 @@ validateGuards(
     std::vector<uint8_t> const& wasm,
     GuardLog guardLog,
     std::string guardLogAccStr,
+    hook_api::APIWhitelist const import_whitelist,
     /* RH NOTE:
      * rules version is a bit field, so rule update 1 is 0x01, update 2 is 0x02
      * and update 3 is 0x04 ideally at rule version 3 all bits so far are set
@@ -847,44 +836,8 @@ validateGuards(
      * might have unforeseen consequences, without also rolling back further
      * changes that are fine.
      */
-    uint64_t rulesVersion = 0)
+    uint64_t rulesVersion = 0x00)
 {
-    // Structure to track function call graph information
-    struct FunctionInfo
-    {
-        int func_idx;
-        std::set<int> callees;  // functions this function calls
-        std::set<int> callers;  // functions that call this function
-        bool has_loops;         // whether this function contains loops
-        uint64_t local_wce;     // local worst-case execution count
-        uint64_t total_wce;     // total WCE including callees
-        bool wce_calculated;    // whether total_wce has been computed
-        bool in_calculation;    // for cycle detection in WCE calculation
-
-        FunctionInfo()
-            : func_idx(-1)
-            , has_loops(false)
-            , local_wce(0)
-            , total_wce(0)
-            , wce_calculated(false)
-            , in_calculation(false)
-        {
-        }
-
-        FunctionInfo(int idx, uint64_t local_wce_val, bool has_loops_val)
-            : func_idx(idx)
-            , has_loops(has_loops_val)
-            , local_wce(local_wce_val)
-            , total_wce(0)
-            , wce_calculated(false)
-            , in_calculation(false)
-        {
-        }
-    };
-
-    // Call graph: maps function index to its information
-    std::map<int, FunctionInfo> call_graph;
-
     uint64_t byteCount = wasm.size();
 
     // 63 bytes is the smallest possible valid hook wasm
@@ -1068,31 +1021,24 @@ validateGuards(
                 int type_idx = parseLeb128(wasm, i, &i);
                 CHECK_SHORT_HOOK();
 
+                auto it = import_whitelist.find(import_name);
+                auto it_end = import_whitelist.end();
+                bool found_in_whitelist = (it != it_end);
+
                 if (import_name == "_g")
                 {
                     guard_import_number = func_upto;
                 }
-                else if (
-                    hook_api::import_whitelist.find(import_name) ==
-                    hook_api::import_whitelist.end())
+                if (!found_in_whitelist)
                 {
-                    if (rulesVersion > 0 &&
-                        hook_api::import_whitelist_1.find(import_name) !=
-                            hook_api::import_whitelist_1.end())
-                    {
-                        // PASS, this is a version 1 api
-                    }
-                    else
-                    {
-                        GUARDLOG(hook::log::IMPORT_ILLEGAL)
-                            << "Malformed transaction. "
-                            << "Hook attempted to import a function that does "
-                               "not "
-                            << "appear in the hook_api function set: `"
-                            << import_name << "`"
-                            << "\n";
-                        return {};
-                    }
+                    GUARDLOG(hook::log::IMPORT_ILLEGAL)
+                        << "Malformed transaction. "
+                        << "Hook attempted to import a function that does "
+                           "not "
+                        << "appear in the hook_api function set: `"
+                        << import_name << "`"
+                        << "\n";
+                    return {};
                 }
 
                 // add to import map
@@ -1224,12 +1170,6 @@ validateGuards(
                 if (DEBUG_GUARD)
                     printf("Function map: func %d -> type %d\n", j, type_idx);
                 func_type_map[j] = type_idx;
-
-                // Step 4: Initialize FunctionInfo for each user-defined
-                // function func_idx starts from last_import_number + 1
-                int actual_func_idx = last_import_number + 1 + j;
-                call_graph[actual_func_idx] = FunctionInfo();
-                call_graph[actual_func_idx].func_idx = actual_func_idx;
             }
         }
 
@@ -1271,6 +1211,9 @@ validateGuards(
         return {};
     }
 
+    int64_t maxInstrCountHook = 0;
+    int64_t maxInstrCountCbak = 0;
+
     // second pass... where we check all the guard function calls follow the
     // guard rules minimal other validation in this pass because first pass
     // caught most of it
@@ -1304,18 +1247,13 @@ validateGuards(
                 std::optional<
                     std::reference_wrapper<std::vector<uint8_t> const>>
                     first_signature;
-                bool helper_function = false;
                 if (auto const& usage = import_type_map.find(j);
                     usage != import_type_map.end())
                 {
                     for (auto const& [import_idx, api_name] : usage->second)
                     {
                         auto const& api_signature =
-                            hook_api::import_whitelist.find(api_name) !=
-                                hook_api::import_whitelist.end()
-                            ? hook_api::import_whitelist.find(api_name)->second
-                            : hook_api::import_whitelist_1.find(api_name)
-                                  ->second;
+                            import_whitelist.find(api_name)->second;
 
                         if (!first_signature)
                         {
@@ -1340,7 +1278,7 @@ validateGuards(
                         }
                     }
                 }
-                else if (j == hook_type_idx)  // hook() or cbak() function type
+                else if (j == hook_type_idx)
                 {
                     // pass
                 }
@@ -1353,8 +1291,7 @@ validateGuards(
                         << "Codesec: " << section_type << " "
                         << "Local: " << j << " "
                         << "Offset: " << i << "\n";
-                    // return {};
-                    helper_function = true;
+                    return {};
                 }
 
                 int param_count = parseLeb128(wasm, i, &i);
@@ -1371,19 +1308,12 @@ validateGuards(
                         return {};
                     }
                 }
-                else if (helper_function)
-                {
-                    // pass
-                }
                 else if (param_count != (*first_signature).get().size() - 1)
                 {
                     GUARDLOG(hook::log::FUNC_TYPE_INVALID)
                         << "Malformed transaction. "
                         << "Hook API: " << *first_name
-                        << " has the wrong number of parameters.\n"
-                        << "param_count: " << param_count << " "
-                        << "first_signature: "
-                        << (*first_signature).get().size() - 1 << "\n";
+                        << " has the wrong number of parameters.\n";
                     return {};
                 }
 
@@ -1430,10 +1360,6 @@ validateGuards(
                             return {};
                         }
                     }
-                    else if (helper_function)
-                    {
-                        // pass
-                    }
                     else if ((*first_signature).get()[k + 1] != param_type)
                     {
                         GUARDLOG(hook::log::FUNC_PARAM_INVALID)
@@ -1510,10 +1436,6 @@ validateGuards(
                             return {};
                         }
                     }
-                    else if (helper_function)
-                    {
-                        // pass
-                    }
                     else if ((*first_signature).get()[0] != result_type)
                     {
                         GUARDLOG(hook::log::FUNC_RETURN_INVALID)
@@ -1565,17 +1487,6 @@ validateGuards(
                 // execution to here means we are up to the actual expr for the
                 // codesec/function
 
-                // Step 5: Calculate actual function index and prepare callees
-                // tracking
-                int actual_func_idx = last_import_number + 1 + j;
-                std::set<int>* out_callees_ptr = nullptr;
-
-                // Only track callees if this function is in the call_graph
-                if (call_graph.find(actual_func_idx) != call_graph.end())
-                {
-                    out_callees_ptr = &call_graph[actual_func_idx].callees;
-                }
-
                 auto valid = check_guard(
                     wasm,
                     j,
@@ -1585,188 +1496,33 @@ validateGuards(
                     last_import_number,
                     guardLog,
                     guardLogAccStr,
-                    rulesVersion,
-                    out_callees_ptr);
+                    rulesVersion);
 
                 if (!valid)
                     return {};
 
-                // Step 5: Store local WCE and build bidirectional call
-                // relationships
-                if (call_graph.find(actual_func_idx) != call_graph.end())
+                if (hook_func_idx && *hook_func_idx == j)
+                    maxInstrCountHook = *valid;
+                else if (cbak_func_idx && *cbak_func_idx == j)
+                    maxInstrCountCbak = *valid;
+                else
                 {
-                    call_graph[actual_func_idx].local_wce = *valid;
-
-                    // Build bidirectional relationships: for each callee, add
-                    // this function as a caller
-                    for (int callee_idx : call_graph[actual_func_idx].callees)
-                    {
-                        if (call_graph.find(callee_idx) != call_graph.end())
-                        {
-                            call_graph[callee_idx].callers.insert(
-                                actual_func_idx);
-                        }
-                    }
+                    if (DEBUG_GUARD)
+                        printf(
+                            "code section: %d not hook_func_idx: %d or "
+                            "cbak_func_idx: %d\n",
+                            j,
+                            *hook_func_idx,
+                            (cbak_func_idx ? *cbak_func_idx : -1));
+                    //   assert(false);
                 }
-
-                // Note: We will calculate total WCE later after processing all
-                // functions
                 i = code_end;
             }
         }
         i = next_section;
     }
 
-    // Step 6: Cycle detection using DFS
-    // Lambda function for DFS-based cycle detection
-    std::set<int> visited;
-    std::set<int> rec_stack;
-    std::function<bool(int)> detect_cycles_dfs = [&](int func_idx) -> bool {
-        if (rec_stack.find(func_idx) != rec_stack.end())
-        {
-            // Found a cycle: func_idx is already in the recursion stack
-            return true;
-        }
+    // execution to here means guards are installed correctly
 
-        if (visited.find(func_idx) != visited.end())
-        {
-            // Already visited and no cycle found from this node
-            return false;
-        }
-
-        visited.insert(func_idx);
-        rec_stack.insert(func_idx);
-
-        // Check all callees
-        if (call_graph.find(func_idx) != call_graph.end())
-        {
-            for (int callee_idx : call_graph[func_idx].callees)
-            {
-                if (detect_cycles_dfs(callee_idx))
-                {
-                    return true;
-                }
-            }
-        }
-
-        rec_stack.erase(func_idx);
-        return false;
-    };
-
-    // Run cycle detection on all user-defined functions
-    for (const auto& [func_idx, func_info] : call_graph)
-    {
-        if (detect_cycles_dfs(func_idx))
-        {
-            GUARDLOG(hook::log::CALL_ILLEGAL)
-                << "GuardCheck: Recursive function calls detected. "
-                << "Hooks cannot contain recursive or mutually recursive "
-                   "functions.\n";
-            return {};
-        }
-    }
-
-    // Step 7: Calculate total WCE for each function using bottom-up approach
-    // Lambda function for recursive WCE calculation with memoization
-    std::function<uint64_t(int)> calculate_function_wce =
-        [&](int func_idx) -> uint64_t {
-        // Check if function exists in call graph
-        if (call_graph.find(func_idx) == call_graph.end())
-        {
-            // This is an imported function, WCE = 0 (already accounted for)
-            return 0;
-        }
-
-        FunctionInfo& func_info = call_graph[func_idx];
-
-        // If already calculated, return cached result
-        if (func_info.wce_calculated)
-        {
-            return func_info.total_wce;
-        }
-
-        // Detect circular dependency in WCE calculation (should not happen
-        // after cycle detection)
-        if (func_info.in_calculation)
-        {
-            GUARDLOG(hook::log::CALL_ILLEGAL)
-                << "GuardCheck: Internal error - circular dependency detected "
-                   "during WCE calculation.\n";
-            return 0xFFFFFFFFU;  // Return large value to trigger overflow error
-        }
-
-        func_info.in_calculation = true;
-
-        // Start with local WCE
-        uint64_t total = func_info.local_wce;
-
-        // Add WCE of all callees
-        for (int callee_idx : func_info.callees)
-        {
-            uint64_t callee_wce = calculate_function_wce(callee_idx);
-
-            // Check for overflow
-            if (total > 0xFFFFU || callee_wce > 0xFFFFU ||
-                (total + callee_wce) > 0xFFFFU)
-            {
-                func_info.in_calculation = false;
-                return 0xFFFFFFFFU;  // Signal overflow
-            }
-
-            total += callee_wce;
-        }
-
-        func_info.total_wce = total;
-        func_info.wce_calculated = true;
-        func_info.in_calculation = false;
-
-        return total;
-    };
-
-    // Calculate WCE for hook and cbak functions
-    int64_t hook_wce_actual = 0;
-    int64_t cbak_wce_actual = 0;
-
-    if (hook_func_idx)
-    {
-        int actual_hook_idx = last_import_number + 1 + *hook_func_idx;
-        hook_wce_actual = calculate_function_wce(actual_hook_idx);
-
-        if (hook_wce_actual >= 0xFFFFU)
-        {
-            GUARDLOG(hook::log::INSTRUCTION_EXCESS)
-                << "GuardCheck: hook() function exceeds maximum instruction "
-                   "count (65535). "
-                << "Total WCE including called functions: " << hook_wce_actual
-                << "\n";
-            return {};
-        }
-
-        if (DEBUG_GUARD)
-            printf("hook() total WCE: %ld\n", hook_wce_actual);
-    }
-
-    if (cbak_func_idx)
-    {
-        int actual_cbak_idx = last_import_number + 1 + *cbak_func_idx;
-        cbak_wce_actual = calculate_function_wce(actual_cbak_idx);
-
-        if (cbak_wce_actual >= 0xFFFFU)
-        {
-            GUARDLOG(hook::log::INSTRUCTION_EXCESS)
-                << "GuardCheck: cbak() function exceeds maximum instruction "
-                   "count (65535). "
-                << "Total WCE including called functions: " << cbak_wce_actual
-                << "\n";
-            return {};
-        }
-
-        if (DEBUG_GUARD)
-            printf("cbak() total WCE: %ld\n", cbak_wce_actual);
-    }
-
-    // execution to here means guards are installed correctly and WCE is within
-    // limits
-
-    return std::pair<uint64_t, uint64_t>{hook_wce_actual, cbak_wce_actual};
+    return std::pair<uint64_t, uint64_t>{maxInstrCountHook, maxInstrCountCbak};
 }

src/ripple/app/hook/HookAPI.h

@@ -0,0 +1,346 @@
+#ifndef HOOK_API_INCLUDED
+#define HOOK_API_INCLUDED 1
+
+#include <ripple/app/hook/Enum.h>
+#include <ripple/app/misc/Transaction.h>
+
+namespace hook {
+using namespace ripple;
+using HookReturnCode = hook_api::hook_return_code;
+
+using Bytes = std::vector<std::uint8_t>;
+
+struct HookContext;  // defined in applyHook.h
+
+class HookAPI
+{
+public:
+    explicit HookAPI(HookContext& ctx) : hookCtx(ctx)
+    {
+    }
+
+    /// control APIs
+    // _g
+    // accept
+    // rollback
+
+    /// util APIs
+    Expected<std::string, HookReturnCode>
+    util_raddr(Bytes const& accountID) const;
+
+    Expected<Bytes, HookReturnCode>
+    util_accid(std::string raddress) const;
+
+    Expected<bool, HookReturnCode>
+    util_verify(Slice const& data, Slice const& sig, Slice const& key) const;
+
+    uint256
+    util_sha512h(Slice const& data) const;
+
+    // util_keylet()
+
+    /// sto APIs
+    Expected<bool, HookReturnCode>
+    sto_validate(Bytes const& data) const;
+
+    Expected<std::pair<uint32_t, uint32_t>, HookReturnCode>
+    sto_subfield(Bytes const& data, uint32_t field_id) const;
+
+    Expected<std::pair<uint32_t, uint32_t>, HookReturnCode>
+    sto_subarray(Bytes const& data, uint32_t index_id) const;
+
+    Expected<Bytes, HookReturnCode>
+    sto_emplace(
+        Bytes const& source_object,
+        std::optional<Bytes> const& field_object,
+        uint32_t field_id) const;
+
+    // sto_erase(): same as sto_emplace with field_object = nullopt
+
+    /// etxn APIs
+    Expected<std::shared_ptr<Transaction>, HookReturnCode>
+    emit(Slice const& txBlob) const;
+
+    Expected<uint64_t, HookReturnCode>
+    etxn_burden() const;
+
+    Expected<uint64_t, HookReturnCode>
+    etxn_fee_base(Slice const& txBlob) const;
+
+    Expected<uint64_t, HookReturnCode>
+    etxn_details(uint8_t* out_ptr) const;
+
+    Expected<uint64_t, HookReturnCode>
+    etxn_reserve(uint64_t count) const;
+
+    uint32_t
+    etxn_generation() const;
+
+    Expected<uint256, HookReturnCode>
+    etxn_nonce() const;
+
+    /// float APIs
+    Expected<uint64_t, HookReturnCode>
+    float_set(int32_t exponent, int64_t mantissa) const;
+
+    Expected<uint64_t, HookReturnCode>
+    float_multiply(uint64_t float1, uint64_t float2) const;
+
+    Expected<uint64_t, HookReturnCode>
+    float_mulratio(
+        uint64_t float1,
+        uint32_t round_up,
+        uint32_t numerator,
+        uint32_t denominator) const;
+
+    uint64_t
+    float_negate(uint64_t float1) const;
+
+    Expected<uint64_t, HookReturnCode>
+    float_compare(uint64_t float1, uint64_t float2, uint32_t mode) const;
+
+    Expected<uint64_t, HookReturnCode>
+    float_sum(uint64_t float1, uint64_t float2) const;
+
+    Expected<Bytes, HookReturnCode>
+    float_sto(
+        std::optional<Currency> currency,
+        std::optional<AccountID> issuer,
+        uint64_t float1,
+        uint32_t field_code,
+        uint32_t write_len) const;
+
+    Expected<uint64_t, HookReturnCode>
+    float_sto_set(Bytes const& data) const;
+
+    Expected<uint64_t, HookReturnCode>
+    float_invert(uint64_t float1) const;
+
+    Expected<uint64_t, HookReturnCode>
+    float_divide(uint64_t float1, uint64_t float2) const;
+
+    uint64_t
+    float_one() const;
+
+    Expected<uint64_t, HookReturnCode>
+    float_mantissa(uint64_t float1) const;
+
+    uint64_t
+    float_sign(uint64_t float1) const;
+
+    Expected<uint64_t, HookReturnCode>
+    float_int(uint64_t float1, uint32_t decimal_places, uint32_t absolute)
+        const;
+
+    Expected<uint64_t, HookReturnCode>
+    float_log(uint64_t float1) const;
+
+    Expected<uint64_t, HookReturnCode>
+    float_root(uint64_t float1, uint32_t n) const;
+
+    /// otxn APIs
+    uint64_t
+    otxn_burden() const;
+
+    uint32_t
+    otxn_generation() const;
+
+    Expected<const STBase*, HookReturnCode>
+    otxn_field(uint32_t field_id) const;
+
+    Expected<uint256, HookReturnCode>
+    otxn_id(uint32_t flags) const;
+
+    TxType
+    otxn_type() const;
+
+    Expected<uint32_t, HookReturnCode>
+    otxn_slot(uint32_t slot_into) const;
+
+    Expected<Blob, HookReturnCode>
+    otxn_param(Bytes const& param_name) const;
+
+    /// hook APIs
+    AccountID
+    hook_account() const;
+
+    Expected<ripple::uint256, HookReturnCode>
+    hook_hash(int32_t hook_no) const;
+
+    Expected<int64_t, HookReturnCode>
+    hook_again() const;
+
+    Expected<Blob, HookReturnCode>
+    hook_param(Bytes const& paramName) const;
+
+    Expected<uint64_t, HookReturnCode>
+    hook_param_set(
+        uint256 const& hash,
+        Bytes const& paramName,
+        Bytes const& paramValue) const;
+
+    Expected<uint64_t, HookReturnCode>
+    hook_skip(uint256 const& hash, uint32_t flags) const;
+
+    uint8_t
+    hook_pos() const;
+
+    /// ledger APIs
+    uint64_t
+    fee_base() const;
+
+    uint32_t
+    ledger_seq() const;
+
+    uint256
+    ledger_last_hash() const;
+
+    uint64_t
+    ledger_last_time() const;
+
+    Expected<uint256, HookReturnCode>
+    ledger_nonce() const;
+
+    Expected<Keylet, HookReturnCode>
+    ledger_keylet(Keylet const& klLo, Keylet const& klHi) const;
+
+    /// state APIs
+
+    // state(): same as state_foreign with ns = 0 and account = hook_account()
+
+    Expected<Bytes, HookReturnCode>
+    state_foreign(
+        uint256 const& key,
+        uint256 const& ns,
+        AccountID const& account) const;
+
+    // state_set(): same as state_foreign_set with ns = 0 and account =
+
+    Expected<uint64_t, HookReturnCode>
+    state_foreign_set(
+        uint256 const& key,
+        uint256 const& ns,
+        AccountID const& account,
+        Bytes& data) const;
+
+    /// slot APIs
+    Expected<const STBase*, HookReturnCode>
+    slot(uint32_t slot_no) const;
+
+    Expected<uint64_t, HookReturnCode>
+    slot_clear(uint32_t slot_no) const;
+
+    Expected<uint64_t, HookReturnCode>
+    slot_count(uint32_t slot_no) const;
+
+    Expected<uint32_t, HookReturnCode>
+    slot_set(Bytes const& data, uint32_t slot_no) const;
+
+    Expected<uint64_t, HookReturnCode>
+    slot_size(uint32_t slot_no) const;
+
+    Expected<uint32_t, HookReturnCode>
+    slot_subarray(uint32_t parent_slot, uint32_t array_id, uint32_t new_slot)
+        const;
+
+    Expected<uint32_t, HookReturnCode>
+    slot_subfield(uint32_t parent_slot, uint32_t field_id, uint32_t new_slot)
+        const;
+
+    Expected<std::variant<STBase, STAmount>, HookReturnCode>
+    slot_type(uint32_t slot_no, uint32_t flags) const;
+
+    Expected<uint64_t, HookReturnCode>
+    slot_float(uint32_t slot_no) const;
+
+    /// trace APIs
+    // trace
+    // trace_num
+    // trace_float
+
+    Expected<uint32_t, HookReturnCode>
+    meta_slot(uint32_t slot_into) const;
+
+    Expected<std::pair<uint32_t, uint32_t>, HookReturnCode>
+    xpop_slot(uint32_t slot_into_tx, uint32_t slot_into_meta) const;
+
+private:
+    HookContext& hookCtx;
+
+    inline int32_t
+    no_free_slots() const;
+
+    inline std::optional<int32_t>
+    get_free_slot() const;
+
+    inline Expected<uint64_t, HookReturnCode>
+    float_multiply_internal_parts(
+        uint64_t man1,
+        int32_t exp1,
+        bool neg1,
+        uint64_t man2,
+        int32_t exp2,
+        bool neg2) const;
+
+    inline Expected<uint64_t, HookReturnCode>
+    mulratio_internal(
+        int64_t& man1,
+        int32_t& exp1,
+        bool round_up,
+        uint32_t numerator,
+        uint32_t denominator) const;
+
+    inline Expected<uint64_t, HookReturnCode>
+    float_divide_internal(uint64_t float1, uint64_t float2) const;
+
+    inline Expected<uint64_t, HookReturnCode>
+    double_to_xfl(double x) const;
+
+    std::optional<ripple::Keylet>
+    unserialize_keylet(Bytes const& data) const;
+
+    // update the state cache
+    inline std::optional<
+        std::reference_wrapper<std::pair<bool, ripple::Blob> const>>
+    lookup_state_cache(
+        AccountID const& acc,
+        uint256 const& ns,
+        uint256 const& key) const;
+
+    // check the state cache
+    inline Expected<uint64_t, HookReturnCode>
+    set_state_cache(
+        AccountID const& acc,
+        uint256 const& ns,
+        uint256 const& key,
+        Bytes const& data,
+        bool modified) const;
+
+    // these are only used by get_stobject_length below
+    enum parse_error {
+        pe_unexpected_end = -1,
+        pe_unknown_type_early = -2,  // detected early
+        pe_unknown_type_late = -3,   // end of function
+        pe_excessive_nesting = -4,
+        pe_excessive_size = -5
+    };
+
+    inline Expected<
+        int32_t,
+        parse_error>
+    get_stobject_length(
+        unsigned char* start,     // in - begin iterator
+        unsigned char* maxptr,    // in - end iterator
+        int& type,                // out - populated by serialized type code
+        int& field,               // out - populated by serialized field code
+        int& payload_start,       // out - the start of actual payload data for
+                                  // this type
+        int& payload_length,      // out - the length of actual payload data for
+                                  // this type
+        int recursion_depth = 0)  // used internally
+        const;
+};
+
+}  // namespace hook
+
+#endif  // HOOK_API_INCLUDED

src/ripple/app/hook/Macro.h

@@ -25,7 +25,8 @@
     _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, N, ...) \
     N
 #define VA_NARGS(__drop, ...) \
-    VA_NARGS_IMPL(__VA_ARGS__, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1)
+    VA_NARGS_IMPL(            \
+        __VA_OPT__(__VA_ARGS__, ) 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
 #define FIRST(a, b) a
 #define SECOND(a, b) b
 #define STRIP_TYPES(...) FOR_VARS(SECOND, 0, __VA_ARGS__)
@@ -88,30 +89,18 @@
 
 #define WASM_VAL_TYPE(T, b) CAT2(TYP_, T)
 
-#define DECLARE_HOOK_FUNCTION(R, F, ...)                      \
-    R F(hook::HookContext& hookCtx,                           \
-        WasmEdge_CallingFrameContext const& frameCtx,         \
-        __VA_ARGS__);                                         \
-    extern WasmEdge_Result WasmFunction##F(                   \
-        void* data_ptr,                                       \
-        const WasmEdge_CallingFrameContext* frameCtx,         \
-        const WasmEdge_Value* in,                             \
-        WasmEdge_Value* out);                                 \
-    extern WasmEdge_ValType WasmFunctionParams##F[];          \
-    extern WasmEdge_ValType WasmFunctionResult##F[];          \
-    extern WasmEdge_FunctionTypeContext* WasmFunctionType##F; \
-    extern WasmEdge_String WasmFunctionName##F;
-
-#define DECLARE_HOOK_FUNCNARG(R, F)                           \
-    R F(hook::HookContext& hookCtx,                           \
-        WasmEdge_CallingFrameContext const& frameCtx);        \
-    extern WasmEdge_Result WasmFunction##F(                   \
-        void* data_ptr,                                       \
-        const WasmEdge_CallingFrameContext* frameCtx,         \
-        const WasmEdge_Value* in,                             \
-        WasmEdge_Value* out);                                 \
-    extern WasmEdge_ValType WasmFunctionResult##F[];          \
-    extern WasmEdge_FunctionTypeContext* WasmFunctionType##F; \
+#define DECLARE_HOOK_FUNCTION(R, F, ...)                         \
+    R F(hook::HookContext& hookCtx,                              \
+        WasmEdge_CallingFrameContext const& frameCtx __VA_OPT__( \
+            COMMA __VA_ARGS__));                                 \
+    extern WasmEdge_Result WasmFunction##F(                      \
+        void* data_ptr,                                          \
+        const WasmEdge_CallingFrameContext* frameCtx,            \
+        const WasmEdge_Value* in,                                \
+        WasmEdge_Value* out);                                    \
+    extern WasmEdge_ValType WasmFunctionParams##F[];             \
+    extern WasmEdge_ValType WasmFunctionResult##F[];             \
+    extern WasmEdge_FunctionTypeContext* WasmFunctionType##F;    \
     extern WasmEdge_String WasmFunctionName##F;
 
 #define DEFINE_HOOK_FUNCTION(R, F, ...)                             \
@@ -121,61 +110,35 @@
         const WasmEdge_Value* in,                                   \
         WasmEdge_Value* out)                                        \
     {                                                               \
-        int _stack = 0;                                             \
-        FOR_VARS(VAR_ASSIGN, 2, __VA_ARGS__);                       \
+        __VA_OPT__(int _stack = 0;)                                 \
+        __VA_OPT__(FOR_VARS(VAR_ASSIGN, 2, __VA_ARGS__);)           \
         hook::HookContext* hookCtx =                                \
             reinterpret_cast<hook::HookContext*>(data_ptr);         \
         R return_code = hook_api::F(                                \
             *hookCtx,                                               \
-            *const_cast<WasmEdge_CallingFrameContext*>(frameCtx),   \
-            STRIP_TYPES(__VA_ARGS__));                              \
+            *const_cast<WasmEdge_CallingFrameContext*>(frameCtx)    \
+                __VA_OPT__(COMMA STRIP_TYPES(__VA_ARGS__)));        \
         if (return_code == RC_ROLLBACK || return_code == RC_ACCEPT) \
             return WasmEdge_Result_Terminate;                       \
         out[0] = RET_ASSIGN(R, return_code);                        \
         return WasmEdge_Result_Success;                             \
     };                                                              \
     WasmEdge_ValType hook_api::WasmFunctionParams##F[] = {          \
-        FOR_VARS(WASM_VAL_TYPE, 0, __VA_ARGS__)};                   \
+        __VA_OPT__(FOR_VARS(WASM_VAL_TYPE, 0, __VA_ARGS__))};       \
     WasmEdge_ValType hook_api::WasmFunctionResult##F[1] = {         \
         WASM_VAL_TYPE(R, dummy)};                                   \
     WasmEdge_FunctionTypeContext* hook_api::WasmFunctionType##F =   \
         WasmEdge_FunctionTypeCreate(                                \
             WasmFunctionParams##F,                                  \
-            VA_NARGS(NULL, __VA_ARGS__),                            \
+            VA_NARGS(NULL __VA_OPT__(, __VA_ARGS__)),               \
             WasmFunctionResult##F,                                  \
             1);                                                     \
     WasmEdge_String hook_api::WasmFunctionName##F =                 \
         WasmEdge_StringCreateByCString(#F);                         \
     R hook_api::F(                                                  \
         hook::HookContext& hookCtx,                                 \
-        WasmEdge_CallingFrameContext const& frameCtx,               \
-        __VA_ARGS__)
-
-#define DEFINE_HOOK_FUNCNARG(R, F)                                           \
-    WasmEdge_Result hook_api::WasmFunction##F(                               \
-        void* data_ptr,                                                      \
-        const WasmEdge_CallingFrameContext* frameCtx,                        \
-        const WasmEdge_Value* in,                                            \
-        WasmEdge_Value* out)                                                 \
-    {                                                                        \
-        hook::HookContext* hookCtx =                                         \
-            reinterpret_cast<hook::HookContext*>(data_ptr);                  \
-        R return_code = hook_api::F(                                         \
-            *hookCtx, *const_cast<WasmEdge_CallingFrameContext*>(frameCtx)); \
-        if (return_code == RC_ROLLBACK || return_code == RC_ACCEPT)          \
-            return WasmEdge_Result_Terminate;                                \
-        out[0] = CAT2(RET_, R(return_code));                                 \
-        return WasmEdge_Result_Success;                                      \
-    };                                                                       \
-    WasmEdge_ValType hook_api::WasmFunctionResult##F[1] = {                  \
-        WASM_VAL_TYPE(R, dummy)};                                            \
-    WasmEdge_FunctionTypeContext* hook_api::WasmFunctionType##F =            \
-        WasmEdge_FunctionTypeCreate({}, 0, WasmFunctionResult##F, 1);        \
-    WasmEdge_String hook_api::WasmFunctionName##F =                          \
-        WasmEdge_StringCreateByCString(#F);                                  \
-    R hook_api::F(                                                           \
-        hook::HookContext& hookCtx,                                          \
-        WasmEdge_CallingFrameContext const& frameCtx)
+        WasmEdge_CallingFrameContext const& frameCtx __VA_OPT__(    \
+            COMMA __VA_ARGS__))
 
 #define HOOK_SETUP()                                                 \
     try                                                              \
@@ -190,6 +153,7 @@
         [[maybe_unused]] const uint64_t memory_length =              \
             WasmEdge_MemoryInstanceGetPageSize(memoryCtx) *          \
             WasmEdge_kPageSize;                                      \
+        [[maybe_unused]] auto& api = hookCtx.api();                  \
         if (!memoryCtx || !memory || !memory_length)                 \
             return INTERNAL_ERROR;
 

src/ripple/app/hook/applyHook.h

@@ -1,6 +1,7 @@
 #ifndef APPLY_HOOK_INCLUDED
 #define APPLY_HOOK_INCLUDED 1
 #include <ripple/app/hook/Enum.h>
+#include <ripple/app/hook/HookAPI.h>
 #include <ripple/app/hook/Macro.h>
 #include <ripple/app/hook/Misc.h>
 #include <ripple/app/misc/Transaction.h>
@@ -61,365 +62,20 @@ namespace hook_api {
     if (HOOK_DBG)   \
     fprintf
 
-DECLARE_HOOK_FUNCTION(int32_t, _g, uint32_t guard_id, uint32_t maxiter);
+#pragma push_macro("HOOK_API_DEFINITION")
+#undef HOOK_API_DEFINITION
 
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    accept,
-    uint32_t read_ptr,
-    uint32_t read_len,
-    int64_t error_code);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    rollback,
-    uint32_t read_ptr,
-    uint32_t read_len,
-    int64_t error_code);
+#define HOOK_WRAP_PARAMS(...) __VA_ARGS__
+#define HOOK_API_DEFINITION(RETURN_TYPE, FUNCTION_NAME, PARAMS_TUPLE, ...) \
+    DECLARE_HOOK_FUNCTION(                                                 \
+        RETURN_TYPE, FUNCTION_NAME, HOOK_WRAP_PARAMS PARAMS_TUPLE);
 
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    util_raddr,
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t read_ptr,
-    uint32_t read_len);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    util_accid,
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t read_ptr,
-    uint32_t read_len);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    util_verify,
-    uint32_t dread_ptr,
-    uint32_t dread_len,
-    uint32_t sread_ptr,
-    uint32_t sread_len,
-    uint32_t kread_ptr,
-    uint32_t kread_len);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    util_sha512h,
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t read_ptr,
-    uint32_t read_len);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    util_keylet,
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t keylet_type,
-    uint32_t a,
-    uint32_t b,
-    uint32_t c,
-    uint32_t d,
-    uint32_t e,
-    uint32_t f);
+#include <ripple/app/hook/hook_api.macro>
 
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    sto_validate,
-    uint32_t tread_ptr,
-    uint32_t tread_len);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    sto_subfield,
-    uint32_t read_ptr,
-    uint32_t read_len,
-    uint32_t field_id);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    sto_subarray,
-    uint32_t read_ptr,
-    uint32_t read_len,
-    uint32_t array_id);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    sto_emplace,
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t sread_ptr,
-    uint32_t sread_len,
-    uint32_t fread_ptr,
-    uint32_t fread_len,
-    uint32_t field_id);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    sto_erase,
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t read_ptr,
-    uint32_t read_len,
-    uint32_t field_id);
+#undef HOOK_API_DEFINITION
+#undef HOOK_WRAP_PARAMS
+#pragma pop_macro("HOOK_API_DEFINITION")
 
-DECLARE_HOOK_FUNCNARG(int64_t, etxn_burden);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    etxn_details,
-    uint32_t write_ptr,
-    uint32_t write_len);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    etxn_fee_base,
-    uint32_t read_ptr,
-    uint32_t read_len);
-DECLARE_HOOK_FUNCTION(int64_t, etxn_reserve, uint32_t count);
-DECLARE_HOOK_FUNCNARG(int64_t, etxn_generation);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    etxn_nonce,
-    uint32_t write_ptr,
-    uint32_t write_len);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    emit,
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t read_ptr,
-    uint32_t read_len);
-
-DECLARE_HOOK_FUNCTION(int64_t, float_set, int32_t exponent, int64_t mantissa);
-DECLARE_HOOK_FUNCTION(int64_t, float_multiply, int64_t float1, int64_t float2);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    float_mulratio,
-    int64_t float1,
-    uint32_t round_up,
-    uint32_t numerator,
-    uint32_t denominator);
-DECLARE_HOOK_FUNCTION(int64_t, float_negate, int64_t float1);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    float_compare,
-    int64_t float1,
-    int64_t float2,
-    uint32_t mode);
-DECLARE_HOOK_FUNCTION(int64_t, float_sum, int64_t float1, int64_t float2);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    float_sto,
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t cread_ptr,
-    uint32_t cread_len,
-    uint32_t iread_ptr,
-    uint32_t iread_len,
-    int64_t float1,
-    uint32_t field_code);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    float_sto_set,
-    uint32_t read_ptr,
-    uint32_t read_len);
-DECLARE_HOOK_FUNCTION(int64_t, float_invert, int64_t float1);
-DECLARE_HOOK_FUNCTION(int64_t, float_divide, int64_t float1, int64_t float2);
-DECLARE_HOOK_FUNCNARG(int64_t, float_one);
-DECLARE_HOOK_FUNCTION(int64_t, float_mantissa, int64_t float1);
-DECLARE_HOOK_FUNCTION(int64_t, float_sign, int64_t float1);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    float_int,
-    int64_t float1,
-    uint32_t decimal_places,
-    uint32_t abs);
-DECLARE_HOOK_FUNCTION(int64_t, float_log, int64_t float1);
-DECLARE_HOOK_FUNCTION(int64_t, float_root, int64_t float1, uint32_t n);
-
-DECLARE_HOOK_FUNCNARG(int64_t, fee_base);
-DECLARE_HOOK_FUNCNARG(int64_t, ledger_seq);
-DECLARE_HOOK_FUNCNARG(int64_t, ledger_last_time);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    ledger_last_hash,
-    uint32_t write_ptr,
-    uint32_t write_len);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    ledger_nonce,
-    uint32_t write_ptr,
-    uint32_t write_len);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    ledger_keylet,
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t lread_ptr,
-    uint32_t lread_len,
-    uint32_t hread_ptr,
-    uint32_t hread_len);
-
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    hook_account,
-    uint32_t write_ptr,
-    uint32_t write_len);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    hook_hash,
-    uint32_t write_ptr,
-    uint32_t write_len,
-    int32_t hook_no);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    hook_param_set,
-    uint32_t read_ptr,
-    uint32_t read_len,
-    uint32_t kread_ptr,
-    uint32_t kread_len,
-    uint32_t hread_ptr,
-    uint32_t hread_len);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    hook_param,
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t read_ptr,
-    uint32_t read_len);
-DECLARE_HOOK_FUNCNARG(int64_t, hook_again);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    hook_skip,
-    uint32_t read_ptr,
-    uint32_t read_len,
-    uint32_t flags);
-DECLARE_HOOK_FUNCNARG(int64_t, hook_pos);
-
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    slot,
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t slot);
-DECLARE_HOOK_FUNCTION(int64_t, slot_clear, uint32_t slot);
-DECLARE_HOOK_FUNCTION(int64_t, slot_count, uint32_t slot);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    slot_set,
-    uint32_t read_ptr,
-    uint32_t read_len,
-    uint32_t slot);
-DECLARE_HOOK_FUNCTION(int64_t, slot_size, uint32_t slot);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    slot_subarray,
-    uint32_t parent_slot,
-    uint32_t array_id,
-    uint32_t new_slot);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    slot_subfield,
-    uint32_t parent_slot,
-    uint32_t field_id,
-    uint32_t new_slot);
-DECLARE_HOOK_FUNCTION(int64_t, slot_type, uint32_t slot_no, uint32_t flags);
-DECLARE_HOOK_FUNCTION(int64_t, slot_float, uint32_t slot_no);
-
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    state_set,
-    uint32_t read_ptr,
-    uint32_t read_len,
-    uint32_t kread_ptr,
-    uint32_t kread_len);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    state_foreign_set,
-    uint32_t read_ptr,
-    uint32_t read_len,
-    uint32_t kread_ptr,
-    uint32_t kread_len,
-    uint32_t nread_ptr,
-    uint32_t nread_len,
-    uint32_t aread_ptr,
-    uint32_t aread_len);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    state,
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t kread_ptr,
-    uint32_t kread_len);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    state_foreign,
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t kread_ptr,
-    uint32_t kread_len,
-    uint32_t nread_ptr,
-    uint32_t nread_len,
-    uint32_t aread_ptr,
-    uint32_t aread_len);
-
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    trace,
-    uint32_t mread_ptr,
-    uint32_t mread_len,
-    uint32_t dread_ptr,
-    uint32_t dread_len,
-    uint32_t as_hex);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    trace_num,
-    uint32_t read_ptr,
-    uint32_t read_len,
-    int64_t number);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    trace_float,
-    uint32_t read_ptr,
-    uint32_t read_len,
-    int64_t float1);
-
-DECLARE_HOOK_FUNCNARG(int64_t, otxn_burden);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    otxn_field,
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t field_id);
-DECLARE_HOOK_FUNCNARG(int64_t, otxn_generation);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    otxn_id,
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t flags);
-DECLARE_HOOK_FUNCNARG(int64_t, otxn_type);
-DECLARE_HOOK_FUNCTION(int64_t, otxn_slot, uint32_t slot_no);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    otxn_param,
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t read_ptr,
-    uint32_t read_len);
-
-DECLARE_HOOK_FUNCTION(int64_t, meta_slot, uint32_t slot_no);
-DECLARE_HOOK_FUNCTION(
-    int64_t,
-    xpop_slot,
-    uint32_t slot_no_tx,
-    uint32_t slot_no_meta);
-
-/*
-    DECLARE_HOOK_FUNCTION(int64_t,  str_find,           uint32_t hread_ptr,
-   uint32_t hread_len, uint32_t nread_ptr, uint32_t nread_len, uint32_t mode,
-   uint32_t n); DECLARE_HOOK_FUNCTION(int64_t,  str_replace,        uint32_t
-   write_ptr, uint32_t write_len, uint32_t hread_ptr, uint32_t hread_len,
-                                                        uint32_t nread_ptr,
-   uint32_t nread_len, uint32_t rread_ptr, uint32_t rread_len, uint32_t mode,
-   uint32_t n); DECLARE_HOOK_FUNCTION(int64_t,  str_compare,        uint32_t
-   fread_ptr, uint32_t fread_len, uint32_t sread_ptr, uint32_t sread_len,
-                                                        uint32_t mode);
-    DECLARE_HOOK_FUNCTION(int64_t,  str_concat,         uint32_t write_ptr,
-   uint32_t write_len, uint32_t read_ptr,  uint32_t read_len, uint64_t operand,
-   uint32_t operand_type);
-*/
 } /* end namespace hook_api */
 
 namespace hook {
@@ -477,7 +133,6 @@ struct HookResult
     ripple::uint256 const hookHash;
     ripple::uint256 const hookCanEmit;
     ripple::Keylet const accountKeylet;
-    ripple::Keylet const ownerDirKeylet;
     ripple::Keylet const hookKeylet;
     ripple::AccountID const account;
     ripple::AccountID const otxnAccount;
@@ -554,6 +209,18 @@ struct HookContext
                       // emitted txn then this optional becomes
                       // populated with the SLE
     const HookExecutor* module = 0;
+
+    // Lazy-initialized HookAPI member
+    mutable std::unique_ptr<HookAPI> api_;
+
+    // Access the HookAPI instance (lazy initialization)
+    HookAPI&
+    api() const
+    {
+        if (!api_)
+            api_ = std::make_unique<HookAPI>(const_cast<HookContext&>(*this));
+        return *api_;
+    }
 };
 
 bool
@@ -792,97 +459,18 @@ public:
 
         WasmEdge_LogSetDebugLevel();
 
-        ADD_HOOK_FUNCTION(_g, ctx);
-        ADD_HOOK_FUNCTION(accept, ctx);
-        ADD_HOOK_FUNCTION(rollback, ctx);
-        ADD_HOOK_FUNCTION(util_raddr, ctx);
-        ADD_HOOK_FUNCTION(util_accid, ctx);
-        ADD_HOOK_FUNCTION(util_verify, ctx);
-        ADD_HOOK_FUNCTION(util_sha512h, ctx);
-        ADD_HOOK_FUNCTION(sto_validate, ctx);
-        ADD_HOOK_FUNCTION(sto_subfield, ctx);
-        ADD_HOOK_FUNCTION(sto_subarray, ctx);
-        ADD_HOOK_FUNCTION(sto_emplace, ctx);
-        ADD_HOOK_FUNCTION(sto_erase, ctx);
-        ADD_HOOK_FUNCTION(util_keylet, ctx);
+#pragma push_macro("HOOK_API_DEFINITION")
+#undef HOOK_API_DEFINITION
 
-        ADD_HOOK_FUNCTION(emit, ctx);
-        ADD_HOOK_FUNCTION(etxn_burden, ctx);
-        ADD_HOOK_FUNCTION(etxn_fee_base, ctx);
-        ADD_HOOK_FUNCTION(etxn_details, ctx);
-        ADD_HOOK_FUNCTION(etxn_reserve, ctx);
-        ADD_HOOK_FUNCTION(etxn_generation, ctx);
-        ADD_HOOK_FUNCTION(etxn_nonce, ctx);
+#define HOOK_WRAP_PARAMS(...) __VA_ARGS__
+#define HOOK_API_DEFINITION(RETURN_TYPE, FUNCTION_NAME, PARAMS_TUPLE, ...) \
+    ADD_HOOK_FUNCTION(FUNCTION_NAME, ctx);
 
-        ADD_HOOK_FUNCTION(float_set, ctx);
-        ADD_HOOK_FUNCTION(float_multiply, ctx);
-        ADD_HOOK_FUNCTION(float_mulratio, ctx);
-        ADD_HOOK_FUNCTION(float_negate, ctx);
-        ADD_HOOK_FUNCTION(float_compare, ctx);
-        ADD_HOOK_FUNCTION(float_sum, ctx);
-        ADD_HOOK_FUNCTION(float_sto, ctx);
-        ADD_HOOK_FUNCTION(float_sto_set, ctx);
-        ADD_HOOK_FUNCTION(float_invert, ctx);
+#include <ripple/app/hook/hook_api.macro>
 
-        ADD_HOOK_FUNCTION(float_divide, ctx);
-        ADD_HOOK_FUNCTION(float_one, ctx);
-        ADD_HOOK_FUNCTION(float_mantissa, ctx);
-        ADD_HOOK_FUNCTION(float_sign, ctx);
-        ADD_HOOK_FUNCTION(float_int, ctx);
-        ADD_HOOK_FUNCTION(float_log, ctx);
-        ADD_HOOK_FUNCTION(float_root, ctx);
-
-        ADD_HOOK_FUNCTION(otxn_burden, ctx);
-        ADD_HOOK_FUNCTION(otxn_generation, ctx);
-        ADD_HOOK_FUNCTION(otxn_field, ctx);
-        ADD_HOOK_FUNCTION(otxn_id, ctx);
-        ADD_HOOK_FUNCTION(otxn_type, ctx);
-        ADD_HOOK_FUNCTION(otxn_slot, ctx);
-        ADD_HOOK_FUNCTION(otxn_param, ctx);
-
-        ADD_HOOK_FUNCTION(hook_account, ctx);
-        ADD_HOOK_FUNCTION(hook_hash, ctx);
-        ADD_HOOK_FUNCTION(hook_again, ctx);
-        ADD_HOOK_FUNCTION(fee_base, ctx);
-        ADD_HOOK_FUNCTION(ledger_seq, ctx);
-        ADD_HOOK_FUNCTION(ledger_last_hash, ctx);
-        ADD_HOOK_FUNCTION(ledger_last_time, ctx);
-        ADD_HOOK_FUNCTION(ledger_nonce, ctx);
-        ADD_HOOK_FUNCTION(ledger_keylet, ctx);
-
-        ADD_HOOK_FUNCTION(hook_param, ctx);
-        ADD_HOOK_FUNCTION(hook_param_set, ctx);
-        ADD_HOOK_FUNCTION(hook_skip, ctx);
-        ADD_HOOK_FUNCTION(hook_pos, ctx);
-
-        ADD_HOOK_FUNCTION(state, ctx);
-        ADD_HOOK_FUNCTION(state_foreign, ctx);
-        ADD_HOOK_FUNCTION(state_set, ctx);
-        ADD_HOOK_FUNCTION(state_foreign_set, ctx);
-
-        ADD_HOOK_FUNCTION(slot, ctx);
-        ADD_HOOK_FUNCTION(slot_clear, ctx);
-        ADD_HOOK_FUNCTION(slot_count, ctx);
-        ADD_HOOK_FUNCTION(slot_set, ctx);
-        ADD_HOOK_FUNCTION(slot_size, ctx);
-        ADD_HOOK_FUNCTION(slot_subarray, ctx);
-        ADD_HOOK_FUNCTION(slot_subfield, ctx);
-        ADD_HOOK_FUNCTION(slot_type, ctx);
-        ADD_HOOK_FUNCTION(slot_float, ctx);
-
-        ADD_HOOK_FUNCTION(trace, ctx);
-        ADD_HOOK_FUNCTION(trace_num, ctx);
-        ADD_HOOK_FUNCTION(trace_float, ctx);
-
-        ADD_HOOK_FUNCTION(meta_slot, ctx);
-        ADD_HOOK_FUNCTION(xpop_slot, ctx);
-
-        /*
-        ADD_HOOK_FUNCTION(str_find, ctx);
-        ADD_HOOK_FUNCTION(str_replace, ctx);
-        ADD_HOOK_FUNCTION(str_compare, ctx);
-        ADD_HOOK_FUNCTION(str_concat, ctx);
-        */
+#undef HOOK_API_DEFINITION
+#undef HOOK_WRAP_PARAMS
+#pragma pop_macro("HOOK_API_DEFINITION")
 
         WasmEdge_TableInstanceContext* hostTable =
             WasmEdge_TableInstanceCreate(tableType);

src/ripple/app/hook/guard_checker.cpp

@@ -1,3 +1,5 @@
+#define GUARD_CHECKER_BUILD
+#include "Enum.h"
 #include "Guard.h"
 #include <fcntl.h>
 #include <iostream>
@@ -79,7 +81,15 @@ main(int argc, char** argv)
 
     close(fd);
 
-    auto result = validateGuards(hook, std::cout, "", 3);
+    // Dummy rules for guard checker build
+    hook_api::Rules rules;
+
+    auto result = validateGuards(
+        hook,
+        std::cout,
+        "",
+        hook_api::getImportWhitelist(rules),
+        hook_api::getGuardRulesVersion(rules));
 
     if (!result)
     {

src/ripple/app/hook/hook_api.macro

@@ -0,0 +1,369 @@
+// int32_t _g(uint32_t guard_id, uint32_t maxiter);
+HOOK_API_DEFINITION(
+  int32_t, _g, (uint32_t, uint32_t),
+  uint256{})
+
+// int64_t accept(uint32_t read_ptr, uint32_t read_len, int64_t error_code);
+HOOK_API_DEFINITION(
+  int64_t, accept, (uint32_t, uint32_t, int64_t),
+  uint256{})
+
+// int64_t rollback(uint32_t read_ptr, uint32_t read_len, int64_t error_code);
+HOOK_API_DEFINITION(
+  int64_t, rollback, (uint32_t, uint32_t, int64_t),
+  uint256{})
+
+// int64_t util_raddr(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
+HOOK_API_DEFINITION(
+  int64_t, util_raddr, (uint32_t, uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t util_accid(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
+HOOK_API_DEFINITION(
+  int64_t, util_accid, (uint32_t, uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t util_verify(uint32_t dread_ptr, uint32_t dread_len, uint32_t sread_ptr, uint32_t sread_len, uint32_t kread_ptr, uint32_t kread_len);
+HOOK_API_DEFINITION(
+  int64_t, util_verify, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t util_sha512h(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
+HOOK_API_DEFINITION(
+  int64_t, util_sha512h, (uint32_t, uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t util_keylet(uint32_t write_ptr, uint32_t write_len, uint32_t keylet_type, uint32_t a, uint32_t b, uint32_t c, uint32_t d, uint32_t e, uint32_t f);
+HOOK_API_DEFINITION(
+  int64_t, util_keylet, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t sto_validate(uint32_t tread_ptr, uint32_t tread_len);
+HOOK_API_DEFINITION(
+  int64_t, sto_validate, (uint32_t, uint32_t),
+  uint256{})
+
+// int64_t sto_subfield(uint32_t read_ptr, uint32_t read_len, uint32_t field_id);
+HOOK_API_DEFINITION(
+  int64_t, sto_subfield, (uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t sto_subarray(uint32_t read_ptr, uint32_t read_len, uint32_t array_id);
+HOOK_API_DEFINITION(
+  int64_t, sto_subarray, (uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t sto_emplace(uint32_t write_ptr, uint32_t write_len, uint32_t sread_ptr, uint32_t sread_len, uint32_t fread_ptr, uint32_t fread_len, uint32_t field_id);
+HOOK_API_DEFINITION(
+  int64_t, sto_emplace, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t sto_erase(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len, uint32_t field_id);
+HOOK_API_DEFINITION(
+  int64_t, sto_erase, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t etxn_burden();
+HOOK_API_DEFINITION(
+  int64_t, etxn_burden, (),
+  uint256{})
+
+// int64_t etxn_details(uint32_t write_ptr, uint32_t write_len);
+HOOK_API_DEFINITION(
+  int64_t, etxn_details, (uint32_t, uint32_t),
+  uint256{})
+
+// int64_t etxn_fee_base(uint32_t read_ptr, uint32_t read_len);
+HOOK_API_DEFINITION(
+  int64_t, etxn_fee_base, (uint32_t, uint32_t),
+  uint256{})
+
+// int64_t etxn_reserve(uint32_t count);
+HOOK_API_DEFINITION(
+  int64_t, etxn_reserve, (uint32_t),
+  uint256{})
+
+// int64_t etxn_generation();
+HOOK_API_DEFINITION(
+  int64_t, etxn_generation, (),
+  uint256{})
+
+// int64_t etxn_nonce(uint32_t write_ptr, uint32_t write_len);
+HOOK_API_DEFINITION(
+  int64_t, etxn_nonce, (uint32_t, uint32_t),
+  uint256{})
+
+// int64_t emit(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
+HOOK_API_DEFINITION(
+  int64_t, emit, (uint32_t, uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t float_set(int32_t exponent, int64_t mantissa);
+HOOK_API_DEFINITION(
+  int64_t, float_set, (int32_t, int64_t),
+  uint256{})
+
+// int64_t float_multiply(int64_t float1, int64_t float2);
+HOOK_API_DEFINITION(
+  int64_t, float_multiply, (int64_t, int64_t),
+  uint256{})
+
+// int64_t float_mulratio(int64_t float1, uint32_t round_up, uint32_t numerator, uint32_t denominator);
+HOOK_API_DEFINITION(
+  int64_t, float_mulratio, (int64_t, uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t float_negate(int64_t float1);
+HOOK_API_DEFINITION(
+  int64_t, float_negate, (int64_t),
+  uint256{})
+
+// int64_t float_compare(int64_t float1, int64_t float2, uint32_t mode);
+HOOK_API_DEFINITION(
+  int64_t, float_compare, (int64_t, int64_t, uint32_t),
+  uint256{})
+
+// int64_t float_sum(int64_t float1, int64_t float2);
+HOOK_API_DEFINITION(
+  int64_t, float_sum, (int64_t, int64_t),
+  uint256{})
+
+// int64_t float_sto(uint32_t write_ptr, uint32_t write_len, uint32_t cread_ptr, uint32_t cread_len, uint32_t iread_ptr, uint32_t iread_len, int64_t float1, uint32_t field_code);
+HOOK_API_DEFINITION(
+  int64_t, float_sto, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, int64_t, uint32_t),
+  uint256{})
+
+// int64_t float_sto_set(uint32_t read_ptr, uint32_t read_len);
+HOOK_API_DEFINITION(
+  int64_t, float_sto_set, (uint32_t, uint32_t),
+  uint256{})
+
+// int64_t float_invert(int64_t float1);
+HOOK_API_DEFINITION(
+  int64_t, float_invert, (int64_t),
+  uint256{})
+
+// int64_t float_divide(int64_t float1, int64_t float2);
+HOOK_API_DEFINITION(
+  int64_t, float_divide, (int64_t, int64_t),
+  uint256{})
+
+// int64_t float_one();
+HOOK_API_DEFINITION(
+  int64_t, float_one, (),
+  uint256{})
+
+// int64_t float_mantissa(int64_t float1);
+HOOK_API_DEFINITION(
+  int64_t, float_mantissa, (int64_t),
+  uint256{})
+
+// int64_t float_sign(int64_t float1);
+HOOK_API_DEFINITION(
+  int64_t, float_sign, (int64_t),
+  uint256{})
+
+// int64_t float_int(int64_t float1, uint32_t decimal_places, uint32_t abs);
+HOOK_API_DEFINITION(
+  int64_t, float_int, (int64_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t float_log(int64_t float1);
+HOOK_API_DEFINITION(
+  int64_t, float_log, (int64_t),
+  uint256{})
+
+// int64_t float_root(int64_t float1, uint32_t n);
+HOOK_API_DEFINITION(
+  int64_t, float_root, (int64_t, uint32_t),
+  uint256{})
+
+// int64_t fee_base();
+HOOK_API_DEFINITION(
+  int64_t, fee_base, (),
+  uint256{})
+
+// int64_t ledger_seq();
+HOOK_API_DEFINITION(
+  int64_t, ledger_seq, (),
+  uint256{})
+
+// int64_t ledger_last_time();
+HOOK_API_DEFINITION(
+  int64_t, ledger_last_time, (),
+  uint256{})
+
+// int64_t ledger_last_hash(uint32_t write_ptr, uint32_t write_len);
+HOOK_API_DEFINITION(
+  int64_t, ledger_last_hash, (uint32_t, uint32_t),
+  uint256{})
+
+// int64_t ledger_nonce(uint32_t write_ptr, uint32_t write_len);
+HOOK_API_DEFINITION(
+  int64_t, ledger_nonce, (uint32_t, uint32_t),
+  uint256{})
+
+// int64_t ledger_keylet(uint32_t write_ptr, uint32_t write_len, uint32_t lread_ptr, uint32_t lread_len, uint32_t hread_ptr, uint32_t hread_len);
+HOOK_API_DEFINITION(
+  int64_t, ledger_keylet, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t hook_account(uint32_t write_ptr, uint32_t write_len);
+HOOK_API_DEFINITION(
+  int64_t, hook_account, (uint32_t, uint32_t),
+  uint256{})
+
+// int64_t hook_hash(uint32_t write_ptr, uint32_t write_len, int32_t hook_no);
+HOOK_API_DEFINITION(
+  int64_t, hook_hash, (uint32_t, uint32_t, int32_t),
+  uint256{})
+
+// int64_t hook_param_set(uint32_t read_ptr, uint32_t read_len, uint32_t kread_ptr, uint32_t kread_len, uint32_t hread_ptr, uint32_t hread_len);
+HOOK_API_DEFINITION(
+  int64_t, hook_param_set, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t hook_param(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
+HOOK_API_DEFINITION(
+  int64_t, hook_param, (uint32_t, uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t hook_again();
+HOOK_API_DEFINITION(
+  int64_t, hook_again, (),
+  uint256{})
+
+// int64_t hook_skip(uint32_t read_ptr, uint32_t read_len, uint32_t flags);
+HOOK_API_DEFINITION(
+  int64_t, hook_skip, (uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t hook_pos();
+HOOK_API_DEFINITION(
+  int64_t, hook_pos, (),
+  uint256{})
+
+// int64_t slot(uint32_t write_ptr, uint32_t write_len, uint32_t slot);
+HOOK_API_DEFINITION(
+  int64_t, slot, (uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t slot_clear(uint32_t slot);
+HOOK_API_DEFINITION(
+  int64_t, slot_clear, (uint32_t),
+  uint256{})
+
+// int64_t slot_count(uint32_t slot);
+HOOK_API_DEFINITION(
+  int64_t, slot_count, (uint32_t),
+  uint256{})
+
+// int64_t slot_set(uint32_t read_ptr, uint32_t read_len, uint32_t slot);
+HOOK_API_DEFINITION(
+  int64_t, slot_set, (uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t slot_size(uint32_t slot);
+HOOK_API_DEFINITION(
+  int64_t, slot_size, (uint32_t),
+  uint256{})
+
+// int64_t slot_subarray(uint32_t parent_slot, uint32_t array_id, uint32_t new_slot);
+HOOK_API_DEFINITION(
+  int64_t, slot_subarray, (uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t slot_subfield(uint32_t parent_slot, uint32_t field_id, uint32_t new_slot);
+HOOK_API_DEFINITION(
+  int64_t, slot_subfield, (uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t slot_type(uint32_t slot_no, uint32_t flags);
+HOOK_API_DEFINITION(
+  int64_t, slot_type, (uint32_t, uint32_t),
+  uint256{})
+
+// int64_t slot_float(uint32_t slot_no);
+HOOK_API_DEFINITION(
+  int64_t, slot_float, (uint32_t),
+  uint256{})
+
+// int64_t state_set(uint32_t read_ptr, uint32_t read_len, uint32_t kread_ptr, uint32_t kread_len);
+HOOK_API_DEFINITION(
+  int64_t, state_set, (uint32_t, uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t state_foreign_set(uint32_t read_ptr, uint32_t read_len, uint32_t kread_ptr, uint32_t kread_len, uint32_t nread_ptr, uint32_t nread_len, uint32_t aread_ptr, uint32_t aread_len);
+HOOK_API_DEFINITION(
+  int64_t, state_foreign_set, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t state(uint32_t write_ptr, uint32_t write_len, uint32_t kread_ptr, uint32_t kread_len);
+HOOK_API_DEFINITION(
+  int64_t, state, (uint32_t, uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t state_foreign(uint32_t write_ptr, uint32_t write_len, uint32_t kread_ptr, uint32_t kread_len, uint32_t nread_ptr, uint32_t nread_len, uint32_t aread_ptr, uint32_t aread_len);
+HOOK_API_DEFINITION(
+  int64_t, state_foreign, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t trace(uint32_t mread_ptr, uint32_t mread_len, uint32_t dread_ptr, uint32_t dread_len, uint32_t as_hex);
+HOOK_API_DEFINITION(
+  int64_t, trace, (uint32_t, uint32_t, uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t trace_num(uint32_t read_ptr, uint32_t read_len, int64_t number);
+HOOK_API_DEFINITION(
+  int64_t, trace_num, (uint32_t, uint32_t, int64_t),
+  uint256{})
+
+// int64_t trace_float(uint32_t read_ptr, uint32_t read_len, int64_t float1);
+HOOK_API_DEFINITION(
+  int64_t, trace_float, (uint32_t, uint32_t, int64_t),
+  uint256{})
+
+// int64_t otxn_burden();
+HOOK_API_DEFINITION(
+  int64_t, otxn_burden, (),
+  uint256{})
+
+// int64_t otxn_field(uint32_t write_ptr, uint32_t write_len, uint32_t field_id);
+HOOK_API_DEFINITION(
+  int64_t, otxn_field, (uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t otxn_generation();
+HOOK_API_DEFINITION(
+  int64_t, otxn_generation, (),
+  uint256{})
+
+// int64_t otxn_id(uint32_t write_ptr, uint32_t write_len, uint32_t flags);
+HOOK_API_DEFINITION(
+  int64_t, otxn_id, (uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t otxn_type();
+HOOK_API_DEFINITION(
+  int64_t, otxn_type, (),
+  uint256{})
+
+// int64_t otxn_slot(uint32_t slot_no);
+HOOK_API_DEFINITION(
+  int64_t, otxn_slot, (uint32_t),
+  uint256{})
+
+// int64_t otxn_param(uint32_t write_ptr, uint32_t write_len, uint32_t read_ptr, uint32_t read_len);
+HOOK_API_DEFINITION(
+  int64_t, otxn_param, (uint32_t, uint32_t, uint32_t, uint32_t),
+  uint256{})
+
+// int64_t meta_slot(uint32_t slot_no);
+HOOK_API_DEFINITION(
+  int64_t, meta_slot, (uint32_t),
+  uint256{})
+
+// int64_t xpop_slot(uint32_t slot_no_tx, uint32_t slot_no_meta);
+HOOK_API_DEFINITION(
+  int64_t, xpop_slot, (uint32_t, uint32_t),
+  featureHooksUpdate1)

src/ripple/app/tx/impl/Change.cpp

@@ -17,6 +17,7 @@
 */
 //==============================================================================
 
+#include <ripple/app/hook/Enum.h>
 #include <ripple/app/hook/Guard.h>
 #include <ripple/app/hook/applyHook.h>
 #include <ripple/app/ledger/Ledger.h>
@@ -605,8 +606,8 @@ Change::activateXahauGenesis()
                 wasmBytes,  // wasm to verify
                 loggerStream,
                 "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
-                (ctx_.view().rules().enabled(featureHooksUpdate1) ? 1 : 0) +
-                    (ctx_.view().rules().enabled(fix20250131) ? 2 : 0));
+                hook_api::getImportWhitelist(ctx_.view().rules()),
+                hook_api::getGuardRulesVersion(ctx_.view().rules()));
 
             if (!result)
             {

src/ripple/app/tx/impl/SetHook.cpp

@@ -490,8 +490,8 @@ SetHook::validateHookSetEntry(SetHookCtx& ctx, STObject const& hookSetObj)
                     hook,  // wasm to verify
                     logger,
                     hsacc,
-                    (ctx.rules.enabled(featureHooksUpdate1) ? 1 : 0) +
-                        (ctx.rules.enabled(fix20250131) ? 2 : 0));
+                    hook_api::getImportWhitelist(ctx.rules),
+                    hook_api::getGuardRulesVersion(ctx.rules));
 
                 if (ctx.j.trace())
                 {

src/ripple/basics/Expected.h

@@ -137,14 +137,14 @@ class [[nodiscard]] Expected
 public:
     template <typename U>
     requires std::convertible_to<U, T> constexpr Expected(U && r)
-        : Base(T(std::forward<U>(r)))
+        : Base(boost::outcome_v2::success(T(std::forward<U>(r))))
     {
     }
 
     template <typename U>
         requires std::convertible_to<U, E> &&
         (!std::is_reference_v<U>)constexpr Expected(Unexpected<U> e)
-        : Base(E(std::move(e.value())))
+        : Base(boost::outcome_v2::failure(E(std::move(e.value()))))
     {
     }
 
@@ -220,7 +220,7 @@ public:
     template <typename U>
         requires std::convertible_to<U, E> &&
         (!std::is_reference_v<U>)constexpr Expected(Unexpected<U> e)
-        : Base(E(std::move(e.value())))
+        : Base(boost::outcome_v2::failure(E(std::move(e.value()))))
     {
     }
 

src/test/app/build_test_hooks.sh

@@ -58,21 +58,8 @@ cat $INPUT_FILE | tr '\n' '\f' |
             then
                 echo '#include "api.h"' > "$WASM_DIR/test-$COUNTER-gen.c"
                 tr '\f' '\n' <<< $line >> "$WASM_DIR/test-$COUNTER-gen.c"
-                DECLARED="`tr '\f' '\n' <<< $line \
-                  | grep  -E '(extern|static|define) ' \
-                  | grep -Eo '[a-z\-\_]+ *\(' \
-                  | grep -v 'sizeof' \
-                  | sed -E 's/[^a-z\-\_]//g' \
-                  | grep -vE '^__attribute__$' \
-                  | sort | uniq`"
-
-                USED="`tr '\f' '\n' <<< $line \
-                  | grep -vE '(extern|static|define) ' \
-                  | grep -Eo '[a-z\-\_]+\(' \
-                  | grep -v 'sizeof' \
-                  | sed -E 's/[^a-z\-\_]//g' \
-                  | grep -vE '^(__attribute__|hook|cbak)$' \
-                  | sort | uniq`"
+                DECLARED="`tr '\f' '\n' <<< $line | grep  -E '(extern|define) ' | grep -Eo '[a-z\-\_]+ *\(' | grep -v 'sizeof' | sed -E 's/[^a-z\-\_]//g' | sort | uniq`"
+                USED="`tr '\f' '\n' <<< $line | grep -vE '(extern|define) ' | grep -Eo '[a-z\-\_]+\(' | grep -v 'sizeof' | sed -E 's/[^a-z\-\_]//g' | grep -vE '^(hook|cbak)' | sort | uniq`"
                 ONCE="`echo $DECLARED $USED | tr ' ' '\n' | sort | uniq -c | grep '1 ' | sed -E 's/^ *1 //g'`"
                 FILTER="`echo $DECLARED | tr ' ' '|' | sed -E 's/\|$//g'`"
                 UNDECL="`echo $ONCE | grep -v -E $FILTER 2>/dev/null || echo ''`"
@@ -82,7 +69,7 @@ cat $INPUT_FILE | tr '\n' '\f' |
                     echo "$line"
                     exit 1
                 fi
-                wasmcc -x c /dev/stdin -o /dev/stdout -O2 -Wl,--allow-undefined,--export=hook,--export=cbak <<< "`tr '\f' '\n' <<< $line`" |
+                wasmcc -x c /dev/stdin -o /dev/stdout -O2 -Wl,--allow-undefined <<< "`tr '\f' '\n' <<< $line`" |
                     hook-cleaner - - 2>/dev/null |
                     xxd -p -u -c 10 | 
                     sed -E 's/../0x&U,/g' | sed -E 's/^/    /g' >> $OUTPUT_FILE

src/test/jtx/hook.h

@@ -20,9 +20,13 @@
 #ifndef RIPPLE_TEST_JTX_HOOK_H_INCLUDED
 #define RIPPLE_TEST_JTX_HOOK_H_INCLUDED
 
+#include <ripple/app/hook/applyHook.h>
 #include <ripple/json/json_value.h>
+#include <cstdint>
+#include <map>
 #include <optional>
 #include <test/jtx/Account.h>
+#include <vector>
 
 namespace ripple {
 namespace test {
@@ -43,6 +47,75 @@ hso(std::string const& wasmHex, void (*f)(Json::Value& jv) = 0);
 Json::Value
 hso_delete(void (*f)(Json::Value& jv) = 0);
 
+struct StubHookResult
+{
+    ripple::uint256 const hookSetTxnID = ripple::uint256();
+    ripple::uint256 const hookHash = ripple::uint256();
+    ripple::uint256 const hookCanEmit = ripple::uint256();
+    ripple::uint256 const hookNamespace = ripple::uint256();
+
+    std::queue<std::shared_ptr<ripple::Transaction>> emittedTxn{};
+    std::optional<hook::HookStateMap> stateMap = std::nullopt;
+    uint16_t changedStateCount = 0;
+    std::map<
+        ripple::uint256,  // hook hash
+        std::map<
+            std::vector<uint8_t>,  // hook param name
+            std::vector<uint8_t>   // hook param value
+            >>
+        hookParamOverrides = {};
+
+    std::optional<std::map<std::vector<uint8_t>, std::vector<uint8_t>>>
+        hookParams = std::nullopt;
+    std::set<ripple::uint256> hookSkips = {};
+    hook_api::ExitType exitType = hook_api::ExitType::ROLLBACK;
+    std::string exitReason{""};
+    int64_t exitCode{-1};
+    uint64_t instructionCount{0};
+    bool hasCallback = false;
+    bool isCallback = false;
+    bool isStrong = false;
+    uint32_t wasmParam = 0;
+    uint32_t overrideCount = 0;
+    uint8_t hookChainPosition = 0;
+    bool foreignStateSetDisabled = false;
+    bool executeAgainAsWeak = false;
+    std::shared_ptr<STObject const> provisionalMeta = nullptr;
+};
+
+struct StubHookContext
+{
+    std::map<uint32_t, hook::SlotEntry> slot{};
+    std::queue<uint32_t> slot_free{};
+    uint32_t slot_counter{0};
+    uint16_t emit_nonce_counter{0};
+    uint16_t ledger_nonce_counter{0};
+    int64_t expected_etxn_count{-1};
+    std::map<ripple::uint256, bool> nonce_used{};
+    uint32_t generation = 0;
+    uint64_t burden = 0;
+    std::map<uint32_t, uint32_t> guard_map{};
+    StubHookResult result = {};
+    std::optional<ripple::STObject> emitFailure = std::nullopt;
+    const hook::HookExecutor* module = 0;
+};
+
+// Overload that takes external stateMap to avoid dangling reference
+hook::HookContext
+makeStubHookContext(
+    ripple::ApplyContext& applyCtx,
+    ripple::AccountID const& hookAccount,
+    ripple::AccountID const& otxnAccount,
+    StubHookContext const& stubHookContext,
+    hook::HookStateMap& stateMap);
+
+hook::HookContext
+makeStubHookContext(
+    ripple::ApplyContext& applyCtx,
+    ripple::AccountID const& hookAccount,
+    ripple::AccountID const& otxnAccount,
+    StubHookContext const& stubHookContext);
+
 }  // namespace jtx
 }  // namespace test
 }  // namespace ripple

src/test/jtx/impl/hook.cpp

@@ -18,7 +18,9 @@
 //==============================================================================
 
 #include <ripple/app/hook/Enum.h>
+#include <ripple/app/hook/applyHook.h>
 #include <ripple/basics/contract.h>
+#include <ripple/protocol/Keylet.h>
 #include <ripple/protocol/jss.h>
 #include <stdexcept>
 #include <test/jtx/hook.h>
@@ -102,6 +104,81 @@ hso(std::string const& wasmHex, void (*f)(Json::Value& jv))
     return jv;
 }
 
+// Helper function to create HookContext with external stateMap
+hook::HookContext
+makeStubHookContext(
+    ripple::ApplyContext& applyCtx,
+    ripple::AccountID const& hookAccount,
+    ripple::AccountID const& otxnAccount,
+    StubHookContext const& stubHookContext,
+    hook::HookStateMap& stateMap)
+{
+    auto& result = stubHookContext.result;
+    auto hookParams = result.hookParams.value_or(
+        std::map<std::vector<uint8_t>, std::vector<uint8_t>>{});
+    return hook::HookContext{
+        .applyCtx = applyCtx,
+        .slot = stubHookContext.slot,
+        .slot_free = stubHookContext.slot_free,
+        .slot_counter = stubHookContext.slot_counter,
+        .emit_nonce_counter = stubHookContext.emit_nonce_counter,
+        .ledger_nonce_counter = stubHookContext.ledger_nonce_counter,
+        .expected_etxn_count = stubHookContext.expected_etxn_count,
+        .nonce_used = stubHookContext.nonce_used,
+        .generation = stubHookContext.generation,
+        .burden = stubHookContext.burden,
+        .guard_map = stubHookContext.guard_map,
+        .result =
+            {
+                .hookSetTxnID = result.hookSetTxnID,
+                .hookHash = result.hookHash,
+                .hookCanEmit = result.hookCanEmit,
+                .accountKeylet = keylet::account(hookAccount),
+                .hookKeylet = keylet::hook(hookAccount),
+                .account = hookAccount,
+                .otxnAccount = otxnAccount,
+                .hookNamespace = result.hookNamespace,
+                .emittedTxn = result.emittedTxn,
+                .stateMap = stateMap,
+                .changedStateCount = result.changedStateCount,
+                .hookParamOverrides = result.hookParamOverrides,
+                .hookParams = hookParams,
+                .hookSkips = result.hookSkips,
+                .exitType = result.exitType,
+                .exitReason = result.exitReason,
+                .exitCode = result.exitCode,
+                .instructionCount = result.instructionCount,
+                .hasCallback = result.hasCallback,
+                .isCallback = result.isCallback,
+                .isStrong = result.isStrong,
+                .wasmParam = result.wasmParam,
+                .overrideCount = result.overrideCount,
+                .hookChainPosition = result.hookChainPosition,
+                .foreignStateSetDisabled = result.foreignStateSetDisabled,
+                .executeAgainAsWeak = result.executeAgainAsWeak,
+                .provisionalMeta = result.provisionalMeta,
+            },
+        .emitFailure = stubHookContext.emitFailure,
+        .module = nullptr};
+}
+
+// Original function - WARNING: stateMap reference may become dangling
+// Only use when stateMap access is not needed after HookContext creation
+hook::HookContext
+makeStubHookContext(
+    ripple::ApplyContext& applyCtx,
+    ripple::AccountID const& hookAccount,
+    ripple::AccountID const& otxnAccount,
+    StubHookContext const& stubHookContext)
+{
+    // Use thread_local to keep stateMap alive
+    // Note: This is a workaround; each call resets the stateMap
+    thread_local hook::HookStateMap stateMap;
+    stateMap = stubHookContext.result.stateMap.value_or(hook::HookStateMap{});
+    return makeStubHookContext(
+        applyCtx, hookAccount, otxnAccount, stubHookContext, stateMap);
+}
+
 }  // namespace jtx
 }  // namespace test
 }  // namespace ripple