Merge remote-tracking branch 'upstream/dev' into hook-helper-func

change build instructions url
Fix BEAST_ENHANCED_LOGGING not working and restore original behavior
2026-04-29 15:37:46 +00:00 · 2026-04-27 14:17:42 +09:00 · 2026-04-24 11:12:28 +10:00 · 2026-04-24 11:11:40 +10:00 · 2026-04-24 11:10:46 +10:00 · 2026-04-24 11:09:19 +10:00
20 changed files with 2607 additions and 2902 deletions
--- a/.codecov.yml
+++ b/.codecov.yml
@@ -1,6 +0,0 @@
-coverage:
-  status:
-    project:
-      default:
-        target: 60%
-        threshold: 2%
--- a/.github/actions/xahau-ga-build/action.yml
+++ b/.github/actions/xahau-ga-build/action.yml
@@ -2,14 +2,6 @@ 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
@@ -28,10 +20,6 @@ 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
@@ -53,11 +41,10 @@ inputs:
    required: false
    default: 'dev'
  stdlib:
-    description: 'C++ standard library to use (default = compiler default, e.g. GCC always uses libstdc++)'
+    description: 'C++ standard library to use'
    required: true
    type: choice
    options:
-      - default
      - libstdcxx
      - libcxx
  clang_gcc_toolchain:
@@ -100,6 +87,11 @@ 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 }}
@@ -130,10 +122,6 @@ 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
@@ -197,8 +185,7 @@ runs:
          -DCMAKE_TOOLCHAIN_FILE:FILEPATH=${TOOLCHAIN_FILE} \
          -DCMAKE_BUILD_TYPE=${{ inputs.configuration }} \
          -Dtests=TRUE \
-          -Dxrpld=TRUE \
-          ${{ inputs.cmake-args }}
+          -Dxrpld=TRUE

    - name: Show ccache config before build
      if: inputs.ccache_enabled == 'true'
@@ -222,7 +209,7 @@ runs:
          VERBOSE_FLAG="-- -v"
        fi

-        cmake --build . --config ${{ inputs.configuration }} --parallel $(nproc) --target ${{ inputs.cmake-target }} ${VERBOSE_FLAG}
+        cmake --build . --config ${{ inputs.configuration }} --parallel $(nproc) ${VERBOSE_FLAG}

    - name: Show ccache statistics
      if: inputs.ccache_enabled == 'true'
--- a/.github/workflows/check-genesis-hooks.yml
+++ b/.github/workflows/check-genesis-hooks.yml
@@ -1,107 +0,0 @@
-name: Check Genesis Hooks
-
-on:
-  push:
-  pull_request:
-
-jobs:
-  check-genesis-hooks:
-    runs-on: ubuntu-24.04
-    env:
-      CLANG_VERSION: 18
-    name: Verify xahau.h is in sync with genesis hooks
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      # Install binaryen from GitHub Releases (pinned to version 100)
-      - name: Install binaryen (version 100)
-        run: |
-          curl -LO https://github.com/WebAssembly/binaryen/releases/download/version_100/binaryen-version_100-x86_64-linux.tar.gz
-          tar -xzf binaryen-version_100-x86_64-linux.tar.gz
-          sudo cp binaryen-version_100/bin/* /usr/local/bin/
-          wasm-opt --version
-
-      - name: Install clang-format
-        run: |
-          codename=$( lsb_release --codename --short )
-          sudo tee /etc/apt/sources.list.d/llvm.list >/dev/null <<EOF
-          deb http://apt.llvm.org/${codename}/ llvm-toolchain-${codename}-${CLANG_VERSION} main
-          deb-src http://apt.llvm.org/${codename}/ llvm-toolchain-${codename}-${CLANG_VERSION} main
-          EOF
-          wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add
-          sudo apt-get update
-          sudo apt-get install clang-format-${CLANG_VERSION}
-          clang-format --version
-
-      # Install wasienv (WebAssembly SDK)
-      - name: Install wasienv
-        run: |
-          # Download install.sh
-          curl -o /tmp/wasienv-install.sh https://raw.githubusercontent.com/wasienv/wasienv/master/install.sh
-          
-          # Replace /bin to /local/bin
-          sed -i 's|/bin|/local/bin|g' /tmp/wasienv-install.sh
-
-          # Execute the installed script
-          bash /tmp/wasienv-install.sh
-
-      # Add wasienv to PATH for subsequent steps
-      - name: Setup wasienv
-        run: |
-          echo "$HOME/.wasienv/bin" >> $GITHUB_PATH
-          wasmcc -v || true
-
-      # Build and install hook-cleaner tool
-      - name: Build and install hook-cleaner
-        run: |
-          git clone https://github.com/richardah/hook-cleaner-c.git /tmp/hook-cleaner
-          cd /tmp/hook-cleaner
-          make
-          cp hook-cleaner /usr/local/bin/
-          chmod +x /usr/local/bin/hook-cleaner
-
-      # Build and install guard_checker tool
-      - name: Build and install guard_checker
-        run: |
-          cd include/xrpl/hook
-          make
-          cp guard_checker /usr/local/bin/
-          chmod +x /usr/local/bin/guard_checker
-
-      # Verify all required tools are available
-      - name: Verify required tools
-        run: |
-          echo "Checking tool availability..."
-          command -v wasmcc || (echo "Error: wasmcc not found" && exit 1)
-          command -v wasm-opt || (echo "Error: wasm-opt not found" && exit 1)
-          command -v hook-cleaner || (echo "Error: hook-cleaner not found" && exit 1)
-          command -v guard_checker || (echo "Error: guard_checker not found" && exit 1)
-          command -v xxd || (echo "Error: xxd not found" && exit 1)
-          command -v clang-format || (echo "Error: clang-format not found" && exit 1)
-          echo "All tools verified successfully"
-
-      # Execute build script to regenerate xahau.h
-      - name: Run build_xahau_h.sh
-        run: |
-          cd hook/genesis
-          ./build_xahau_h.sh
-
-      # Check if xahau.h has changed (fail if out of sync)
-      - name: Verify xahau.h is in sync
-        run: |
-          if ! git diff --exit-code include/xrpl/hook/xahau.h; then
-            echo ""
-            echo "❌ ERROR: xahau.h is out of sync with genesis hooks"
-            echo ""
-            echo "The generated xahau.h differs from the committed version."
-            echo "Please run the following command and commit the changes:"
-            echo ""
-            echo "    cd hook/genesis && ./build_xahau_h.sh"
-            echo ""
-            echo "Diff:"
-            git diff include/xrpl/hook/xahau.h
-            exit 1
-          fi
-          echo "✅ xahau.h is in sync with genesis hooks"
--- a/.github/workflows/xahau-ga-nix.yml
+++ b/.github/workflows/xahau-ga-nix.yml
@@ -57,9 +57,8 @@ jobs:
                  "cc": "gcc-11",
                  "cxx": "g++-11",
                  "compiler_version": 11,
-                  "stdlib": "default",
-                  "configuration": "Debug",
-                  "job_type": "build"
+                  "stdlib": "libstdcxx",
+                  "configuration": "Debug"
              },
              {
                  "compiler_id": "gcc-13-libstdcxx",
@@ -67,20 +66,8 @@ jobs:
                  "cc": "gcc-13",
                  "cxx": "g++-13",
                  "compiler_version": 13,
-                  "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"
+                  "stdlib": "libstdcxx",
+                  "configuration": "Debug"
              },
              {
                  "compiler_id": "clang-14-libstdcxx-gcc11",
@@ -90,8 +77,7 @@ jobs:
                  "compiler_version": 14,
                  "stdlib": "libstdcxx",
                  "clang_gcc_toolchain": 11,
-                  "configuration": "Debug",
-                  "job_type": "build"
+                  "configuration": "Debug"
              },
              {
                  "compiler_id": "clang-16-libstdcxx-gcc13",
@@ -101,8 +87,7 @@ jobs:
                  "compiler_version": 16,
                  "stdlib": "libstdcxx",
                  "clang_gcc_toolchain": 13,
-                  "configuration": "Debug",
-                  "job_type": "build"
+                  "configuration": "Debug"
              },
              {
                  "compiler_id": "clang-17-libcxx",
@@ -111,8 +96,7 @@ jobs:
                  "cxx": "clang++-17",
                  "compiler_version": 17,
                  "stdlib": "libcxx",
-                  "configuration": "Debug",
-                  "job_type": "build"
+                  "configuration": "Debug"
              },
              {
                  # Clang 18 - testing if it's faster than Clang 17 with libc++
@@ -123,16 +107,14 @@ jobs:
                  "cxx": "clang++-18",
                  "compiler_version": 18,
                  "stdlib": "libcxx",
-                  "configuration": "Debug",
-                  "job_type": "build"
+                  "configuration": "Debug"
              }
          ]
          
          # Minimal matrix for PRs and feature branches
          minimal_matrix = [
              full_matrix[1],  # gcc-13 (middle-ground gcc)
-              full_matrix[2],  # gcc-13 coverage
-              full_matrix[3]   # clang-14 (mature, stable clang)
+              full_matrix[2]   # clang-14 (mature, stable clang)
          ]
          
          # Determine which matrix to use based on the target branch
@@ -207,21 +189,14 @@ jobs:
          # Select the appropriate matrix
          if use_full:
              if force_full:
-                  print(f"Using FULL matrix (7 configs) - forced by [ci-nix-full-matrix] tag")
+                  print(f"Using FULL matrix (6 configs) - forced by [ci-nix-full-matrix] tag")
              else:
-                  print(f"Using FULL matrix (7 configs) - targeting main branch")
+                  print(f"Using FULL matrix (6 configs) - targeting main branch")
              matrix = full_matrix
          else:
-              print(f"Using MINIMAL matrix (3 configs) - feature branch/PR")
+              print(f"Using MINIMAL matrix (2 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:
@@ -229,10 +204,7 @@ jobs:

  build:
    needs: matrix-setup
-    runs-on: ${{ fromJSON(matrix.runs_on) }}
-    permissions:
-      id-token: write
-      contents: read
+    runs-on: [self-hosted, generic, 20.04]
    container:
      image: ubuntu:24.04
      volumes:
@@ -261,7 +233,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 git python3 python-is-python3 pipx
+          apt-get install -y 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
@@ -332,12 +304,6 @@ 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 curl lcov
-          fi
-
      - name: Check environment
        run: |
          echo "PATH:"
@@ -347,13 +313,6 @@ 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

@@ -381,7 +340,6 @@ 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
@@ -396,27 +354,7 @@ 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 }}
-          # Coverage builds are slower due to instrumentation; use fewer parallel jobs to avoid flakiness
-          cmake-args: '-Dcoverage=ON -Dcoverage_format=xml -Dcoverage_test_parallelism=$(($(nproc)/2)) -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 }}"
@@ -429,7 +367,6 @@ 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
@@ -438,29 +375,3 @@ 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: codecov/codecov-action@v5
-        with:
-          files: coverage.xml
-          fail_ci_if_error: true
-          disable_search: true
-          verbose: true
-          plugins: noop
-          use_oidc: true
--- a/.gitignore
+++ b/.gitignore
@@ -129,3 +129,6 @@ generated

 # Suggested in-tree build directory
 /.build/
+
+guard_checker
+guard_checker.dSYM
--- a/hook/genesis/build_xahau_h.sh
+++ b/hook/genesis/build_xahau_h.sh
@@ -1,203 +0,0 @@
-#!/bin/bash
-
-# build_xahau_h.sh
-# Builds genesis hook WASMs and updates xahau.h with hex arrays
-
-set -euo pipefail
-
-# Color codes for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-# Script directory and path constants
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-XAHAU_H="${SCRIPT_DIR}/../../include/xrpl/hook/xahau.h"
-TEMP_DIR="${SCRIPT_DIR}/.temp"
-
-# Hook file mappings (space-separated: name:file)
-HOOK_FILES=(
-    "GovernanceHook:govern.wasm"
-    "RewardHook:reward.wasm"
-    # "MintHook:mint.wasm"
-)
-
-# Cleanup function
-cleanup() {
-    local exit_code=$?
-    if [ ${exit_code} -eq 0 ] && [ -d "${TEMP_DIR}" ]; then
-        rm -rf "${TEMP_DIR}"
-    elif [ ${exit_code} -ne 0 ]; then
-        echo -e "${RED}Error: Script failed with exit code ${exit_code}${NC}" >&2
-        if [ -d "${TEMP_DIR}" ]; then
-            echo -e "${YELLOW}Temp files preserved at: ${TEMP_DIR}${NC}" >&2
-        fi
-    fi
-    exit ${exit_code}
-}
-
-trap cleanup EXIT INT TERM
-
-# Tool verification
-echo -e "${BLUE}==> Checking required tools...${NC}"
-REQUIRED_TOOLS=("make" "xxd" "sed" "clang-format" "wasm-opt")
-for tool in "${REQUIRED_TOOLS[@]}"; do
-    if ! command -v "${tool}" &> /dev/null; then
-        echo -e "${RED}Error: Required tool '${tool}' not found${NC}" >&2
-        exit 1
-    fi
-    echo -e "${GREEN}    ✓ ${tool}${NC}"
-done
-
-# Verify wasm-opt version is exactly 100
-WASM_OPT_VERSION=$(wasm-opt --version | grep -oE '[0-9]+' | head -1)
-if [ "${WASM_OPT_VERSION}" != "100" ]; then
-    echo -e "${RED}Error: wasm-opt version must be 100, but found ${WASM_OPT_VERSION}${NC}" >&2
-    exit 1
-fi
-echo -e "${GREEN}    ✓ wasm-opt version 100${NC}"
-
-# Verify xahau.h exists
-if [ ! -f "${XAHAU_H}" ]; then
-    echo -e "${RED}Error: xahau.h not found at ${XAHAU_H}${NC}" >&2
-    exit 1
-fi
-
-# Create temp directory
-mkdir -p "${TEMP_DIR}"
-
-# Build all WASM files
-echo -e "${BLUE}==> Building WASM files with 'make all'...${NC}"
-cd "${SCRIPT_DIR}"
-make all
-echo -e "${GREEN}    Build completed successfully${NC}"
-
-# Function to convert WASM to hex array
-wasm_to_hex_array() {
-    local wasm_file="$1"
-    local indent="    "
-
-    if [ ! -f "${wasm_file}" ]; then
-        echo -e "${RED}Error: WASM file not found: ${wasm_file}${NC}" >&2
-        return 1
-    fi
-
-    # Convert to hex with xxd, format with sed
-    xxd -p -u -c 10 "${wasm_file}" | \
-        sed 's/../0x&U,/g' | \
-        sed "s/^/${indent}/g" | \
-        sed '$ s/,$//'
-}
-
-# Function to update hook array in xahau.h
-update_hook_array() {
-    local hook_name="$1"
-    local hex_array="$2"
-    local temp_file="${TEMP_DIR}/xahau.h.tmp"
-
-    echo -e "${BLUE}==> Updating ${hook_name}...${NC}"
-
-    # Check if hook already exists
-    if grep -q "static const std::vector<uint8_t> ${hook_name} = {" "${XAHAU_H}"; then
-        echo -e "${YELLOW}    Replacing existing ${hook_name}${NC}"
-
-        # Use awk to replace the array content
-        awk -v hook="${hook_name}" -v hex="${hex_array}" '
-        BEGIN { in_array=0 }
-        {
-            if ($0 ~ "static const std::vector<uint8_t> " hook " = {") {
-                print $0
-                print hex
-                in_array=1
-                next
-            }
-            if (in_array && $0 ~ /};/) {
-                print "};"
-                in_array=0
-                next
-            }
-            if (!in_array) {
-                print $0
-            }
-        }
-        ' "${XAHAU_H}" > "${temp_file}"
-
-        mv "${temp_file}" "${XAHAU_H}"
-    else
-        echo -e "${YELLOW}    Adding new ${hook_name}${NC}"
-
-        # Find the position before #endif and add the new hook
-        awk -v hook="${hook_name}" -v hex="${hex_array}" '
-        {
-            if ($0 ~ /#endif.*XAHAU_GENESIS_HOOKS/) {
-                print ""
-                print "static const std::vector<uint8_t> " hook " = {"
-                print hex
-                print "};"
-                print ""
-                print $0
-            } else {
-                print $0
-            }
-        }
-        ' "${XAHAU_H}" > "${temp_file}"
-
-        mv "${temp_file}" "${XAHAU_H}"
-    fi
-
-    echo -e "${GREEN}    ✓ ${hook_name} updated${NC}"
-}
-
-# Process each hook
-for hook_entry in "${HOOK_FILES[@]}"; do
-    hook_name="${hook_entry%%:*}"
-    wasm_file="${SCRIPT_DIR}/${hook_entry##*:}"
-
-    echo -e "${BLUE}==> Converting ${wasm_file} to hex array...${NC}"
-    hex_array=$(wasm_to_hex_array "${wasm_file}")
-
-    if [ $? -ne 0 ]; then
-        echo -e "${RED}Error: Failed to convert ${wasm_file}${NC}" >&2
-        exit 1
-    fi
-
-    echo -e "${GREEN}    Conversion successful ($(echo "${hex_array}" | wc -l) lines)${NC}"
-
-    update_hook_array "${hook_name}" "${hex_array}"
-done
-
-# Format with clang-format
-echo -e "${BLUE}==> Formatting with clang-format...${NC}"
-cp "${XAHAU_H}" "${TEMP_DIR}/xahau.h.before_format"
-clang-format -i "${XAHAU_H}"
-echo -e "${GREEN}    Formatting completed${NC}"
-
-# Verification
-echo -e "${BLUE}==> Verifying changes...${NC}"
-for hook_entry in "${HOOK_FILES[@]}"; do
-    hook_name="${hook_entry%%:*}"
-    if grep -q "static const std::vector<uint8_t> ${hook_name} = {" "${XAHAU_H}"; then
-        echo -e "${GREEN}    ✓ ${hook_name} found in xahau.h${NC}"
-    else
-        echo -e "${RED}    ✗ ${hook_name} NOT found in xahau.h${NC}" >&2
-        exit 1
-    fi
-done
-
-# Show summary
-echo ""
-echo -e "${GREEN}========================================${NC}"
-echo -e "${GREEN}Successfully updated xahau.h${NC}"
-echo -e "${GREEN}========================================${NC}"
-echo -e "Updated hooks:"
-for hook_entry in "${HOOK_FILES[@]}"; do
-    hook_name="${hook_entry%%:*}"
-    wasm_file="${SCRIPT_DIR}/${hook_entry##*:}"
-    size=$(wc -c < "${wasm_file}" | tr -d ' ')
-    echo -e "  - ${hook_name}: ${size} bytes"
-done
-echo ""
-echo -e "File location: ${XAHAU_H}"
-echo ""
--- a/hook/genesis/headers/error.h
+++ b/hook/genesis/headers/error.h
@@ -1,46 +0,0 @@
-// For documentation please see: https://xrpl-hooks.readme.io/reference/
-// Generated using generate_error.sh
-#ifndef HOOK_ERROR_CODES
-#define SUCCESS 0
-#define OUT_OF_BOUNDS -1
-#define INTERNAL_ERROR -2
-#define TOO_BIG -3
-#define TOO_SMALL -4
-#define DOESNT_EXIST -5
-#define NO_FREE_SLOTS -6
-#define INVALID_ARGUMENT -7
-#define ALREADY_SET -8
-#define PREREQUISITE_NOT_MET -9
-#define FEE_TOO_LARGE -10
-#define EMISSION_FAILURE -11
-#define TOO_MANY_NONCES -12
-#define TOO_MANY_EMITTED_TXN -13
-#define NOT_IMPLEMENTED -14
-#define INVALID_ACCOUNT -15
-#define GUARD_VIOLATION -16
-#define INVALID_FIELD -17
-#define PARSE_ERROR -18
-#define RC_ROLLBACK -19
-#define RC_ACCEPT -20
-#define NO_SUCH_KEYLET -21
-#define NOT_AN_ARRAY -22
-#define NOT_AN_OBJECT -23
-#define INVALID_FLOAT -10024
-#define DIVISION_BY_ZERO -25
-#define MANTISSA_OVERSIZED -26
-#define MANTISSA_UNDERSIZED -27
-#define EXPONENT_OVERSIZED -28
-#define EXPONENT_UNDERSIZED -29
-#define OVERFLOW -30
-#define NOT_IOU_AMOUNT -31
-#define NOT_AN_AMOUNT -32
-#define CANT_RETURN_NEGATIVE -33
-#define NOT_AUTHORIZED -34
-#define PREVIOUS_FAILURE_PREVENTS_RETRY -35
-#define TOO_MANY_PARAMS -36
-#define INVALID_TXN -37
-#define RESERVE_INSUFFICIENT -38
-#define COMPLEX_NOT_SUPPORTED -39
-#define DOES_NOT_MATCH -40
-#define HOOK_ERROR_CODES
-#endif //HOOK_ERROR_CODES
--- a/hook/genesis/headers/extern.h
+++ b/hook/genesis/headers/extern.h
@@ -1,352 +0,0 @@
-// For documentation please see: https://xrpl-hooks.readme.io/reference/
-// Generated using generate_extern.sh
-#include <stdint.h>
-#ifndef HOOK_EXTERN
-
-extern int32_t __attribute__((noduplicate))
-_g(uint32_t guard_id, uint32_t maxiter);
-
-extern int64_t
-accept(uint32_t read_ptr, uint32_t read_len, int64_t error_code);
-
-extern int64_t
-emit(
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t read_ptr,
-    uint32_t read_len);
-
-extern int64_t
-etxn_burden(void);
-
-extern int64_t
-etxn_details(uint32_t write_ptr, uint32_t write_len);
-
-extern int64_t
-etxn_fee_base(uint32_t read_ptr, uint32_t read_len);
-
-extern int64_t
-etxn_generation(void);
-
-extern int64_t
-etxn_nonce(uint32_t write_ptr, uint32_t write_len);
-
-extern int64_t
-etxn_reserve(uint32_t count);
-
-extern int64_t
-fee_base(void);
-
-extern int64_t
-float_compare(int64_t float1, int64_t float2, uint32_t mode);
-
-extern int64_t
-float_divide(int64_t float1, int64_t float2);
-
-extern int64_t
-float_exponent(int64_t float1);
-
-extern int64_t
-float_exponent_set(int64_t float1, int32_t exponent);
-
-extern int64_t
-float_int(int64_t float1, uint32_t decimal_places, uint32_t abs);
-
-extern int64_t
-float_invert(int64_t float1);
-
-extern int64_t
-float_log(int64_t float1);
-
-extern int64_t
-float_mantissa(int64_t float1);
-
-extern int64_t
-float_mantissa_set(int64_t float1, int64_t mantissa);
-
-extern int64_t
-float_mulratio(
-    int64_t float1,
-    uint32_t round_up,
-    uint32_t numerator,
-    uint32_t denominator);
-
-extern int64_t
-float_multiply(int64_t float1, int64_t float2);
-
-extern int64_t
-float_negate(int64_t float1);
-
-extern int64_t
-float_one(void);
-
-extern int64_t
-float_root(int64_t float1, uint32_t n);
-
-extern int64_t
-float_set(int32_t exponent, int64_t mantissa);
-
-extern int64_t
-float_sign(int64_t float1);
-
-extern int64_t
-float_sign_set(int64_t float1, uint32_t negative);
-
-extern 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);
-
-extern int64_t
-float_sto_set(uint32_t read_ptr, uint32_t read_len);
-
-extern int64_t
-float_sum(int64_t float1, int64_t float2);
-
-extern int64_t
-hook_account(uint32_t write_ptr, uint32_t write_len);
-
-extern int64_t
-hook_again(void);
-
-extern int64_t
-hook_hash(uint32_t write_ptr, uint32_t write_len, int32_t hook_no);
-
-extern int64_t
-hook_param(
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t read_ptr,
-    uint32_t read_len);
-
-extern int64_t
-otxn_param(
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t read_ptr,
-    uint32_t read_len);
-
-extern 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);
-
-extern int64_t
-hook_pos(void);
-
-extern int64_t
-hook_skip(uint32_t read_ptr, uint32_t read_len, uint32_t flags);
-
-extern 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);
-
-extern int64_t
-ledger_last_hash(uint32_t write_ptr, uint32_t write_len);
-
-extern int64_t
-ledger_last_time(void);
-
-extern int64_t
-ledger_nonce(uint32_t write_ptr, uint32_t write_len);
-
-extern int64_t
-ledger_seq(void);
-
-extern int64_t
-meta_slot(uint32_t slot_no);
-
-extern int64_t
-otxn_burden(void);
-
-extern int64_t
-otxn_field(uint32_t write_ptr, uint32_t write_len, uint32_t field_id);
-
-extern int64_t
-otxn_field_txt(uint32_t write_ptr, uint32_t write_len, uint32_t field_id);
-
-extern int64_t
-otxn_generation(void);
-
-extern int64_t
-otxn_id(uint32_t write_ptr, uint32_t write_len, uint32_t flags);
-
-extern int64_t
-otxn_slot(uint32_t slot_no);
-
-extern int64_t
-otxn_type(void);
-
-extern int64_t
-rollback(uint32_t read_ptr, uint32_t read_len, int64_t error_code);
-
-extern int64_t
-slot(uint32_t write_ptr, uint32_t write_len, uint32_t slot);
-
-extern int64_t
-slot_clear(uint32_t slot);
-
-extern int64_t
-slot_count(uint32_t slot);
-
-extern int64_t
-slot_float(uint32_t slot_no);
-
-extern int64_t
-slot_id(uint32_t write_ptr, uint32_t write_len, uint32_t slot);
-
-extern int64_t
-slot_set(uint32_t read_ptr, uint32_t read_len, uint32_t slot);
-
-extern int64_t
-slot_size(uint32_t slot);
-
-extern int64_t
-slot_subarray(uint32_t parent_slot, uint32_t array_id, uint32_t new_slot);
-
-extern int64_t
-slot_subfield(uint32_t parent_slot, uint32_t field_id, uint32_t new_slot);
-
-extern int64_t
-slot_type(uint32_t slot_no, uint32_t flags);
-
-extern int64_t
-state(
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t kread_ptr,
-    uint32_t kread_len);
-
-extern 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);
-
-extern 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);
-
-extern int64_t
-state_set(
-    uint32_t read_ptr,
-    uint32_t read_len,
-    uint32_t kread_ptr,
-    uint32_t kread_len);
-
-extern 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);
-
-extern int64_t
-sto_erase(
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t read_ptr,
-    uint32_t read_len,
-    uint32_t field_id);
-
-extern int64_t
-sto_subarray(uint32_t read_ptr, uint32_t read_len, uint32_t array_id);
-
-extern int64_t
-sto_subfield(uint32_t read_ptr, uint32_t read_len, uint32_t field_id);
-
-extern int64_t
-sto_validate(uint32_t tread_ptr, uint32_t tread_len);
-
-extern int64_t
-trace(
-    uint32_t mread_ptr,
-    uint32_t mread_len,
-    uint32_t dread_ptr,
-    uint32_t dread_len,
-    uint32_t as_hex);
-
-extern int64_t
-trace_float(uint32_t read_ptr, uint32_t read_len, int64_t float1);
-
-extern int64_t
-trace_num(uint32_t read_ptr, uint32_t read_len, int64_t number);
-
-extern int64_t
-trace_slot(uint32_t read_ptr, uint32_t read_len, uint32_t slot);
-
-extern int64_t
-util_accid(
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t read_ptr,
-    uint32_t read_len);
-
-extern 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);
-
-extern int64_t
-util_raddr(
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t read_ptr,
-    uint32_t read_len);
-
-extern int64_t
-util_sha512h(
-    uint32_t write_ptr,
-    uint32_t write_len,
-    uint32_t read_ptr,
-    uint32_t read_len);
-
-extern 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);
-
-extern int64_t xpop_slot(uint32_t, uint32_t);
-#define HOOK_EXTERN
-#endif  // HOOK_EXTERN
--- a/hook/genesis/headers/hookapi.h
+++ b/hook/genesis/headers/hookapi.h
@@ -1,50 +0,0 @@
-/**
- * Hook API include file
- *
- * Note to the reader:
- * This include defines two types of things: external functions and macros
- * Functions are used sparingly because a non-inlining compiler may produce
- * undesirable output.
- *
- * Find documentation here: https://xrpl-hooks.readme.io/reference/
- */
-
-#ifndef HOOKAPI_INCLUDED
-#define HOOKAPI_INCLUDED 1
-
-#define KEYLET_HOOK 1
-#define KEYLET_HOOK_STATE 2
-#define KEYLET_ACCOUNT 3
-#define KEYLET_AMENDMENTS 4
-#define KEYLET_CHILD 5
-#define KEYLET_SKIP 6
-#define KEYLET_FEES 7
-#define KEYLET_NEGATIVE_UNL 8
-#define KEYLET_LINE 9
-#define KEYLET_OFFER 10
-#define KEYLET_QUALITY 11
-#define KEYLET_EMITTED_DIR 12
-#define KEYLET_TICKET 13
-#define KEYLET_SIGNERS 14
-#define KEYLET_CHECK 15
-#define KEYLET_DEPOSIT_PREAUTH 16
-#define KEYLET_UNCHECKED 17
-#define KEYLET_OWNER_DIR 18
-#define KEYLET_PAGE 19
-#define KEYLET_ESCROW 20
-#define KEYLET_PAYCHAN 21
-#define KEYLET_EMITTED 22
-#define KEYLET_NFT_OFFER 23
-#define KEYLET_HOOK_DEFINITION 24
-
-#define COMPARE_EQUAL 1U
-#define COMPARE_LESS 2U
-#define COMPARE_GREATER 4U
-
-#include "error.h"
-#include "extern.h"
-#include "sfcodes.h"
-#include "macro.h"
-#include "types.h"
-
-#endif
--- a/hook/genesis/headers/macro.h
+++ b/hook/genesis/headers/macro.h
@@ -1,671 +0,0 @@
-/**
- * These are helper macros for writing hooks, all of them are optional as is including hookmacro.h at all
- */
-
-#include <stdint.h>
-#include "hookapi.h"
-#include "sfcodes.h"
-
-#ifndef HOOKMACROS_INCLUDED
-#define HOOKMACROS_INCLUDED 1
-
-
-#ifdef NDEBUG
-#define DEBUG 0
-#else
-#define DEBUG 1
-#endif
-
-#define TRACEVAR(v) if (DEBUG) trace_num((uint32_t)(#v), (uint32_t)(sizeof(#v) - 1), (int64_t)v);
-#define TRACEHEX(v) if (DEBUG) trace((uint32_t)(#v), (uint32_t)(sizeof(#v) - 1), (uint32_t)(v), (uint32_t)(sizeof(v)), 1);
-#define TRACEXFL(v) if (DEBUG) trace_float((uint32_t)(#v), (uint32_t)(sizeof(#v) - 1), (int64_t)v);
-#define TRACESTR(v) if (DEBUG) trace((uint32_t)(#v), (uint32_t)(sizeof(#v) - 1), (uint32_t)(v), sizeof(v), 0);
-
-// hook developers should use this guard macro, simply GUARD(<maximum iterations>)
-#define GUARD(maxiter) _g((1ULL << 31U) + __LINE__, (maxiter)+1)
-#define GUARDM(maxiter, n) _g(( (1ULL << 31U) + (__LINE__ << 16) + n), (maxiter)+1)
-
-#define SBUF(str) (uint32_t)(str), sizeof(str)
-
-#define REQUIRE(cond, str)\
-{\
-    if (!(cond))\
-        rollback(SBUF(str), __LINE__);\
-}
-
-// make a report buffer as a c-string
-// provide a name for a buffer to declare (buf)
-// provide a static string
-// provide an integer to print after the string
-#define RBUF(buf, out_len, str, num)\
-unsigned char buf[sizeof(str) + 21];\
-int out_len = 0;\
-{\
-    int i = 0;\
-    for (; GUARDM(sizeof(str),1),i < sizeof(str); ++i)\
-        (buf)[i] = str[i];\
-    if ((buf)[sizeof(str)-1] == 0) i--;\
-    if ((num) < 0) (buf)[i++] = '-';\
-    uint64_t unsigned_num = (uint64_t)( (num) < 0 ? (num) * -1 : (num) );\
-    uint64_t j = 10000000000000000000ULL;\
-    int start = 1;\
-    for (; GUARDM(20,2), unsigned_num > 0 && j > 0; j /= 10)\
-    {\
-        unsigned char digit = ( unsigned_num / j ) % 10;\
-        if (digit == 0 && start)\
-            continue;\
-        start = 0;\
-        (buf)[i++] = '0' + digit;\
-    }\
-    (buf)[i] = '\0';\
-    out_len = i;\
-}
-
-#define RBUF2(buff, out_len, str, num, str2, num2)\
-unsigned char buff[sizeof(str) + sizeof(str2) + 42];\
-int out_len = 0;\
-{\
-    unsigned char* buf = buff;\
-    int i = 0;\
-    for (; GUARDM(sizeof(str),1),i < sizeof(str); ++i)\
-        (buf)[i] = str[i];\
-    if ((buf)[sizeof(str)-1] == 0) i--;\
-    if ((num) < 0) (buf)[i++] = '-';\
-    uint64_t unsigned_num = (uint64_t)( (num) < 0 ? (num) * -1 : (num) );\
-    uint64_t j = 10000000000000000000ULL;\
-    int start = 1;\
-    for (; GUARDM(20,2), unsigned_num > 0 && j > 0; j /= 10)\
-    {\
-        unsigned char digit = ( unsigned_num / j ) % 10;\
-        if (digit == 0 && start)\
-            continue;\
-        start = 0;\
-        (buf)[i++] = '0' + digit;\
-    }\
-    buf += i;\
-    out_len += i;\
-    i = 0;\
-    for (; GUARDM(sizeof(str2),3),i < sizeof(str2); ++i)\
-        (buf)[i] = str2[i];\
-    if ((buf)[sizeof(str2)-1] == 0) i--;\
-    if ((num2) < 0) (buf)[i++] = '-';\
-    unsigned_num = (uint64_t)( (num2) < 0 ? (num2) * -1 : (num2) );\
-    j = 10000000000000000000ULL;\
-    start = 1;\
-    for (; GUARDM(20,4), unsigned_num > 0 && j > 0; j /= 10)\
-    {\
-        unsigned char digit = ( unsigned_num / j ) % 10;\
-        if (digit == 0 && start)\
-            continue;\
-        start = 0;\
-        (buf)[i++] = '0' + digit;\
-    }\
-    (buf)[i] = '\0';\
-    out_len += i;\
-}
-
-#define CLEARBUF(b)\
-{\
-    for (int x = 0; GUARD(sizeof(b)), x < sizeof(b); ++x)\
-        b[x] = 0;\
-}
-
-// returns an in64_t, negative if error, non-negative if valid drops
-#define AMOUNT_TO_DROPS(amount_buffer)\
-     (((amount_buffer)[0] >> 7) ? -2 : (\
-     ((((uint64_t)((amount_buffer)[0])) & 0xb00111111) << 56) +\
-      (((uint64_t)((amount_buffer)[1])) << 48) +\
-      (((uint64_t)((amount_buffer)[2])) << 40) +\
-      (((uint64_t)((amount_buffer)[3])) << 32) +\
-      (((uint64_t)((amount_buffer)[4])) << 24) +\
-      (((uint64_t)((amount_buffer)[5])) << 16) +\
-      (((uint64_t)((amount_buffer)[6])) <<  8) +\
-      (((uint64_t)((amount_buffer)[7])))))
-
-#define SUB_OFFSET(x) ((int32_t)(x >> 32))
-#define SUB_LENGTH(x) ((int32_t)(x & 0xFFFFFFFFULL))
-
-#define BUFFER_EQUAL_20(buf1, buf2)\
-    (\
-        *(((uint64_t*)(buf1)) + 0) == *(((uint64_t*)(buf2)) + 0) &&\
-        *(((uint64_t*)(buf1)) + 1) == *(((uint64_t*)(buf2)) + 1) &&\
-        *(((uint32_t*)(buf1)) + 4) == *(((uint32_t*)(buf2)) + 4))
-
-#define BUFFER_EQUAL_32(buf1, buf2)\
-    (\
-        *(((uint64_t*)(buf1)) + 0) == *(((uint64_t*)(buf2)) + 0) &&\
-        *(((uint64_t*)(buf1)) + 1) == *(((uint64_t*)(buf2)) + 1) &&\
-        *(((uint64_t*)(buf1)) + 2) == *(((uint64_t*)(buf2)) + 2) &&\
-        *(((uint64_t*)(buf1)) + 3) == *(((uint64_t*)(buf2)) + 3))
-
-
-// when using this macro buf1len may be dynamic but buf2len must be static
-// provide n >= 1 to indicate how many times the macro will be hit on the line of code
-// e.g. if it is in a loop that loops 10 times n = 10
-
-#define BUFFER_EQUAL_GUARD(output, buf1, buf1len, buf2, buf2len, n)\
-{\
-    output = ((buf1len) == (buf2len) ? 1 : 0);\
-    for (int x = 0; GUARDM( (buf2len) * (n), 1 ), output && x < (buf2len);\
-         ++x)\
-        output = *(((uint8_t*)(buf1)) + x) == *(((uint8_t*)(buf2)) + x);\
-}
-
-#define BUFFER_SWAP(x,y)\
-{\
-    uint8_t* z = x;\
-    x = y;\
-    y = z;\
-}
-
-#define ACCOUNT_COMPARE(compare_result, buf1, buf2)\
-{\
-    compare_result = 0;\
-    for (int i = 0; GUARD(20), i < 20; ++i)\
-    {\
-        if (buf1[i] > buf2[i])\
-        {\
-            compare_result = 1;\
-            break;\
-        }\
-        else if (buf1[i] < buf2[i])\
-        {\
-            compare_result = -1;\
-            break;\
-        }\
-    }\
-}
-
-#define BUFFER_EQUAL_STR_GUARD(output, buf1, buf1len, str, n)\
-    BUFFER_EQUAL_GUARD(output, buf1, buf1len, str, (sizeof(str)-1), n)
-
-#define BUFFER_EQUAL_STR(output, buf1, buf1len, str)\
-    BUFFER_EQUAL_GUARD(output, buf1, buf1len, str, (sizeof(str)-1), 1)
-
-#define BUFFER_EQUAL(output, buf1, buf2, compare_len)\
-    BUFFER_EQUAL_GUARD(output, buf1, compare_len, buf2, compare_len, 1)
-
-#define UINT16_TO_BUF(buf_raw, i)\
-{\
-    unsigned char* buf = (unsigned char*)buf_raw;\
-    buf[0] = (((uint64_t)i) >> 8) & 0xFFUL;\
-    buf[1] = (((uint64_t)i) >> 0) & 0xFFUL;\
-}
-
-#define UINT16_FROM_BUF(buf)\
-    (((uint64_t)((buf)[0]) <<  8) +\
-     ((uint64_t)((buf)[1]) <<  0))
-
-#define UINT32_TO_BUF(buf_raw, i)\
-{\
-    unsigned char* buf = (unsigned char*)buf_raw;\
-    buf[0] = (((uint64_t)i) >> 24) & 0xFFUL;\
-    buf[1] = (((uint64_t)i) >> 16) & 0xFFUL;\
-    buf[2] = (((uint64_t)i) >>  8) & 0xFFUL;\
-    buf[3] = (((uint64_t)i) >>  0) & 0xFFUL;\
-}
-
-
-#define UINT32_FROM_BUF(buf)\
-    (((uint64_t)((buf)[0]) << 24) +\
-     ((uint64_t)((buf)[1]) << 16) +\
-     ((uint64_t)((buf)[2]) <<  8) +\
-     ((uint64_t)((buf)[3]) <<  0))
-
-#define UINT64_TO_BUF(buf_raw, i)\
-{\
-    unsigned char* buf = (unsigned char*)buf_raw;\
-    buf[0] = (((uint64_t)i) >> 56) & 0xFFUL;\
-    buf[1] = (((uint64_t)i) >> 48) & 0xFFUL;\
-    buf[2] = (((uint64_t)i) >> 40) & 0xFFUL;\
-    buf[3] = (((uint64_t)i) >> 32) & 0xFFUL;\
-    buf[4] = (((uint64_t)i) >> 24) & 0xFFUL;\
-    buf[5] = (((uint64_t)i) >> 16) & 0xFFUL;\
-    buf[6] = (((uint64_t)i) >>  8) & 0xFFUL;\
-    buf[7] = (((uint64_t)i) >>  0) & 0xFFUL;\
-}
-
-
-#define UINT64_FROM_BUF(buf)\
-    (((uint64_t)((buf)[0]) << 56) +\
-     ((uint64_t)((buf)[1]) << 48) +\
-     ((uint64_t)((buf)[2]) << 40) +\
-     ((uint64_t)((buf)[3]) << 32) +\
-     ((uint64_t)((buf)[4]) << 24) +\
-     ((uint64_t)((buf)[5]) << 16) +\
-     ((uint64_t)((buf)[6]) <<  8) +\
-     ((uint64_t)((buf)[7]) <<  0))
-
-
-#define INT64_FROM_BUF(buf)\
-   ((((uint64_t)((buf)[0] & 0x7FU) << 56) +\
-     ((uint64_t)((buf)[1]) << 48) +\
-     ((uint64_t)((buf)[2]) << 40) +\
-     ((uint64_t)((buf)[3]) << 32) +\
-     ((uint64_t)((buf)[4]) << 24) +\
-     ((uint64_t)((buf)[5]) << 16) +\
-     ((uint64_t)((buf)[6]) <<  8) +\
-     ((uint64_t)((buf)[7]) <<  0)) * (buf[0] & 0x80U ? -1 : 1))
-
-#define INT64_TO_BUF(buf_raw, i)\
-{\
-    unsigned char* buf = (unsigned char*)buf_raw;\
-    buf[0] = (((uint64_t)i) >> 56) & 0x7FUL;\
-    buf[1] = (((uint64_t)i) >> 48) & 0xFFUL;\
-    buf[2] = (((uint64_t)i) >> 40) & 0xFFUL;\
-    buf[3] = (((uint64_t)i) >> 32) & 0xFFUL;\
-    buf[4] = (((uint64_t)i) >> 24) & 0xFFUL;\
-    buf[5] = (((uint64_t)i) >> 16) & 0xFFUL;\
-    buf[6] = (((uint64_t)i) >>  8) & 0xFFUL;\
-    buf[7] = (((uint64_t)i) >>  0) & 0xFFUL;\
-    if (i < 0) buf[0] |= 0x80U;\
-}
-
-#define ttPAYMENT 0
-#define ttESCROW_CREATE 1
-#define ttESCROW_FINISH 2
-#define ttACCOUNT_SET 3
-#define ttESCROW_CANCEL 4
-#define ttREGULAR_KEY_SET 5
-#define ttOFFER_CREATE 7
-#define ttOFFER_CANCEL 8
-#define ttTICKET_CREATE 10
-#define ttSIGNER_LIST_SET 12
-#define ttPAYCHAN_CREATE 13
-#define ttPAYCHAN_FUND 14
-#define ttPAYCHAN_CLAIM 15
-#define ttCHECK_CREATE 16
-#define ttCHECK_CASH 17
-#define ttCHECK_CANCEL 18
-#define ttDEPOSIT_PREAUTH 19
-#define ttTRUST_SET 20
-#define ttACCOUNT_DELETE 21
-#define ttHOOK_SET 22
-#define ttNFTOKEN_MINT 25
-#define ttNFTOKEN_BURN 26
-#define ttNFTOKEN_CREATE_OFFER 27
-#define ttNFTOKEN_CANCEL_OFFER 28
-#define ttNFTOKEN_ACCEPT_OFFER 29
-#define ttURITOKEN_MINT 45
-#define ttURITOKEN_BURN 46
-#define ttURITOKEN_BUY 47
-#define ttURITOKEN_CREATE_SELL_OFFER 48
-#define ttURITOKEN_CANCEL_SELL_OFFER 49
-#define ttCLAIM_REWARD 98
-#define ttINVOKE 99
-#define ttAMENDMENT 100
-#define ttFEE 101
-#define ttUNL_MODIFY 102
-#define ttEMIT_FAILURE 103
-#define tfCANONICAL 0x80000000UL
-
-#define atACCOUNT 1U
-#define atOWNER 2U
-#define atDESTINATION 3U
-#define atISSUER 4U
-#define atAUTHORIZE 5U
-#define atUNAUTHORIZE 6U
-#define atTARGET 7U
-#define atREGULARKEY 8U
-#define atPSEUDOCALLBACK 9U
-
-#define amAMOUNT 1U
-#define amBALANCE 2U
-#define amLIMITAMOUNT 3U
-#define amTAKERPAYS 4U
-#define amTAKERGETS 5U
-#define amLOWLIMIT 6U
-#define amHIGHLIMIT 7U
-#define amFEE 8U
-#define amSENDMAX 9U
-#define amDELIVERMIN 10U
-#define amMINIMUMOFFER 16U
-#define amRIPPLEESCROW 17U
-#define amDELIVEREDAMOUNT 18U
-
-/**
- * RH NOTE -- PAY ATTENTION
- *
- * ALL 'ENCODE' MACROS INCREMENT BUF_OUT
- * THIS IS TO MAKE CHAINING EASY
- * BUF_OUT IS A SACRIFICIAL POINTER
- *
- * 'ENCODE' MACROS WITH CONSTANTS HAVE
- * ALIASING TO ASSIST YOU WITH ORDER
- * _TYPECODE_FIELDCODE_ENCODE_MACRO
- * TO PRODUCE A SERIALIZED OBJECT
- * IN CANONICAL FORMAT YOU MUST ORDER
- * FIRST BY TYPE CODE THEN BY FIELD CODE
- *
- * ALL 'PREPARE' MACROS PRESERVE POINTERS
- *
- **/
-
-
-#define ENCODE_TL_SIZE 49
-#define ENCODE_TL(buf_out, tlamt, amount_type)\
-{\
-        uint8_t uat = amount_type; \
-        buf_out[0] = 0x60U +(uat & 0x0FU ); \
-        for (int i = 1; GUARDM(48, 1), i < 49; ++i)\
-            buf_out[i] = tlamt[i-1];\
-        buf_out += ENCODE_TL_SIZE;\
-}
-#define _06_XX_ENCODE_TL(buf_out, drops, amount_type )\
-    ENCODE_TL(buf_out, drops, amount_type );
-#define ENCODE_TL_AMOUNT(buf_out, drops )\
-    ENCODE_TL(buf_out, drops, amAMOUNT );
-#define _06_01_ENCODE_TL_AMOUNT(buf_out, drops )\
-    ENCODE_TL_AMOUNT(buf_out, drops );
-
-
-// Encode drops to serialization format
-// consumes 9 bytes
-#define ENCODE_DROPS_SIZE 9
-#define ENCODE_DROPS(buf_out, drops, amount_type ) \
-    {\
-        uint8_t uat = amount_type; \
-        uint64_t udrops = drops; \
-        buf_out[0] = 0x60U +(uat & 0x0FU ); \
-        buf_out[1] = 0b01000000 + (( udrops >> 56 ) & 0b00111111 ); \
-        buf_out[2] = (udrops >> 48) & 0xFFU; \
-        buf_out[3] = (udrops >> 40) & 0xFFU; \
-        buf_out[4] = (udrops >> 32) & 0xFFU; \
-        buf_out[5] = (udrops >> 24) & 0xFFU; \
-        buf_out[6] = (udrops >> 16) & 0xFFU; \
-        buf_out[7] = (udrops >>  8) & 0xFFU; \
-        buf_out[8] = (udrops >>  0) & 0xFFU; \
-        buf_out += ENCODE_DROPS_SIZE; \
-    }
-
-#define _06_XX_ENCODE_DROPS(buf_out, drops, amount_type )\
-    ENCODE_DROPS(buf_out, drops, amount_type );
-
-#define ENCODE_DROPS_AMOUNT(buf_out, drops )\
-    ENCODE_DROPS(buf_out, drops, amAMOUNT );
-#define _06_01_ENCODE_DROPS_AMOUNT(buf_out, drops )\
-    ENCODE_DROPS_AMOUNT(buf_out, drops );
-
-#define ENCODE_DROPS_FEE(buf_out, drops )\
-    ENCODE_DROPS(buf_out, drops, amFEE );
-#define _06_08_ENCODE_DROPS_FEE(buf_out, drops )\
-    ENCODE_DROPS_FEE(buf_out, drops );
-
-#define ENCODE_TT_SIZE 3
-#define ENCODE_TT(buf_out, tt )\
-    {\
-        uint8_t utt = tt;\
-        buf_out[0] = 0x12U;\
-        buf_out[1] =(utt >> 8 ) & 0xFFU;\
-        buf_out[2] =(utt >> 0 ) & 0xFFU;\
-        buf_out += ENCODE_TT_SIZE; \
-    }
-#define _01_02_ENCODE_TT(buf_out, tt)\
-    ENCODE_TT(buf_out, tt);
-
-
-#define ENCODE_ACCOUNT_SIZE 22
-#define ENCODE_ACCOUNT(buf_out, account_id, account_type)\
-    {\
-        uint8_t uat = account_type;\
-        buf_out[0] = 0x80U + uat;\
-        buf_out[1] = 0x14U;\
-        *(uint64_t*)(buf_out +  2) = *(uint64_t*)(account_id +  0);\
-        *(uint64_t*)(buf_out + 10) = *(uint64_t*)(account_id +  8);\
-        *(uint32_t*)(buf_out + 18) = *(uint32_t*)(account_id + 16);\
-        buf_out += ENCODE_ACCOUNT_SIZE;\
-    }
-#define _08_XX_ENCODE_ACCOUNT(buf_out, account_id, account_type)\
-    ENCODE_ACCOUNT(buf_out, account_id, account_type);
-
-#define ENCODE_ACCOUNT_SRC_SIZE 22
-#define ENCODE_ACCOUNT_SRC(buf_out, account_id)\
-    ENCODE_ACCOUNT(buf_out, account_id, atACCOUNT);
-#define _08_01_ENCODE_ACCOUNT_SRC(buf_out, account_id)\
-    ENCODE_ACCOUNT_SRC(buf_out, account_id);
-
-#define ENCODE_ACCOUNT_DST_SIZE 22
-#define ENCODE_ACCOUNT_DST(buf_out, account_id)\
-    ENCODE_ACCOUNT(buf_out, account_id, atDESTINATION);
-#define _08_03_ENCODE_ACCOUNT_DST(buf_out, account_id)\
-    ENCODE_ACCOUNT_DST(buf_out, account_id);
-
-#define ENCODE_ACCOUNT_OWNER_SIZE 22
-#define ENCODE_ACCOUNT_OWNER(buf_out, account_id) \
-    ENCODE_ACCOUNT(buf_out, account_id, atOWNER);
-#define _08_02_ENCODE_ACCOUNT_OWNER(buf_out, account_id) \
-    ENCODE_ACCOUNT_OWNER(buf_out, account_id);
-
-#define ENCODE_UINT32_COMMON_SIZE 5U
-#define ENCODE_UINT32_COMMON(buf_out, i, field)\
-    {\
-        uint32_t ui = i; \
-        uint8_t uf = field; \
-        buf_out[0] = 0x20U +(uf & 0x0FU); \
-        buf_out[1] =(ui >> 24 ) & 0xFFU; \
-        buf_out[2] =(ui >> 16 ) & 0xFFU; \
-        buf_out[3] =(ui >>  8 ) & 0xFFU; \
-        buf_out[4] =(ui >>  0 ) & 0xFFU; \
-        buf_out += ENCODE_UINT32_COMMON_SIZE; \
-    }
-#define _02_XX_ENCODE_UINT32_COMMON(buf_out, i, field)\
-    ENCODE_UINT32_COMMON(buf_out, i, field)\
-
-#define ENCODE_UINT32_UNCOMMON_SIZE 6U
-#define ENCODE_UINT32_UNCOMMON(buf_out, i, field)\
-    {\
-        uint32_t ui = i; \
-        uint8_t uf = field; \
-        buf_out[0] = 0x20U; \
-        buf_out[1] = uf; \
-        buf_out[2] =(ui >> 24 ) & 0xFFU; \
-        buf_out[3] =(ui >> 16 ) & 0xFFU; \
-        buf_out[4] =(ui >>  8 ) & 0xFFU; \
-        buf_out[5] =(ui >>  0 ) & 0xFFU; \
-        buf_out += ENCODE_UINT32_UNCOMMON_SIZE; \
-    }
-#define _02_XX_ENCODE_UINT32_UNCOMMON(buf_out, i, field)\
-    ENCODE_UINT32_UNCOMMON(buf_out, i, field)\
-
-#define ENCODE_LLS_SIZE 6U
-#define ENCODE_LLS(buf_out, lls )\
-    ENCODE_UINT32_UNCOMMON(buf_out, lls, 0x1B );
-#define _02_27_ENCODE_LLS(buf_out, lls )\
-    ENCODE_LLS(buf_out, lls );
-
-#define ENCODE_FLS_SIZE 6U
-#define ENCODE_FLS(buf_out, fls )\
-    ENCODE_UINT32_UNCOMMON(buf_out, fls, 0x1A );
-#define _02_26_ENCODE_FLS(buf_out, fls )\
-    ENCODE_FLS(buf_out, fls );
-
-#define ENCODE_TAG_SRC_SIZE 5
-#define ENCODE_TAG_SRC(buf_out, tag )\
-    ENCODE_UINT32_COMMON(buf_out, tag, 0x3U );
-#define _02_03_ENCODE_TAG_SRC(buf_out, tag )\
-    ENCODE_TAG_SRC(buf_out, tag );
-
-#define ENCODE_TAG_DST_SIZE 5
-#define ENCODE_TAG_DST(buf_out, tag )\
-    ENCODE_UINT32_COMMON(buf_out, tag, 0xEU );
-#define _02_14_ENCODE_TAG_DST(buf_out, tag )\
-    ENCODE_TAG_DST(buf_out, tag );
-
-#define ENCODE_SEQUENCE_SIZE 5
-#define ENCODE_SEQUENCE(buf_out, sequence )\
-    ENCODE_UINT32_COMMON(buf_out, sequence, 0x4U );
-#define _02_04_ENCODE_SEQUENCE(buf_out, sequence )\
-    ENCODE_SEQUENCE(buf_out, sequence );
-
-#define ENCODE_FLAGS_SIZE 5
-#define ENCODE_FLAGS(buf_out, tag )\
-    ENCODE_UINT32_COMMON(buf_out, tag, 0x2U );
-#define _02_02_ENCODE_FLAGS(buf_out, tag )\
-    ENCODE_FLAGS(buf_out, tag );
-
-#define ENCODE_SIGNING_PUBKEY_SIZE 35
-#define ENCODE_SIGNING_PUBKEY(buf_out, pkey )\
-    {\
-        buf_out[0] = 0x73U;\
-        buf_out[1] = 0x21U;\
-        *(uint64_t*)(buf_out +  2) = *(uint64_t*)(pkey +  0);\
-        *(uint64_t*)(buf_out + 10) = *(uint64_t*)(pkey +  8);\
-        *(uint64_t*)(buf_out + 18) = *(uint64_t*)(pkey + 16);\
-        *(uint64_t*)(buf_out + 26) = *(uint64_t*)(pkey + 24);\
-        buf[34] = pkey[32];\
-        buf_out += ENCODE_SIGNING_PUBKEY_SIZE;\
-    }
-
-#define _07_03_ENCODE_SIGNING_PUBKEY(buf_out, pkey )\
-    ENCODE_SIGNING_PUBKEY(buf_out, pkey );
-
-#define ENCODE_SIGNING_PUBKEY_NULL_SIZE 2
-#define ENCODE_SIGNING_PUBKEY_NULL(buf_out )\
-    {\
-        *buf_out++ = 0x73U;\
-        *buf_out++ = 0x00U;\
-    }
-
-#define _07_03_ENCODE_SIGNING_PUBKEY_NULL(buf_out )\
-    ENCODE_SIGNING_PUBKEY_NULL(buf_out );
-
-
-#define _0E_0E_ENCODE_HOOKOBJ(buf_out, hhash)\
-{\
-        uint8_t* hook0 = (hhash);\
-        *buf_out++ = 0xEEU;   /* hook obj start */ \
-        if (hook0 == 0) /* noop */\
-        {\
-            /* do nothing */ \
-        }\
-        else\
-        {\
-            *buf_out++ = 0x22U; /* flags = override */\
-            *buf_out++ = 0x00U;\
-            *buf_out++ = 0x00U;\
-            *buf_out++ = 0x00U;\
-            *buf_out++ = 0x01U;\
-            if (hook0 == 0xFFFFFFFFUL) /* delete operation */ \
-            {\
-                *buf_out++ = 0x7BU; /* empty createcode */ \
-                *buf_out++ = 0x00U;\
-            }\
-            else\
-            {\
-                *buf_out++ = 0x50U; /* HookHash */\
-                *buf_out++ = 0x1FU;\
-                uint64_t* d = (uint64_t*)buf_out;\
-                uint64_t* s = (uint64_t*)hook0;\
-                *d++ = *s++;\
-                *d++ = *s++;\
-                *d++ = *s++;\
-                *d++ = *s++;\
-                buf_out+=32;\
-            }\
-        }\
-        *buf_out++ = 0xE1U;\
-}
-
-#define PREPARE_HOOKSET(buf_out_master, maxlen, h, sizeout)\
-    {\
-        uint8_t* buf_out = (buf_out_master);                                            \
-        uint8_t acc[20];                                                                \
-        uint32_t cls = (uint32_t)ledger_seq();                                          \
-        hook_account(SBUF(acc));                                                        \
-        _01_02_ENCODE_TT                   (buf_out, ttHOOK_SET                     );  \
-        _02_02_ENCODE_FLAGS                (buf_out, tfCANONICAL                    );  \
-        _02_04_ENCODE_SEQUENCE             (buf_out, 0                              );  \
-        _02_26_ENCODE_FLS                  (buf_out, cls + 1                        );  \
-        _02_27_ENCODE_LLS                  (buf_out, cls + 5                        );  \
-        uint8_t* fee_ptr = buf_out;                                                     \
-        _06_08_ENCODE_DROPS_FEE            (buf_out, 0                              );  \
-        _07_03_ENCODE_SIGNING_PUBKEY_NULL  (buf_out                                 );  \
-        _08_01_ENCODE_ACCOUNT_SRC          (buf_out, acc                            );  \
-        uint32_t remaining_size = (maxlen) - (buf_out - (buf_out_master));              \
-        int64_t edlen = etxn_details((uint32_t)buf_out, remaining_size);                \
-        buf_out += edlen;                                                               \
-        *buf_out++ = 0xFBU;   /* hook array start */                                    \
-        _0E_0E_ENCODE_HOOKOBJ               (buf_out, h[0]);                           \
-        _0E_0E_ENCODE_HOOKOBJ               (buf_out, h[1]);                           \
-        _0E_0E_ENCODE_HOOKOBJ               (buf_out, h[2]);                           \
-        _0E_0E_ENCODE_HOOKOBJ               (buf_out, h[3]);                           \
-        _0E_0E_ENCODE_HOOKOBJ               (buf_out, h[4]);                           \
-        _0E_0E_ENCODE_HOOKOBJ               (buf_out, h[5]);                           \
-        _0E_0E_ENCODE_HOOKOBJ               (buf_out, h[6]);                           \
-        _0E_0E_ENCODE_HOOKOBJ               (buf_out, h[7]);                           \
-        _0E_0E_ENCODE_HOOKOBJ               (buf_out, h[8]);                           \
-        _0E_0E_ENCODE_HOOKOBJ               (buf_out, h[9]);                           \
-        *buf_out++ = 0xF1U;  /* hook array end */                                       \
-        sizeout = (buf_out - (buf_out_master));                                         \
-        int64_t fee = etxn_fee_base(buf_out_master, sizeout);                           \
-        _06_08_ENCODE_DROPS_FEE            (fee_ptr, fee                            );  \
-    }
-
-#ifdef HAS_CALLBACK
-#define PREPARE_PAYMENT_SIMPLE_SIZE 270U
-#else
-#define PREPARE_PAYMENT_SIMPLE_SIZE 248U
-#endif
-
-#define PREPARE_PAYMENT_SIMPLE(buf_out_master, drops_amount_raw, to_address, dest_tag_raw, src_tag_raw)\
-    {\
-        uint8_t* buf_out = buf_out_master;\
-        uint8_t acc[20];\
-        uint64_t drops_amount = (drops_amount_raw);\
-        uint32_t dest_tag = (dest_tag_raw);\
-        uint32_t src_tag = (src_tag_raw);\
-        uint32_t cls = (uint32_t)ledger_seq();\
-        hook_account(SBUF(acc));\
-        _01_02_ENCODE_TT                   (buf_out, ttPAYMENT                      );      /* uint16  | size   3 */ \
-        _02_02_ENCODE_FLAGS                (buf_out, tfCANONICAL                    );      /* uint32  | size   5 */ \
-        _02_03_ENCODE_TAG_SRC              (buf_out, src_tag                        );      /* uint32  | size   5 */ \
-        _02_04_ENCODE_SEQUENCE             (buf_out, 0                              );      /* uint32  | size   5 */ \
-        _02_14_ENCODE_TAG_DST              (buf_out, dest_tag                       );      /* uint32  | size   5 */ \
-        _02_26_ENCODE_FLS                  (buf_out, cls + 1                        );      /* uint32  | size   6 */ \
-        _02_27_ENCODE_LLS                  (buf_out, cls + 5                        );      /* uint32  | size   6 */ \
-        _06_01_ENCODE_DROPS_AMOUNT         (buf_out, drops_amount                   );      /* amount  | size   9 */ \
-        uint8_t* fee_ptr = buf_out;\
-        _06_08_ENCODE_DROPS_FEE            (buf_out, 0                              );      /* amount  | size   9 */ \
-        _07_03_ENCODE_SIGNING_PUBKEY_NULL  (buf_out                                 );      /* pk      | size  35 */ \
-        _08_01_ENCODE_ACCOUNT_SRC          (buf_out, acc                            );      /* account | size  22 */ \
-        _08_03_ENCODE_ACCOUNT_DST          (buf_out, to_address                     );      /* account | size  22 */ \
-        int64_t edlen = etxn_details((uint32_t)buf_out, PREPARE_PAYMENT_SIMPLE_SIZE);       /* emitdet | size 1?? */ \
-        int64_t fee = etxn_fee_base(buf_out_master, PREPARE_PAYMENT_SIMPLE_SIZE);                                    \ 
-        _06_08_ENCODE_DROPS_FEE            (fee_ptr, fee                            );                               \
-    }
-
-#ifdef HAS_CALLBACK
-#define PREPARE_PAYMENT_SIMPLE_TRUSTLINE_SIZE 309
-#else
-#define PREPARE_PAYMENT_SIMPLE_TRUSTLINE_SIZE 287
-#endif
-#define PREPARE_PAYMENT_SIMPLE_TRUSTLINE(buf_out_master, tlamt, to_address, dest_tag_raw, src_tag_raw)\
-    {\
-        uint8_t* buf_out = buf_out_master;\
-        uint8_t acc[20];\
-        uint32_t dest_tag = (dest_tag_raw);\
-        uint32_t src_tag = (src_tag_raw);\
-        uint32_t cls = (uint32_t)ledger_seq();\
-        hook_account(SBUF(acc));\
-        _01_02_ENCODE_TT                   (buf_out, ttPAYMENT                      );      /* uint16  | size   3 */ \
-        _02_02_ENCODE_FLAGS                (buf_out, tfCANONICAL                    );      /* uint32  | size   5 */ \
-        _02_03_ENCODE_TAG_SRC              (buf_out, src_tag                        );      /* uint32  | size   5 */ \
-        _02_04_ENCODE_SEQUENCE             (buf_out, 0                              );      /* uint32  | size   5 */ \
-        _02_14_ENCODE_TAG_DST              (buf_out, dest_tag                       );      /* uint32  | size   5 */ \
-        _02_26_ENCODE_FLS                  (buf_out, cls + 1                        );      /* uint32  | size   6 */ \
-        _02_27_ENCODE_LLS                  (buf_out, cls + 5                        );      /* uint32  | size   6 */ \
-        _06_01_ENCODE_TL_AMOUNT            (buf_out, tlamt                          );      /* amount  | size  48 */ \
-        uint8_t* fee_ptr = buf_out;\
-        _06_08_ENCODE_DROPS_FEE            (buf_out, 0                              );      /* amount  | size   9 */ \
-        _07_03_ENCODE_SIGNING_PUBKEY_NULL  (buf_out                                 );      /* pk      | size  35 */ \
-        _08_01_ENCODE_ACCOUNT_SRC          (buf_out, acc                            );      /* account | size  22 */ \
-        _08_03_ENCODE_ACCOUNT_DST          (buf_out, to_address                     );      /* account | size  22 */ \
-        etxn_details((uint32_t)buf_out, PREPARE_PAYMENT_SIMPLE_TRUSTLINE_SIZE);             /* emitdet | size 1?? */  \
-        int64_t fee = etxn_fee_base(buf_out_master, PREPARE_PAYMENT_SIMPLE_TRUSTLINE_SIZE);                          \ 
-        _06_08_ENCODE_DROPS_FEE            (fee_ptr, fee                            );                               \
-    }
-
-
-
-#endif
-
--- a/hook/genesis/headers/sfcodes.h
+++ b/hook/genesis/headers/sfcodes.h
@@ -1,215 +0,0 @@
-// For documentation please see: https://xrpl-hooks.readme.io/reference/
-// Generated using generate_sfcodes.sh
-#define sfCloseResolution ((16U << 16U) + 1U)
-#define sfMethod ((16U << 16U) + 2U)
-#define sfTransactionResult ((16U << 16U) + 3U)
-#define sfTickSize ((16U << 16U) + 16U)
-#define sfUNLModifyDisabling ((16U << 16U) + 17U)
-#define sfHookResult ((16U << 16U) + 18U)
-#define sfLedgerEntryType ((1U << 16U) + 1U)
-#define sfTransactionType ((1U << 16U) + 2U)
-#define sfSignerWeight ((1U << 16U) + 3U)
-#define sfTransferFee ((1U << 16U) + 4U)
-#define sfVersion ((1U << 16U) + 16U)
-#define sfHookStateChangeCount ((1U << 16U) + 17U)
-#define sfHookEmitCount ((1U << 16U) + 18U)
-#define sfHookExecutionIndex ((1U << 16U) + 19U)
-#define sfHookApiVersion ((1U << 16U) + 20U)
-#define sfNetworkID ((2U << 16U) + 1U)
-#define sfFlags ((2U << 16U) + 2U)
-#define sfSourceTag ((2U << 16U) + 3U)
-#define sfSequence ((2U << 16U) + 4U)
-#define sfPreviousTxnLgrSeq ((2U << 16U) + 5U)
-#define sfLedgerSequence ((2U << 16U) + 6U)
-#define sfCloseTime ((2U << 16U) + 7U)
-#define sfParentCloseTime ((2U << 16U) + 8U)
-#define sfSigningTime ((2U << 16U) + 9U)
-#define sfExpiration ((2U << 16U) + 10U)
-#define sfTransferRate ((2U << 16U) + 11U)
-#define sfWalletSize ((2U << 16U) + 12U)
-#define sfOwnerCount ((2U << 16U) + 13U)
-#define sfDestinationTag ((2U << 16U) + 14U)
-#define sfHighQualityIn ((2U << 16U) + 16U)
-#define sfHighQualityOut ((2U << 16U) + 17U)
-#define sfLowQualityIn ((2U << 16U) + 18U)
-#define sfLowQualityOut ((2U << 16U) + 19U)
-#define sfQualityIn ((2U << 16U) + 20U)
-#define sfQualityOut ((2U << 16U) + 21U)
-#define sfStampEscrow ((2U << 16U) + 22U)
-#define sfBondAmount ((2U << 16U) + 23U)
-#define sfLoadFee ((2U << 16U) + 24U)
-#define sfOfferSequence ((2U << 16U) + 25U)
-#define sfFirstLedgerSequence ((2U << 16U) + 26U)
-#define sfLastLedgerSequence ((2U << 16U) + 27U)
-#define sfTransactionIndex ((2U << 16U) + 28U)
-#define sfOperationLimit ((2U << 16U) + 29U)
-#define sfReferenceFeeUnits ((2U << 16U) + 30U)
-#define sfReserveBase ((2U << 16U) + 31U)
-#define sfReserveIncrement ((2U << 16U) + 32U)
-#define sfSetFlag ((2U << 16U) + 33U)
-#define sfClearFlag ((2U << 16U) + 34U)
-#define sfSignerQuorum ((2U << 16U) + 35U)
-#define sfCancelAfter ((2U << 16U) + 36U)
-#define sfFinishAfter ((2U << 16U) + 37U)
-#define sfSignerListID ((2U << 16U) + 38U)
-#define sfSettleDelay ((2U << 16U) + 39U)
-#define sfTicketCount ((2U << 16U) + 40U)
-#define sfTicketSequence ((2U << 16U) + 41U)
-#define sfNFTokenTaxon ((2U << 16U) + 42U)
-#define sfMintedNFTokens ((2U << 16U) + 43U)
-#define sfBurnedNFTokens ((2U << 16U) + 44U)
-#define sfHookStateCount ((2U << 16U) + 45U)
-#define sfEmitGeneration ((2U << 16U) + 46U)
-#define sfLockCount ((2U << 16U) + 47U)
-#define sfRewardTime ((2U << 16U) + 98U)
-#define sfRewardLgrFirst ((2U << 16U) + 99U)
-#define sfRewardLgrLast ((2U << 16U) + 100U)
-#define sfIndexNext ((3U << 16U) + 1U)
-#define sfIndexPrevious ((3U << 16U) + 2U)
-#define sfBookNode ((3U << 16U) + 3U)
-#define sfOwnerNode ((3U << 16U) + 4U)
-#define sfBaseFee ((3U << 16U) + 5U)
-#define sfExchangeRate ((3U << 16U) + 6U)
-#define sfLowNode ((3U << 16U) + 7U)
-#define sfHighNode ((3U << 16U) + 8U)
-#define sfDestinationNode ((3U << 16U) + 9U)
-#define sfCookie ((3U << 16U) + 10U)
-#define sfServerVersion ((3U << 16U) + 11U)
-#define sfNFTokenOfferNode ((3U << 16U) + 12U)
-#define sfEmitBurden ((3U << 16U) + 13U)
-#define sfHookInstructionCount ((3U << 16U) + 17U)
-#define sfHookReturnCode ((3U << 16U) + 18U)
-#define sfReferenceCount ((3U << 16U) + 19U)
-#define sfRewardAccumulator ((3U << 16U) + 100U)
-#define sfEmailHash ((4U << 16U) + 1U)
-#define sfTakerPaysCurrency ((10U << 16U) + 1U)
-#define sfTakerPaysIssuer ((10U << 16U) + 2U)
-#define sfTakerGetsCurrency ((10U << 16U) + 3U)
-#define sfTakerGetsIssuer ((10U << 16U) + 4U)
-#define sfLedgerHash ((5U << 16U) + 1U)
-#define sfParentHash ((5U << 16U) + 2U)
-#define sfTransactionHash ((5U << 16U) + 3U)
-#define sfAccountHash ((5U << 16U) + 4U)
-#define sfPreviousTxnID ((5U << 16U) + 5U)
-#define sfLedgerIndex ((5U << 16U) + 6U)
-#define sfWalletLocator ((5U << 16U) + 7U)
-#define sfRootIndex ((5U << 16U) + 8U)
-#define sfAccountTxnID ((5U << 16U) + 9U)
-#define sfNFTokenID ((5U << 16U) + 10U)
-#define sfEmitParentTxnID ((5U << 16U) + 11U)
-#define sfEmitNonce ((5U << 16U) + 12U)
-#define sfEmitHookHash ((5U << 16U) + 13U)
-#define sfBookDirectory ((5U << 16U) + 16U)
-#define sfInvoiceID ((5U << 16U) + 17U)
-#define sfNickname ((5U << 16U) + 18U)
-#define sfAmendment ((5U << 16U) + 19U)
-#define sfHookOn ((5U << 16U) + 20U)
-#define sfDigest ((5U << 16U) + 21U)
-#define sfChannel ((5U << 16U) + 22U)
-#define sfConsensusHash ((5U << 16U) + 23U)
-#define sfCheckID ((5U << 16U) + 24U)
-#define sfValidatedHash ((5U << 16U) + 25U)
-#define sfPreviousPageMin ((5U << 16U) + 26U)
-#define sfNextPageMin ((5U << 16U) + 27U)
-#define sfNFTokenBuyOffer ((5U << 16U) + 28U)
-#define sfNFTokenSellOffer ((5U << 16U) + 29U)
-#define sfHookStateKey ((5U << 16U) + 30U)
-#define sfHookHash ((5U << 16U) + 31U)
-#define sfHookNamespace ((5U << 16U) + 32U)
-#define sfHookSetTxnID ((5U << 16U) + 33U)
-#define sfOfferID ((5U << 16U) + 34U)
-#define sfEscrowID ((5U << 16U) + 35U)
-#define sfURITokenID ((5U << 16U) + 36U)
-#define sfAmount ((6U << 16U) + 1U)
-#define sfBalance ((6U << 16U) + 2U)
-#define sfLimitAmount ((6U << 16U) + 3U)
-#define sfTakerPays ((6U << 16U) + 4U)
-#define sfTakerGets ((6U << 16U) + 5U)
-#define sfLowLimit ((6U << 16U) + 6U)
-#define sfHighLimit ((6U << 16U) + 7U)
-#define sfFee ((6U << 16U) + 8U)
-#define sfSendMax ((6U << 16U) + 9U)
-#define sfDeliverMin ((6U << 16U) + 10U)
-#define sfMinimumOffer ((6U << 16U) + 16U)
-#define sfRippleEscrow ((6U << 16U) + 17U)
-#define sfDeliveredAmount ((6U << 16U) + 18U)
-#define sfNFTokenBrokerFee ((6U << 16U) + 19U)
-#define sfHookCallbackFee ((6U << 16U) + 20U)
-#define sfLockedBalance ((6U << 16U) + 21U)
-#define sfPublicKey ((7U << 16U) + 1U)
-#define sfMessageKey ((7U << 16U) + 2U)
-#define sfSigningPubKey ((7U << 16U) + 3U)
-#define sfTxnSignature ((7U << 16U) + 4U)
-#define sfURI ((7U << 16U) + 5U)
-#define sfSignature ((7U << 16U) + 6U)
-#define sfDomain ((7U << 16U) + 7U)
-#define sfFundCode ((7U << 16U) + 8U)
-#define sfRemoveCode ((7U << 16U) + 9U)
-#define sfExpireCode ((7U << 16U) + 10U)
-#define sfCreateCode ((7U << 16U) + 11U)
-#define sfMemoType ((7U << 16U) + 12U)
-#define sfMemoData ((7U << 16U) + 13U)
-#define sfMemoFormat ((7U << 16U) + 14U)
-#define sfFulfillment ((7U << 16U) + 16U)
-#define sfCondition ((7U << 16U) + 17U)
-#define sfMasterSignature ((7U << 16U) + 18U)
-#define sfUNLModifyValidator ((7U << 16U) + 19U)
-#define sfValidatorToDisable ((7U << 16U) + 20U)
-#define sfValidatorToReEnable ((7U << 16U) + 21U)
-#define sfHookStateData ((7U << 16U) + 22U)
-#define sfHookReturnString ((7U << 16U) + 23U)
-#define sfHookParameterName ((7U << 16U) + 24U)
-#define sfHookParameterValue ((7U << 16U) + 25U)
-#define sfBlob ((7U << 16U) + 26U)
-#define sfAccount ((8U << 16U) + 1U)
-#define sfOwner ((8U << 16U) + 2U)
-#define sfDestination ((8U << 16U) + 3U)
-#define sfIssuer ((8U << 16U) + 4U)
-#define sfAuthorize ((8U << 16U) + 5U)
-#define sfUnauthorize ((8U << 16U) + 6U)
-#define sfRegularKey ((8U << 16U) + 8U)
-#define sfNFTokenMinter ((8U << 16U) + 9U)
-#define sfEmitCallback ((8U << 16U) + 10U)
-#define sfHookAccount ((8U << 16U) + 16U)
-#define sfIndexes ((19U << 16U) + 1U)
-#define sfHashes ((19U << 16U) + 2U)
-#define sfAmendments ((19U << 16U) + 3U)
-#define sfNFTokenOffers ((19U << 16U) + 4U)
-#define sfHookNamespaces ((19U << 16U) + 5U)
-#define sfPaths ((18U << 16U) + 1U)
-#define sfTransactionMetaData ((14U << 16U) + 2U)
-#define sfCreatedNode ((14U << 16U) + 3U)
-#define sfDeletedNode ((14U << 16U) + 4U)
-#define sfModifiedNode ((14U << 16U) + 5U)
-#define sfPreviousFields ((14U << 16U) + 6U)
-#define sfFinalFields ((14U << 16U) + 7U)
-#define sfNewFields ((14U << 16U) + 8U)
-#define sfTemplateEntry ((14U << 16U) + 9U)
-#define sfMemo ((14U << 16U) + 10U)
-#define sfSignerEntry ((14U << 16U) + 11U)
-#define sfNFToken ((14U << 16U) + 12U)
-#define sfEmitDetails ((14U << 16U) + 13U)
-#define sfHook ((14U << 16U) + 14U)
-#define sfSigner ((14U << 16U) + 16U)
-#define sfMajority ((14U << 16U) + 18U)
-#define sfDisabledValidator ((14U << 16U) + 19U)
-#define sfEmittedTxn ((14U << 16U) + 20U)
-#define sfHookExecution ((14U << 16U) + 21U)
-#define sfHookDefinition ((14U << 16U) + 22U)
-#define sfHookParameter ((14U << 16U) + 23U)
-#define sfHookGrant ((14U << 16U) + 24U)
-#define sfSigners ((15U << 16U) + 3U)
-#define sfSignerEntries ((15U << 16U) + 4U)
-#define sfTemplate ((15U << 16U) + 5U)
-#define sfNecessary ((15U << 16U) + 6U)
-#define sfSufficient ((15U << 16U) + 7U)
-#define sfAffectedNodes ((15U << 16U) + 8U)
-#define sfMemos ((15U << 16U) + 9U)
-#define sfNFTokens ((15U << 16U) + 10U)
-#define sfHooks ((15U << 16U) + 11U)
-#define sfMajorities ((15U << 16U) + 16U)
-#define sfDisabledValidators ((15U << 16U) + 17U)
-#define sfHookExecutions ((15U << 16U) + 18U)
-#define sfHookParameters ((15U << 16U) + 19U)
-#define sfHookGrants ((15U << 16U) + 20U)
-#define sfActiveValidators ((15U << 16U) + 95U)
--- a/hook/genesis/headers/types.h
+++ b/hook/genesis/headers/types.h
@@ -1,239 +0,0 @@
-#include <stdint.h>
-
-// 8 byte-int = 1 bytes
-#define SFL_CLOSERESOLUTION 1
-#define SFL_METHOD 1
-#define SFL_TRANSACTIONRESULT 1
-#define SFL_TICKSIZE 1
-#define SFL_UNLMODIFYDISABLING 1
-#define SFL_HOOKRESULT 1
-// 16 byte-int = 2 bytes
-#define SFL_LEDGERENTRYTYPE 2
-#define SFL_TRANSACTIONTYPE 2
-#define SFL_SIGNERWEIGHT 2
-#define SFL_TRANSFERFEE 2
-#define SFL_VERSION 2
-#define SFL_HOOKSTATECHANGECOUNT 2
-#define SFL_HOOKEMITCOUNT 2
-#define SFL_HOOKEXECUTIONINDEX 2
-#define SFL_HOOKAPIVERSION 2
-// 32 byte-int = 4 bytes
-#define SFL_NETWORKID 4
-#define SFL_FLAGS 4
-#define SFL_SOURCETAG 4
-#define SFL_SEQUENCE 4
-#define SFL_PREVIOUSTXNLGRSEQ 4
-#define SFL_LEDGERSEQUENCE 4
-#define SFL_CLOSETIME 4
-#define SFL_PARENTCLOSETIME 4
-#define SFL_SIGNINGTIME 4
-#define SFL_EXPIRATION 4
-#define SFL_TRANSFERRATE 4
-#define SFL_WALLETSIZE 4
-#define SFL_OWNERCOUNT 4
-#define SFL_DESTINATIONTAG 4
-#define SFL_HIGHQUALITYIN 4
-#define SFL_HIGHQUALITYOUT 4
-#define SFL_LOWQUALITYIN 4
-#define SFL_LOWQUALITYOUT 4
-#define SFL_QUALITYIN 4
-#define SFL_QUALITYOUT 4
-#define SFL_STAMPESCROW 4
-#define SFL_BONDAMOUNT 4
-#define SFL_LOADFEE 4
-#define SFL_OFFERSEQUENCE 4
-#define SFL_FIRSTLEDGERSEQUENCE 4
-#define SFL_LASTLEDGERSEQUENCE 4
-#define SFL_TRANSACTIONINDEX 4
-#define SFL_OPERATIONLIMIT 4
-#define SFL_REFERENCEFEEUNITS 4
-#define SFL_RESERVEBASE 4
-#define SFL_RESERVEINCREMENT 4
-#define SFL_SETFLAG 4
-#define SFL_CLEARFLAG 4
-#define SFL_SIGNERQUORUM 4
-#define SFL_CANCELAFTER 4
-#define SFL_FINISHAFTER 4
-#define SFL_SIGNERLISTID 4
-#define SFL_SETTLEDELAY 4
-#define SFL_TICKETCOUNT 4
-#define SFL_TICKETSEQUENCE 4
-#define SFL_NFTOKENTAXON 4
-#define SFL_MINTEDNFTOKENS 4
-#define SFL_BURNEDNFTOKENS 4
-#define SFL_HOOKSTATECOUNT 4
-#define SFL_EMITGENERATION 4
-#define SFL_LOCKCOUNT 4
-#define SFL_REWARDTIME 4
-#define SFL_REWARDLGRFIRST 4
-#define SFL_REWARDLGRLAST 4
-#define SFL_FIRSTNFTOKENSEQUENCE 4
-// 64 byte-int = 8 bytes
-#define SFL_INDEX_NEXT 8
-#define SFL_INDEX_PREVIOUS 8
-#define SFL_BOOK_NODE 8
-#define SFL_OWNER_NODE 8
-#define SFL_BASE_FEE 8
-#define SFL_EXCHANGE_RATE 8
-#define SFL_LOW_NODE 8
-#define SFL_HIGH_NODE 8
-#define SFL_DESTINATION_NODE 8
-#define SFL_COOKIE 8
-#define SFL_SERVER_VERSION 8
-#define SFL_EMIT_BURDEN 8
-#define SFL_NFTOKEN_OFFER_NODE 8
-#define SFL_HOOK_INSTRUCTION_COUNT 8
-#define SFL_HOOK_RETURN_CODE 8
-#define SFL_REFERENCE_COUNT 8
-#define SFL_REWARD_ACCUMULATOR 8
-// 128 byte-int = 4 bytes
-#define SFL_EMAIL_HASH 128
-// 160 byte-int = 4 bytes
-#define SFL_TAKER_PAYS_CURRENCY 160
-#define SFL_TAKER_PAYS_ISSUER 160
-#define SFL_TAKER_GETS_CURRENCY 160
-#define SFL_TAKER_GETS_ISSUER 160
-// 256 byte-int = ??? bytes
-#define SFL_LEDGER_HASH 256
-#define SFL_PARENT_HASH 256
-#define SFL_TRANSACTION_HASH 256
-#define SFL_ACCOUNT_HASH 256
-#define SFL_HOOK_ON 256
-#define SFL_PREVIOUS_TXN_ID 256
-#define SFL_LEDGER_INDEX 256
-#define SFL_WALLET_LOCATOR 256
-#define SFL_ROOT_INDEX 256
-#define SFL_ACCOUNT_TXN_ID 256
-#define SFL_NFTOKEN_ID 256
-#define SFL_EMIT_PARENT_TXN_ID 256
-#define SFL_EMIT_NONCE 256
-#define SFL_EMIT_HOOK_HASH 256
-// 256 byte-int = ??? bytes
-#define SFL_BOOK_DIRECTORY 256
-#define SFL_INVOICE_ID 256
-#define SFL_NICKNAME 256
-#define SFL_AMENDMENT 256
-#define SFL_DIGEST 256
-#define SFL_CHANNEL 256
-#define SFL_CONSENSUS_HASH 256
-#define SFL_CHECK_ID 256
-#define SFL_VALIDATED_HASH 256
-#define SFL_PREVIOUS_PAGE_MIN 256
-#define SFL_NEXT_PAGE_MIN 256
-#define SFL_NFTOKEN_BUY_OFFER 256
-#define SFL_NFTOKEN_SELL_OFFER 256
-#define SFL_HOOK_STATE_KEY 256
-#define SFL_HOOK_HASH 256
-#define SFL_HOOK_NAMESPACE 256
-#define SFL_HOOK_SET_TXN_ID 256
-#define SFL_OFFER_ID 256
-#define SFL_ESCROW_ID 256
-#define SFL_URITOKEN_ID 256
-// 20 bytes
-#define SFL_AMOUNT 20
-#define SFL_BALANCE 20
-#define SFL_LIMIT_AMOUNT 20
-#define SFL_TAKER_PAYS 20
-#define SFL_TAKER_GETS 20
-#define SFL_LOW_LIMIT 20
-#define SFL_HIGH_LIMIT 20
-#define SFL_FEE 20
-#define SFL_SEND_MAX 20
-#define SFL_DELIVER_MIN 20
-#define SFL_LOCKED_BALANCE 20
-// Unimplemented
-#define SFL_AMOUNT_MINIMUM_OFFER 8
-#define SFL_AMOUNT_RIPPLE_ESCROW 8
-#define SFL_AMOUNT_DELIVERED_AMOUNT 8
-#define SFL_AMOUNT_NFTOKEN_BROKER_FEE 8
-#define SFL_AMOUNT_HOOK_CALLBACK_FEE 8
-#define SFL_AMOUNT_BASE_FEE_DROPS 8
-#define SFL_AMOUNT_RESERVE_BASE_DROPS 8
-#define SFL_AMOUNT_RESERVE_INCREMENT_DROPS 8
-// Unimplemented
-#define SFL_VL_PUBLIC_KEY 64
-#define SFL_VL_MESSAGE_KEY 64
-#define SFL_VL_SIGNING_PUB_KEY 64
-// Unimplemented
-#define SFL_VL_TXN_SIGNATURE 96
-// Unimplemented
-#define SFL_VL_URI 256
-// Unimplemented
-#define SFL_VL_SIGNATURE 96
-// Unimplemented
-#define SFL_VL_DOMAIN 256
-#define SFL_VL_FUND_CODE 256
-#define SFL_VL_REMOVE_CODE 256
-#define SFL_VL_EXPIRE_CODE 256
-#define SFL_VL_CREATE_CODE 256
-#define SFL_VL_MEMO_TYPE 256
-#define SFL_VL_MEMO_DATA 256
-#define SFL_VL_MEMO_FORMAT 256
-#define SFL_VL_FULFILLMENT 256
-#define SFL_VL_CONDITION 256
-// Unimplemented
-#define SFL_VL_MASTER_SIGNATURE 96
-// Unimplemented
-#define SFL_VL_UNL_MODIFY_VALIDATOR 256
-#define SFL_VL_VALIDATOR_TO_DISABLE 256
-#define SFL_VL_VALIDATOR_TO_RE_ENABLE 256
-#define SFL_VL_HOOK_STATE_DATA 256
-#define SFL_VL_HOOK_RETURN_STRING 256
-#define SFL_VL_HOOK_PARAMETER_NAME 256
-#define SFL_VL_HOOK_PARAMETER_VALUE 256
-#define SFL_VL_BLOB 256
-// 20 bytes
-#define SFL_ACCOUNT 20
-#define SFL_OWNER 20
-#define SFL_DESTINATION 20
-#define SFL_ISSUER 20
-#define SFL_AUTHORIZE 20
-#define SFL_UNAUTHORIZE 20
-#define SFL_REGULAR_KEY 20
-#define SFL_NFTOKEN_MINTER 20
-#define SFL_EMIT_CALLBACK 20
-#define SFL_HOOK_ACCOUNT 20
-#define SFL_NFTOKEN_MINTER 20
-// Unimplemented
-#define SFL_PATHS 1
-// Unimplemented
-#define SFL_VECTOR256_INDEXES 32
-#define SFL_VECTOR256_HASHES 32
-#define SFL_VECTOR256_AMENDMENTS 32
-#define SFL_VECTOR256_NFTOKEN_OFFERS 32
-#define SFL_VECTOR256_HOOK_NAMESPACES 32
-// Unimplemented
-#define SFL_TRANSACTION_META_DATA 1
-#define SFL_CREATED_NODE 1
-#define SFL_DELETED_NODE 1
-#define SFL_MODIFIED_NODE 1
-#define SFL_PREVIOUS_FIELDS 1
-#define SFL_FINAL_FIELDS 1
-#define SFL_NEW_FIELDS 1
-#define SFL_TEMPLATE_ENTRY 1
-#define SFL_MEMO 1
-#define SFL_SIGNER_ENTRY 1
-#define SFL_NFTOKEN 1
-#define SFL_EMIT_DETAILS 1
-#define SFL_HOOK 1
-#define SFL_SIGNER 1
-#define SFL_MAJORITY 1
-#define SFL_DISABLED_VALIDATOR 1
-#define SFL_EMITTED_TXN 1
-#define SFL_HOOK_EXECUTION 1
-#define SFL_HOOK_DEFINITION 1
-#define SFL_HOOK_PARAMETER 1
-#define SFL_HOOK_GRANT 1
-#define SFL_SIGNERS 1
-#define SFL_SIGNER_ENTRIES 1
-#define SFL_TEMPLATE 1
-#define SFL_NECESSARY 1
-#define SFL_SUFFICIENT 1
-#define SFL_AFFECTED_NODES 1
-#define SFL_MEMOS 1
-#define SFL_NFTOKENS 1
-#define SFL_HOOKS 1
-#define SFL_MAJORITIES 1
-#define SFL_DISABLED_VALIDATORS 1
-#define SFL_HOOK_EXECUTIONS 1
-#define SFL_HOOK_EXECUTION 1
--- a/hook/genesis/makefile
+++ b/hook/genesis/makefile
@@ -1,9 +1,9 @@
 all: reward govern mint
 accept:
-	wasmcc accept.c -o accept.wasm -Oz -Wl,--allow-undefined  -I./headers
+	wasmcc accept.c -o accept.wasm -Oz -Wl,--allow-undefined  -I../
 	hook-cleaner accept.wasm
 reward:
-	wasmcc reward.c -o reward.wasm -Oz -Wl,--allow-undefined  -I./headers
+	wasmcc reward.c -o reward.wasm -Oz -Wl,--allow-undefined  -I../
 	wasm-opt reward.wasm -o reward.wasm \
 		--shrink-level=100000000 \
 		--coalesce-locals-learning \
@@ -58,7 +58,7 @@ reward:
 	hook-cleaner reward.wasm
 	guard_checker reward.wasm
 govern:
-	wasmcc govern.c -o govern.wasm -Oz -Wl,--allow-undefined  -I./headers
+	wasmcc govern.c -o govern.wasm -Oz -Wl,--allow-undefined  -I../
 	wasm-opt govern.wasm -o govern.wasm \
 		--shrink-level=100000000 \
 		--coalesce-locals-learning \
@@ -113,7 +113,7 @@ govern:
 	hook-cleaner govern.wasm
 	guard_checker govern.wasm
 mint:
-	wasmcc mint.c -o mint.wasm -Oz -Wl,--allow-undefined  -I./headers
+	wasmcc mint.c -o mint.wasm -Oz -Wl,--allow-undefined  -I../
 	wasm-opt mint.wasm -o mint.wasm \
 		--shrink-level=100000000 \
 		--coalesce-locals-learning \
@@ -142,5 +142,5 @@ mint:
 	hook-cleaner mint.wasm
 	guard_checker mint.wasm
 nftoken:
-	wasmcc nftoken.c -o nftoken.wasm -Oz -Wl,--allow-undefined  -I./headers
+	wasmcc nftoken.c -o nftoken.wasm -Oz -Wl,--allow-undefined  -I../
 	hook-cleaner nftoken.wasm
--- a/include/xrpl/hook/Guard.h
+++ b/include/xrpl/hook/Guard.h
@@ -5,6 +5,7 @@
 #include <memory>
 #include <optional>
 #include <ostream>
+#include <set>
 #include <stack>
 #include <string>
 #include <string_view>
@@ -282,7 +283,8 @@ check_guard(
     * might have unforeseen consequences, without also rolling back further
     * changes that are fine.
     */
-    uint64_t rulesVersion = 0
+    uint64_t rulesVersion = 0,
+    std::set<int>* out_callees = nullptr

 )
 {
@@ -492,17 +494,27 @@ check_guard(
        {
            REQUIRE(1);
            uint64_t callee_idx = LEB();
-            // disallow calling of user defined functions inside a hook
+
+            // record user-defined function calls if tracking is enabled
            if (callee_idx > last_import_idx)
            {
-                GUARDLOG(hook::log::CALL_ILLEGAL)
-                    << "GuardCheck "
-                    << "Hook calls a function outside of the whitelisted "
-                       "imports "
-                    << "codesec: " << codesec << " hook byte offset: " << i
-                    << "\n";
+                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";

-                return {};
+                    return {};
+                }
            }

            // enforce guard call limit
@@ -838,6 +850,42 @@ validateGuards(
     */
    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
@@ -1170,6 +1218,12 @@ 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;
            }
        }

@@ -1211,9 +1265,6 @@ 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
@@ -1247,6 +1298,7 @@ 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())
                {
@@ -1278,7 +1330,7 @@ validateGuards(
                        }
                    }
                }
-                else if (j == hook_type_idx)
+                else if (j == hook_type_idx)  // hook() or cbak() function type
                {
                    // pass
                }
@@ -1291,7 +1343,8 @@ validateGuards(
                        << "Codesec: " << section_type << " "
                        << "Local: " << j << " "
                        << "Offset: " << i << "\n";
-                    return {};
+                    // return {};
+                    helper_function = true;
                }

                int param_count = parseLeb128(wasm, i, &i);
@@ -1308,12 +1361,19 @@ 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";
+                        << " has the wrong number of parameters.\n"
+                        << "param_count: " << param_count << " "
+                        << "first_signature: "
+                        << (*first_signature).get().size() - 1 << "\n";
                    return {};
                }

@@ -1360,6 +1420,10 @@ validateGuards(
                            return {};
                        }
                    }
+                    else if (helper_function)
+                    {
+                        // pass
+                    }
                    else if ((*first_signature).get()[k + 1] != param_type)
                    {
                        GUARDLOG(hook::log::FUNC_PARAM_INVALID)
@@ -1436,6 +1500,10 @@ validateGuards(
                            return {};
                        }
                    }
+                    else if (helper_function)
+                    {
+                        // pass
+                    }
                    else if ((*first_signature).get()[0] != result_type)
                    {
                        GUARDLOG(hook::log::FUNC_RETURN_INVALID)
@@ -1487,6 +1555,17 @@ 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,
@@ -1496,33 +1575,188 @@ validateGuards(
                    last_import_number,
                    guardLog,
                    guardLogAccStr,
-                    rulesVersion);
+                    rulesVersion,
+                    out_callees_ptr);

                if (!valid)
                    return {};

-                if (hook_func_idx && *hook_func_idx == j)
-                    maxInstrCountHook = *valid;
-                else if (cbak_func_idx && *cbak_func_idx == j)
-                    maxInstrCountCbak = *valid;
-                else
+                // Step 5: Store local WCE and build bidirectional call
+                // relationships
+                if (call_graph.find(actual_func_idx) != call_graph.end())
                {
-                    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);
+                    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);
+                        }
+                    }
                }
+
+                // Note: We will calculate total WCE later after processing all
+                // functions
                i = code_end;
            }
        }
        i = next_section;
    }

-    // execution to here means guards are installed correctly
+    // 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;
+        }

-    return std::pair<uint64_t, uint64_t>{maxInstrCountHook, maxInstrCountCbak};
+        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};
 }
--- a/include/xrpl/hook/xahau.h
+++ b/include/xrpl/hook/xahau.h
--- a/src/test/app/SetHook_test.cpp
+++ b/src/test/app/SetHook_test.cpp
@@ -2971,6 +2971,809 @@ public:
        }
    }

+    void
+    testHelperFunctions(FeatureBitset features)
+    {
+        testcase("Test helper functions and recursion detection");
+        using namespace jtx;
+        Env env{*this, features};
+
+        auto const alice = Account{"alice"};
+        auto const bob = Account{"bob"};
+        env.fund(XRP(10000), alice, bob);
+        env.close();
+
+        // Test 1: Valid helper function without loops - should pass
+        {
+            /*
+            #include <stdint.h>
+            extern int32_t _g(uint32_t id, uint32_t maxiter);
+            extern int64_t accept(uint32_t read_ptr, uint32_t read_len, int64_t
+                                  error_code);
+            extern int64_t hook_pos(void);
+
+            int64_t helper(int64_t n) { return n + hook_pos(); }
+
+            int64_t cbak(uint32_t reserved) {
+                _g(1, 1);
+                int64_t result = helper(34);
+                return accept(0, 0, result);
+            }
+
+            int64_t hook(uint32_t reserved) {
+                _g(1, 1);
+                int64_t result = helper(5);
+                return accept(0, 0, result);
+            }
+            */
+            TestHook hook_wasm = wasm[R"[test.hook](
+                (module
+                    (type (;0;) (func (param i32) (result i64)))
+                    (type (;1;) (func (result i64)))
+                    (type (;2;) (func (param i32 i32) (result i32)))
+                    (type (;3;) (func (param i32 i32 i64) (result i64)))
+                    (type (;4;) (func (param i64) (result i64)))
+                    (import "env" "hook_pos" (func (;0;) (type 1)))
+                    (import "env" "_g" (func (;1;) (type 2)))
+                    (import "env" "accept" (func (;2;) (type 3)))
+                    (func (;3;) (type 4) (param i64) (result i64)
+                        call 0
+                        local.get 0
+                        i64.add)
+                    (func (;4;) (type 0) (param i32) (result i64)
+                        i32.const 1
+                        i32.const 1
+                        call 1
+                        drop
+                        i32.const 0
+                        i32.const 0
+                        i64.const 34
+                        call 3
+                        call 2)
+                    (func (;5;) (type 0) (param i32) (result i64)
+                        i32.const 1
+                        i32.const 1
+                        call 1
+                        drop
+                        i32.const 0
+                        i32.const 0
+                        i64.const 5
+                        call 3
+                        call 2)
+                    (memory (;0;) 2)
+                    (export "memory" (memory 0))
+                    (export "cbak" (func 4))
+                    (export "hook" (func 5)))
+            )[test.hook]"];
+            HASH_WASM(hook);
+
+            env(ripple::test::jtx::hook(
+                    alice, {{hso(hook_wasm, overrideFlag)}}, 0),
+                M("Valid helper function without loops"),
+                HSFEE,
+                ter(tesSUCCESS));
+            env.close();
+            EXPECT_HOOK_FEE(hook, 14);
+
+            env(pay(bob, alice, XRP(1)), M("Test helper 1"), fee(XRP(1)));
+            env.close();
+        }
+
+        // Test 2: Helper function with guarded loop - should pass
+        {
+            /*
+            #include <stdint.h>
+            extern int32_t _g(uint32_t id, uint32_t maxiter);
+            extern int64_t accept(uint32_t read_ptr, uint32_t read_len, int64_t
+            error_code); extern int64_t hook_pos(void);
+
+            int64_t helper(int64_t n) {
+                int64_t sum = 0;
+                for (int i = 0; i < 3; ++i) {
+                    _g(2, 4);
+                    sum += i * n;
+                }
+                return sum;
+            }
+
+            int64_t cbak(uint32_t reserved) {
+                _g(1, 1);
+                int64_t result = helper(2);
+                return accept(0, 0, result);
+            }
+
+            int64_t hook(uint32_t reserved) {
+                _g(1, 1);
+                int64_t result = helper(3);
+                return accept(0, 0, result);
+            }
+            */
+            TestHook hook_wasm = wasm[R"[test.hook](
+                (module
+                    (type (;0;) (func (param i32) (result i64)))
+                    (type (;1;) (func (param i32 i32) (result i32)))
+                    (type (;2;) (func (param i32 i32 i64) (result i64)))
+                    (type (;3;) (func (param i64) (result i64)))
+                    (import "env" "_g" (func (;0;) (type 1)))
+                    (import "env" "accept" (func (;1;) (type 2)))
+                    (func (;2;) (type 0) (param i32) (result i64)
+                        i32.const 1
+                        i32.const 1
+                        call 0
+                        drop
+                        i32.const 0
+                        i32.const 0
+                        i64.const 3
+                        call 3
+                        call 1)
+                    (func (;3;) (type 3) (param i64) (result i64)
+                        i32.const 2
+                        i32.const 4
+                        call 0
+                        drop
+                        i32.const 2
+                        i32.const 4
+                        call 0
+                        drop
+                        i32.const 2
+                        i32.const 4
+                        call 0
+                        drop
+                        local.get 0
+                        i64.const 3
+                        i64.mul)
+                    (func (;4;) (type 0) (param i32) (result i64)
+                        i32.const 1
+                        i32.const 1
+                        call 0
+                        drop
+                        i32.const 0
+                        i32.const 0
+                        i64.const 2
+                        call 3
+                        call 1)
+                    (memory (;0;) 2)
+                    (export "memory" (memory 0))
+                    (export "hook" (func 2))
+                    (export "cbak" (func 4)))
+            )[test.hook]"];
+            HASH_WASM(hook);
+
+            env(ripple::test::jtx::hook(
+                    alice, {{hso(hook_wasm, overrideFlag)}}, 0),
+                M("Helper function with guarded loop"),
+                HSFEE,
+                ter(tesSUCCESS));
+            env.close();
+            EXPECT_HOOK_FEE(hook, 26);
+
+            env(pay(bob, alice, XRP(1)), M("Test helper 2"), fee(XRP(1)));
+            env.close();
+        }
+
+        // Test 3: Direct recursion - should fail
+        {
+            /*
+            #include <stdint.h>
+            extern int32_t _g(uint32_t id, uint32_t maxiter);
+            extern int64_t accept(uint32_t read_ptr, uint32_t read_len, int64_t
+                                  error_code);
+            extern int64_t hook_pos(void);
+
+            int64_t recursive_func(int64_t n) {
+              if (n <= 0)
+                return 0;
+              return n + recursive_func(n - hook_pos());
+            }
+            int64_t cbak(uint32_t reserved) {
+              _g(1, 1);
+              int64_t result = recursive_func(5);
+              return accept(0, 0, result);
+            }
+
+            int64_t hook(uint32_t reserved) {
+              _g(1, 1);
+              int64_t result = recursive_func(10);
+              return accept(0, 0, result);
+            }
+
+            */
+            TestHook hook = wasm[R"[test.hook](
+            (module
+                (type (;0;) (func (param i32) (result i64)))
+                (type (;1;) (func (param i32 i32) (result i32)))
+                (type (;2;) (func (param i32 i32 i64) (result i64)))
+                (type (;3;) (func (result i64)))
+                (type (;4;) (func (param i64) (result i64)))
+                (import "env" "_g" (func $g (type 1)))
+                (import "env" "accept" (func $accept (type 2)))
+                (import "env" "hook_pos" (func $hook_pos (type 3)))
+                (func $recursive_func (type 4) (param $n i64) (result i64)
+                    (if (result i64)
+                    (i64.le_s (local.get $n) (i64.const 0))
+                    (then
+                        (i64.const 0)
+                    )
+                    (else
+                        (i64.add
+                        (local.get $n)
+                        (call $recursive_func
+                            (i64.sub (local.get $n) (call $hook_pos))
+                        )
+                        )
+                    )
+                    )
+                )
+                (func (;3;) (type 0) (param i32) (result i64) ;; cbak
+                    i32.const 1
+                    i32.const 1
+                    call $g
+                    drop
+                    i32.const 0
+                    i32.const 0
+                    i64.const 5
+                    call $recursive_func
+                    call $accept
+                )
+                (func (;5;) (type 0) (param i32) (result i64) ;; hook
+                    i32.const 1
+                    i32.const 1
+                    call $g
+                    drop
+                    i32.const 0
+                    i32.const 0
+                    i64.const 10
+                    call $recursive_func
+                    call $accept
+                )
+                (memory (;0;) 2)
+                (export "memory" (memory 0))
+                (export "cbak" (func 3))
+                (export "hook" (func 5)))
+            )[test.hook]"];
+
+            env(ripple::test::jtx::hook(alice, {{hso(hook)}}, 0),
+                M("Direct recursion should fail"),
+                HSFEE,
+                ter(temMALFORMED));
+            env.close();
+        }
+
+        // Test 4: Indirect recursion (A -> B -> A) - should fail
+        {
+            /*
+            #include <stdint.h>
+            extern int32_t _g(uint32_t id, uint32_t maxiter);
+            extern int64_t accept(uint32_t read_ptr, uint32_t read_len, int64_t
+            error_code);
+
+            int64_t func_b(int64_t n);
+
+            int64_t func_a(int64_t n) {
+              if (n <= 0)
+                return 0;
+              return n + func_b(n - 1);
+            }
+
+            int64_t func_b(int64_t n) {
+              if (n <= 0)
+                return 0;
+              return n + func_a(n - 1);
+            }
+
+            int64_t cbak(uint32_t reserved) {
+              _g(1, 1);
+              int64_t result = func_a(5);
+              return accept(0, 0, result);
+            }
+
+            int64_t hook(uint32_t reserved) {
+              _g(1, 1);
+              int64_t result = func_a(10);
+              return accept(0, 0, result);
+            }
+
+            */
+            TestHook hook = wasm[R"[test.hook](
+            (module
+                (import "env" "_g" (func $_g (param i32 i32) (result i32)))
+                (import "env" "accept" (func $accept (param i32 i32 i64) (result i64)))
+                (type $func_type (func (param i64) (result i64)))
+                (func $func_b (param $n i64) (result i64)
+                    (if (result i64)
+                    (i64.le_s (local.get $n) (i64.const 0))
+                    (then
+                        (i64.const 0)
+                    )
+                    (else
+                        (i64.add
+                        (local.get $n)
+                        (call $func_a
+                            (i64.sub (local.get $n) (i64.const 1))
+                        )
+                        )
+                    )
+                    )
+                )
+                (func $func_a (param $n i64) (result i64)
+                    (if (result i64)
+                    (i64.le_s (local.get $n) (i64.const 0))
+                    (then
+                        (i64.const 0)
+                    )
+                    (else
+                        (i64.add
+                        (local.get $n)
+                        (call $func_b
+                            (i64.sub (local.get $n) (i64.const 1))
+                        )
+                        )
+                    )
+                    )
+                )
+                (func $cbak (param $reserved i32) (result i64)
+                    (local $result i64)
+                    (drop (call $_g (i32.const 1) (i32.const 1)))
+                    (local.set $result (call $func_a (i64.const 5)))
+                    (call $accept (i32.const 0) (i32.const 0) (local.get $result))
+                )
+                (func $hook (param $reserved i32) (result i64)
+                    (local $result i64)
+                    (drop (call $_g (i32.const 1) (i32.const 1)))
+                    (local.set $result (call $func_a (i64.const 10)))
+                    (call $accept (i32.const 0) (i32.const 0) (local.get $result))
+                )
+                (export "cbak" (func $cbak))
+                (export "hook" (func $hook)))
+            )[test.hook]"];
+
+            env(ripple::test::jtx::hook(alice, {{hso(hook)}}, 0),
+                M("Indirect recursion should fail"),
+                HSFEE,
+                ter(temMALFORMED));
+            env.close();
+        }
+
+        // Test 5: Deep call chain (A -> B -> C -> D) - should pass if WCE is OK
+        {
+            /*
+            #include <stdint.h>
+            extern int32_t _g(uint32_t id, uint32_t maxiter);
+            extern int64_t accept(uint32_t read_ptr, uint32_t read_len, int64_t
+                                  error_code);
+            extern int64_t hook_pos(void);
+
+            int64_t helper(int64_t n) { return n + hook_pos(); }
+
+            int64_t cbak(uint32_t reserved) {
+                _g(1, 1);
+                int64_t result = helper(34);
+                return accept(0, 0, result);
+            }
+
+            int64_t hook(uint32_t reserved) {
+                _g(1, 1);
+                int64_t result = helper(5);
+                return accept(0, 0, result);
+            }
+            */
+            TestHook hook_wasm = wasm[R"[test.hook](
+                (module
+                    (type (;0;) (func (param i32) (result i64)))
+                    (type (;1;) (func (result i64)))
+                    (type (;2;) (func (param i32 i32) (result i32)))
+                    (type (;3;) (func (param i32 i32 i64) (result i64)))
+                    (type (;4;) (func (param i64) (result i64)))
+                    (import "env" "hook_pos" (func (;0;) (type 1)))
+                    (import "env" "_g" (func (;1;) (type 2)))
+                    (import "env" "accept" (func (;2;) (type 3)))
+                    (func (;3;) (type 4) (param i64) (result i64)
+                        call 0
+                        local.get 0
+                        i64.add)
+                    (func (;4;) (type 0) (param i32) (result i64)
+                        i32.const 1
+                        i32.const 1
+                        call 1
+                        drop
+                        i32.const 0
+                        i32.const 0
+                        i64.const 34
+                        call 3
+                        call 2)
+                    (func (;5;) (type 0) (param i32) (result i64)
+                        i32.const 1
+                        i32.const 1
+                        call 1
+                        drop
+                        i32.const 0
+                        i32.const 0
+                        i64.const 5
+                        call 3
+                        call 2)
+                    (memory (;0;) 2)
+                    (export "memory" (memory 0))
+                    (export "cbak" (func 4))
+                    (export "hook" (func 5)))
+            )[test.hook]"];
+            HASH_WASM(hook);
+
+            env(ripple::test::jtx::hook(
+                    alice, {{hso(hook_wasm, overrideFlag)}}, 0),
+                M("Deep call chain without recursion"),
+                HSFEE,
+                ter(tesSUCCESS));
+            env.close();
+            EXPECT_HOOK_FEE(hook, 14);
+
+            env(pay(bob, alice, XRP(1)), M("Test helper 5"), fee(XRP(1)));
+            env.close();
+        }
+
+        // Test 6: Helper called multiple times - WCE should accumulate
+        {
+            /*
+            #include <stdint.h>
+            extern int32_t _g(uint32_t id, uint32_t maxiter);
+            extern int64_t accept(uint32_t read_ptr, uint32_t read_len, int64_t
+            error_code);
+
+            int64_t expensive_helper() {
+              int64_t sum = 0;
+              for (int i = 0; i < 100; ++i) {
+                _g(2, 301);
+                sum += i;
+              }
+              return sum;
+            }
+
+            int64_t hook(uint32_t reserved) {
+              _g(1, 1);
+              int64_t result = 0;
+              result += expensive_helper();
+              result += expensive_helper();
+              result += expensive_helper();
+              return accept(0, 0, result);
+            }
+            */
+
+            TestHook hook_wasm = wasm[R"[test.hook](
+                (module
+                    (type (;0;) (func (param i32 i32) (result i32)))
+                    (type (;1;) (func (param i32 i32 i64) (result i64)))
+                    (type (;2;) (func (result i64)))
+                    (type (;3;) (func (param i32) (result i64)))
+                    (import "env" "_g" (func (;0;) (type 0)))
+                    (import "env" "accept" (func (;1;) (type 1)))
+                    (func (;2;) (type 2) (result i64)
+                        (local i64)
+                        i64.const 100
+                        local.set 0
+                        loop  ;; label = @1
+                        i32.const 2
+                        i32.const 301
+                        call 0
+                        drop
+                        local.get 0
+                        i64.const 1
+                        i64.sub
+                        local.tee 0
+                        i64.eqz
+                        i32.eqz
+                        br_if 0 (;@1;)
+                        end
+                        i64.const 4950)
+                    (func (;3;) (type 3) (param i32) (result i64)
+                        i32.const 1
+                        i32.const 1
+                        call 0
+                        drop
+                        i32.const 0
+                        i32.const 0
+                        call 2
+                        call 2
+                        i64.add
+                        call 2
+                        i64.add
+                        call 1)
+                    (memory (;0;) 2)
+                    (export "memory" (memory 0))
+                    (export "hook" (func 3)))
+            )[test.hook]"];
+            HASH_WASM(hook);
+
+            env(ripple::test::jtx::hook(
+                    alice, {{hso(hook_wasm, overrideFlag)}}, 0),
+                M("Helper called multiple times"),
+                HSFEE,
+                ter(tesSUCCESS));
+            env.close();
+            EXPECT_HOOK_FEE(hook, 2727);
+
+            env(pay(bob, alice, XRP(1)), M("Test helper 6"), fee(XRP(1)));
+            env.close();
+        }
+
+        // Test 7: WCE overflow through many helpers - should fail
+        {
+            /*
+            #include <stdint.h>
+            extern int32_t _g(uint32_t id, uint32_t maxiter);
+            extern int64_t accept(uint32_t read_ptr, uint32_t read_len, int64_t
+            error_code);
+
+            int64_t large_helper(int64_t n) {
+              int64_t sum = n;
+              for (int i = 0; i < 10000; ++i) {
+                _g(2, 10001);
+                sum += i;
+              }
+              return sum;
+            }
+
+            int64_t cbak(uint32_t reserved) {
+              _g(1, 1);
+              int64_t result = 10;
+              for (int i = 0; i < 10; ++i) {
+                _g(3, 11);
+                result += large_helper(10);
+              }
+              return accept(0, 0, result);
+            }
+
+            int64_t hook(uint32_t reserved) {
+              _g(1, 1);
+              int64_t result = 0;
+              for (int i = 0; i < 10; ++i) {
+                _g(3, 11);
+                result += large_helper(0);
+              }
+              return accept(0, 0, result);
+            }
+
+            */
+            TestHook hook = wasm[R"[test.hook](
+                (module
+                    (type (;0;) (func (param i32) (result i64)))
+                    (type (;1;) (func (param i32 i32) (result i32)))
+                    (type (;2;) (func (param i32 i32 i64) (result i64)))
+                    (type (;3;) (func (param i64) (result i64)))
+                    (import "env" "_g" (func (;0;) (type 1)))
+                    (import "env" "accept" (func (;1;) (type 2)))
+                    (func (;2;) (type 0) (param i32) (result i64)
+                        (local i64)
+                        i32.const 1
+                        i32.const 1
+                        call 0
+                        drop
+                        i32.const 10
+                        local.set 0
+                        i64.const 10
+                        local.set 1
+                        loop  ;; label = @1
+                        i32.const 3
+                        i32.const 11
+                        call 0
+                        drop
+                        i64.const 10
+                        call 3
+                        local.get 1
+                        i64.add
+                        local.set 1
+                        local.get 0
+                        i32.const 1
+                        i32.sub
+                        local.tee 0
+                        br_if 0 (;@1;)
+                        end
+                        i32.const 0
+                        i32.const 0
+                        local.get 1
+                        call 1)
+                    (func (;3;) (type 3) (param i64) (result i64)
+                        (local i64)
+                        i64.const 10000
+                        local.set 1
+                        loop  ;; label = @1
+                        i32.const 2
+                        i32.const 10001
+                        call 0
+                        drop
+                        local.get 1
+                        i64.const 1
+                        i64.sub
+                        local.tee 1
+                        i64.eqz
+                        i32.eqz
+                        br_if 0 (;@1;)
+                        end
+                        local.get 0
+                        i64.const 49995000
+                        i64.add)
+                    (func (;4;) (type 0) (param i32) (result i64)
+                        (local i64)
+                        i32.const 1
+                        i32.const 1
+                        call 0
+                        drop
+                        i32.const 10
+                        local.set 0
+                        loop  ;; label = @1
+                        i32.const 3
+                        i32.const 11
+                        call 0
+                        drop
+                        i64.const 0
+                        call 3
+                        local.get 1
+                        i64.add
+                        local.set 1
+                        local.get 0
+                        i32.const 1
+                        i32.sub
+                        local.tee 0
+                        br_if 0 (;@1;)
+                        end
+                        i32.const 0
+                        i32.const 0
+                        local.get 1
+                        call 1)
+                    (memory (;0;) 2)
+                    (export "memory" (memory 0))
+                    (export "cbak" (func 2))
+                    (export "hook" (func 4)))
+            )[test.hook]"];
+
+            env(ripple::test::jtx::hook(alice, {{hso(hook)}}, 0),
+                M("WCE overflow through helpers"),
+                HSFEE,
+                ter(temMALFORMED));
+            env.close();
+        }
+
+        // Test 8: guard inside guard
+        {
+            /*
+            #include <stdint.h>
+            extern int32_t _g(uint32_t id, uint32_t maxiter);
+            extern int64_t accept(uint32_t read_ptr, uint32_t read_len, int64_t
+            error_code);
+
+            int64_t helper(int64_t n) {
+                int64_t sum = n;
+                for (int i = 0; i < 100; ++i) {
+                    _g(2, 1000);
+                    sum += i;
+                }
+                return sum;
+            }
+
+            int64_t cbak(uint32_t reserved) {
+                _g(1, 1);
+                int64_t result = 10;
+                for (int i = 0; i < 10; ++i) {
+                    _g(3, 11);
+                    result += helper(10);
+                }
+                return accept(0, 0, result);
+            }
+
+            int64_t hook(uint32_t reserved) {
+                _g(1, 1);
+                int64_t result = 0;
+                for (int i = 0; i < 10; ++i) {
+                    _g(3, 11);
+                    result += helper(0);
+                }
+                return accept(0, 0, result);
+            }
+            */
+
+            TestHook hook_wasm = wasm[R"[test.hook](
+                (module
+                    (type (;0;) (func (param i32) (result i64)))
+                    (type (;1;) (func (param i32 i32) (result i32)))
+                    (type (;2;) (func (param i32 i32 i64) (result i64)))
+                    (type (;3;) (func (param i64) (result i64)))
+                    (import "env" "_g" (func (;0;) (type 1)))
+                    (import "env" "accept" (func (;1;) (type 2)))
+                    (func (;2;) (type 3) (param i64) (result i64)
+                        (local i64)
+                        i64.const 100
+                        local.set 1
+                        loop  ;; label = @1
+                        i32.const 2
+                        i32.const 1000
+                        call 0
+                        drop
+                        local.get 1
+                        i64.const 1
+                        i64.sub
+                        local.tee 1
+                        i64.eqz
+                        i32.eqz
+                        br_if 0 (;@1;)
+                        end
+                        local.get 0
+                        i64.const 4950
+                        i64.add)
+                    (func (;3;) (type 0) (param i32) (result i64)
+                        (local i64)
+                        i32.const 1
+                        i32.const 1
+                        call 0
+                        drop
+                        i32.const 10
+                        local.set 0
+                        i64.const 10
+                        local.set 1
+                        loop  ;; label = @1
+                        i32.const 3
+                        i32.const 11
+                        call 0
+                        drop
+                        i64.const 10
+                        call 2
+                        local.get 1
+                        i64.add
+                        local.set 1
+                        local.get 0
+                        i32.const 1
+                        i32.sub
+                        local.tee 0
+                        br_if 0 (;@1;)
+                        end
+                        i32.const 0
+                        i32.const 0
+                        local.get 1
+                        call 1)
+                    (func (;4;) (type 0) (param i32) (result i64)
+                        (local i64)
+                        i32.const 1
+                        i32.const 1
+                        call 0
+                        drop
+                        i32.const 10
+                        local.set 0
+                        loop  ;; label = @1
+                        i32.const 3
+                        i32.const 11
+                        call 0
+                        drop
+                        i64.const 0
+                        call 2
+                        local.get 1
+                        i64.add
+                        local.set 1
+                        local.get 0
+                        i32.const 1
+                        i32.sub
+                        local.tee 0
+                        br_if 0 (;@1;)
+                        end
+                        i32.const 0
+                        i32.const 0
+                        local.get 1
+                        call 1)
+                    (memory (;0;) 2)
+                    (export "memory" (memory 0))
+                    (export "cbak" (func 3))
+                    (export "hook" (func 4)))
+            )[test.hook]"];
+            HASH_WASM(hook);
+
+            env(ripple::test::jtx::hook(
+                    alice, {{hso(hook_wasm, overrideFlag)}}, 0),
+                M("guard inside guard"),
+                HSFEE,
+                ter(tesSUCCESS));
+            EXPECT_HOOK_FEE(hook, 9151);
+
+            env(pay(bob, alice, XRP(1)), M("Test helper 8"), fee(XRP(1)));
+            env.close();
+        }
+    }
+
    void
    test_emit(FeatureBitset features)
    {
@@ -14729,6 +15532,7 @@ public:
        test_rollback(features);

        testGuards(features);
+        testHelperFunctions(features);

        test_emit(features);  //
        test_prepare(features);
--- a/src/test/app/SetHook_wasm.h
+++ b/src/test/app/SetHook_wasm.h
--- a/src/test/app/XahauGenesis_test.cpp
+++ b/src/test/app/XahauGenesis_test.cpp
@@ -140,7 +140,8 @@ struct XahauGenesis_test : public beast::unit_test::suite
        bool skipTests = false,
        bool const testFlag = false,
        bool const badNetID = false,
-        uint32_t const expectedOwnerCount = 14 /** case for testFlag=false */)
+        uint32_t const expectedOwnerCount =
+            10 /** testFlag ? 10 : 14 (default) */)
    {
        using namespace jtx;

@@ -249,7 +250,9 @@ struct XahauGenesis_test : public beast::unit_test::suite
            genesisAccRoot->getFieldAmount(sfBalance) ==
            XahauGenesis::GenesisAmount);
        BEAST_EXPECT(
-            genesisAccRoot->getFieldU32(sfOwnerCount) == expectedOwnerCount);
+            genesisAccRoot->getFieldU32(sfOwnerCount) == !testFlag
+                ? expectedOwnerCount
+                : 14);

        // ensure the definitions are correctly set
        {
@@ -592,8 +595,7 @@ struct XahauGenesis_test : public beast::unit_test::suite
            false,
            true,
            {},
-            2 /*Hook objects *2 */ + 3 /* IRR,IRD,IMC HookStates */ +
-                members.size());
+            3 /* IRR,IRD,IMC */ + members.size() + tables.size());

        env.close();
        env.close();
@@ -2325,7 +2327,7 @@ struct XahauGenesis_test : public beast::unit_test::suite
            {
                BEAST_EXPECT(
                    root->getFieldU32(sfOwnerCount) ==
-                    (mc * 2 + 2 + paramsCount));
+                    mc * 2 + 2 + paramsCount);
                BEAST_EXPECT(root->getFieldU32(sfFlags) & lsfDisableMaster);
                BEAST_EXPECT(root->getAccountID(sfRegularKey) == noAccount());
            }
--- a/src/test/app/build_test_hooks.sh
+++ b/src/test/app/build_test_hooks.sh
@@ -58,8 +58,21 @@ 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|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`"
+                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`"
                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 ''`"
@@ -69,7 +82,7 @@ cat $INPUT_FILE | tr '\n' '\f' |
                    echo "$line"
                    exit 1
                fi
-                wasmcc -x c /dev/stdin -o /dev/stdout -O2 -Wl,--allow-undefined <<< "`tr '\f' '\n' <<< $line`" |
+                wasmcc -x c /dev/stdin -o /dev/stdout -O2 -Wl,--allow-undefined,--export=hook,--export=cbak <<< "`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
--- a/src/xrpld/app/hook/detail/applyHook.cpp
+++ b/src/xrpld/app/hook/detail/applyHook.cpp
@@ -2730,23 +2730,26 @@ DEFINE_HOOK_FUNCTION(

                return serialize_keylet(kl, memory, write_ptr, write_len);
            }
-            // These keylet types are not yet implemented. Their
-            // corresponding amendments are not yet supported on the
-            // network. Each case needs a full implementation (see
-            // above cases for reference) before its amendment can be
-            // enabled.
-            // featureXChainBridge
            case keylet_code::BRIDGE:
            case keylet_code::XCHAIN_OWNED_CLAIM_ID:
-            case keylet_code::XCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID:
-            // featureMPTokensV1
+            case keylet_code::XCHAIN_OWNED_CREATE_ACCOUNT_CLAIM_ID: {
+                if (!applyCtx.view().rules().enabled(featureXChainBridge))
+                    return INVALID_ARGUMENT;
+            }
            case keylet_code::MPTOKEN_ISSUANCE:
-            case keylet_code::MPTOKEN:
-            // featureCredentials
-            case keylet_code::CREDENTIAL:
-            // featurePermissionedDomains
-            case keylet_code::PERMISSIONED_DOMAIN:
-                return INVALID_ARGUMENT;
+            case keylet_code::MPTOKEN: {
+                if (!applyCtx.view().rules().enabled(featureMPTokensV1))
+                    return INVALID_ARGUMENT;
+            }
+            case keylet_code::CREDENTIAL: {
+                if (!applyCtx.view().rules().enabled(featureCredentials))
+                    return INVALID_ARGUMENT;
+            }
+            case keylet_code::PERMISSIONED_DOMAIN: {
+                if (!applyCtx.view().rules().enabled(
+                        featurePermissionedDomains))
+                    return INVALID_ARGUMENT;
+            }
        }
    }
    catch (std::exception& e)
Author	SHA1	Message	Date
tequ	04c2929883	Merge remote-tracking branch 'upstream/dev' into hook-helper-func	2026-04-27 14:17:42 +09:00
Alloy Networks	cd00ed72d8	change build instructions url	2026-04-24 11:12:28 +10:00
tequ	05a3e04f2d	Fix BEAST_ENHANCED_LOGGING not working and restore original behavior	2026-04-24 11:11:40 +10:00
tequ	66f7294120	Test: hint build_test_hooks.sh when hook wasm is empty in hso()	2026-04-24 11:10:46 +10:00
Nicholas Dudfield	7f6ac75617	Revert "chore: use improved levelization script with threading and argparse" This reverts commit `5c1d7d9ae9`.	2026-04-24 11:09:19 +10:00
Nicholas Dudfield	4150f0383c	chore: use improved levelization script with threading and argparse	2026-04-24 11:09:19 +10:00
Nicholas Dudfield	25123b370a	chore: replace levelization shell script with python Backport of XRPLF/rippled#6325. The python version runs ~80x faster.	2026-04-24 11:09:19 +10:00
tequ	f90ed41802	enable ccache direct_mode	2026-04-24 11:06:51 +10:00
tequ	8c4c158d3a	output ccache configuration in release-builder	2026-04-24 11:06:51 +10:00
tequ	2d2951875d	fix: typo `SignersListSet`	2026-04-24 11:05:20 +10:00
tequ	9bfca63574	Update util_keylet fee test	2026-04-24 11:00:31 +10:00
tequ	1ba444ae7f	Updated tests to align with the changes merged into the dev branch.	2026-04-24 11:00:31 +10:00
tequ	f96d9b6e51	Add tests for Hooks fee	2026-04-24 11:00:31 +10:00
tequ	63096d5fbc	add test	2026-01-21 12:45:05 +09:00
tequ	2e128acdcf	add execution test	2026-01-21 10:52:31 +09:00
tequ	043c60b62e	Update new tests	2026-01-20 20:07:26 +09:00
tequ	5dd1198e4f	Merge commit '5d9071695a616e1af378142e09649abc7d0e8afa' into hook-helper-func	2026-01-20 15:46:00 +09:00
tequ	5d9071695a	Add tests for Hooks fee	2026-01-20 12:12:45 +09:00
tequ	ec6dc93834	Allow helper functions at Hooks	2026-01-19 16:44:23 +09:00