Merge branch 'dev' into wasmtime-engine

Add Wasmtime v44.0.1 as a second WebAssembly execution engine, selectable at runtime via the new featureWasmtimeEngine Amendment. When the Amendment is enabled, hook execution and WASM validation switch from WasmEdge to Wasmtime.
sfHookInstructionCount changes semantics to fuel consumed (initial budget: 10,000,000,000 units); fee calculation is redefined accordingly.

New files:
- external/wasmtime/conanfile.py + conandata.yml — prebuilt C API binary package (macOS arm64, Linux x86_64; SHA256-pinned at v44.0.1)
- cmake/deps/Wasmtime.cmake — find_package(wasmtime REQUIRED)
- src/.../WasmtimeEngine.h/.cpp — IWasmEngine implementation

Build system changes:
- CMakeLists.txt, conanfile.py: with_wasmtime option (default on)
- cmake/RippledCore.cmake: link wasmtime::wasmtime alongside wasmedge::wasmedge

Protocol changes:
- features.macro: XRPL_FEATURE(WasmtimeEngine, Supported::yes, DefaultNo)
- WasmEngine.h: constexpr kWasmtimeInitialFuel = 10'000'000'000ULL (consensus-fixed)
- applyHook.cpp, SetHook.cpp, Change.cpp: engine selected by featureWasmtimeEngine

Implementation notes:
- Consensus-fixed config: consume_fuel=true, wasm_simd=true, relaxed_simd=false, reference_types=true, bulk_memory=true,  multi_value=false, nan_canonicalization=true
- Termination ABI: accept/rollback sets ExecState::terminated flag then returns a wasm_trap_t* to unwind the guest; execute() checks the flag before inspecting callErr to distinguish clean termination from errors
- Memory access workaround (ensureMemoryExported): Wasmtime lacks an index-based memory accessor equivalent to WasmEdge_CallingFrameGetMemoryInstance. The binary is patched before instantiation to inject a "memory" export when the module owns memory without exporting it, enabling wasmtime_caller_export_get() inside host callbacks.

.codecov.yml

@@ -19,15 +19,6 @@ coverage:
       default:
         target: auto
         threshold: 2%
-        paths:
-          # PeerImp is historically hard to exercise in the current unit-test
-          # harness. Keep this list narrow; new testable code should remain
-          # covered by the default patch gate.
-          - "!src/xrpld/overlay/detail/PeerImp.cpp"
-      historically-untested:
-        target: 0%
-        paths:
-          - "src/xrpld/overlay/detail/PeerImp.cpp"
     changes: false
 
 github_checks:

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

@@ -50,10 +50,6 @@ inputs:
     options:
       - libstdcxx
       - libcxx
-  conan_deps_cxxflags:
-    description: 'Extra cxxflags applied to Conan dependency package builds only (NOT the rippled build). JSON object keyed by Conan package pattern, e.g. {"grpc/*":["-Wno-foo"]}. Maps to <pattern>:tools.build:cxxflags.'
-    required: false
-    default: '{}'
 
 outputs:
   cache-hit:
@@ -85,8 +81,6 @@ runs:
 
     - name: Configure Conan
       shell: bash
-      env:
-        CONAN_DEPS_CXXFLAGS: ${{ inputs.conan_deps_cxxflags }}
       run: |
         # Create the default profile directory if it doesn't exist
         mkdir -p ~/.conan2/profiles
@@ -111,14 +105,7 @@ runs:
         os=${{ inputs.os }}
         EOF
 
-        # [buildenv] + [conf] sections.
-        # Linux pins compiler executables; macOS uses the system toolchain.
-        # conan_deps_cxxflags (matrix-driven) optionally adds package-pattern
-        # scoped tools.build:cxxflags for Conan dependency builds only - typically
-        # grpc workarounds for newer clang's stricter diagnostics. Because these
-        # are profile-pattern scoped (e.g. grpc/*:...), they do NOT affect the
-        # consumer/rippled toolchain generated for the main build.
-        NEED_CONF=0
+        # Add buildenv and conf sections for Linux (not needed for macOS)
         if [ "${{ inputs.os }}" = "Linux" ] && [ -n "${{ inputs.cc }}" ]; then
           cat >> ~/.conan2/profiles/default <<EOF
 
@@ -129,38 +116,16 @@ runs:
         [conf]
         tools.build:compiler_executables={"c": "/usr/bin/${{ inputs.cc }}", "cpp": "/usr/bin/${{ inputs.cxx }}"}
         EOF
-          NEED_CONF=1
         fi
 
-        if [ -n "${CONAN_DEPS_CXXFLAGS}" ] && [ "${CONAN_DEPS_CXXFLAGS}" != "{}" ]; then
-          CONAN_DEPS_CXXFLAGS_LINES="$(python3 - <<'PY'
-        import json
-        import os
-        import sys
+        # Add macOS-specific conf if needed
+        if [ "${{ inputs.os }}" = "Macos" ]; then
+          cat >> ~/.conan2/profiles/default <<EOF
 
-        raw = os.environ["CONAN_DEPS_CXXFLAGS"]
-        data = json.loads(raw)
-        if not isinstance(data, dict):
-            sys.exit("conan_deps_cxxflags must be a JSON object like {\"grpc/*\": [\"-Wno-...\"]}")
-
-        for pattern, flags in data.items():
-            if not isinstance(pattern, str) or not pattern:
-                sys.exit("conan_deps_cxxflags keys must be non-empty Conan package patterns")
-            if pattern == "&":
-                sys.exit("conan_deps_cxxflags must target dependency package patterns, not the consumer (&)")
-            if not isinstance(flags, list) or not all(isinstance(flag, str) for flag in flags):
-                sys.exit(f"{pattern}: cxxflags must be a JSON string list")
-            if flags:
-                print(f"{pattern}:tools.build:cxxflags={json.dumps(flags, separators=(',', ':'))}")
-        PY
-          )"
-          if [ -n "${CONAN_DEPS_CXXFLAGS_LINES}" ] && [ "$NEED_CONF" = "0" ]; then
-            echo "" >> ~/.conan2/profiles/default
-            echo "[conf]" >> ~/.conan2/profiles/default
-          fi
-          if [ -n "${CONAN_DEPS_CXXFLAGS_LINES}" ]; then
-            printf '%s\n' "${CONAN_DEPS_CXXFLAGS_LINES}" >> ~/.conan2/profiles/default
-          fi
+        [conf]
+        # Workaround for gRPC with newer Apple Clang
+        tools.build:cxxflags=["-Wno-missing-template-arg-list-after-template-kw"]
+        EOF
         fi
 
         # Display profile for verification

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

@@ -107,9 +107,6 @@ jobs:
           compiler: apple-clang
           compiler_version: ${{ steps.detect-compiler.outputs.compiler_version }}
           stdlib: libcxx
-          # grpc 1.50.1 trips clang-19+ -Werror=missing-template-arg-list-after-template-kw
-          # on Apple Clang. Drop when grpc is bumped past the fix.
-          conan_deps_cxxflags: '{"grpc/*":["-Wno-missing-template-arg-list-after-template-kw"]}'
 
       - name: Build
         uses: ./.github/actions/xahau-ga-build

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

@@ -72,26 +72,15 @@ jobs:
                   "job_type": "build"
               },
               {
-                  # Latest stable Clang for the most accurate source-based
-                  # coverage mapping (newer language features, fewer bugs in
-                  # llvm-cov region inference). Pulled from apt.llvm.org since
-                  # Ubuntu 24.04 default repos cap at clang-18.
-                  "compiler_id": "clang-20-libcxx",
-                  "compiler": "clang",
-                  "cc": "clang-20",
-                  "cxx": "clang++-20",
-                  "compiler_version": 20,
-                  "stdlib": "libcxx",
+                  "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",
-                  "coverage_tool": "llvm",
-                  "coverage_format": "lcov",
-                  # grpc 1.50.1 uses `Foo::template Bar(...)` without an
-                  # angle-bracket arg list; clang-19+ promoted that to
-                  # -Werror. Drop when grpc is bumped past the fix.
-                  "conan_deps_cxxflags": {
-                      "grpc/*": ["-Wno-missing-template-arg-list-after-template-kw"]
-                  }
+                  "job_type": "coverage"
               },
               {
                   "compiler_id": "clang-14-libstdcxx-gcc11",
@@ -142,7 +131,7 @@ jobs:
           # Minimal matrix for PRs and feature branches
           minimal_matrix = [
               full_matrix[1],  # gcc-13 (middle-ground gcc)
-              full_matrix[2],  # clang-20 llvm-cov coverage
+              full_matrix[2],  # gcc-13 coverage
               full_matrix[3]   # clang-14 (mature, stable clang)
           ]
           
@@ -218,9 +207,9 @@ jobs:
           # Select the appropriate matrix
           if use_full:
               if force_full:
-                  print(f"Using FULL matrix (7 configs (build x6 + clang-20 llvm-cov coverage)) - forced by [ci-nix-full-matrix] tag")
+                  print(f"Using FULL matrix (7 configs) - forced by [ci-nix-full-matrix] tag")
               else:
-                  print(f"Using FULL matrix (7 configs (build x6 + clang-20 llvm-cov coverage)) - targeting main branch")
+                  print(f"Using FULL matrix (7 configs) - targeting main branch")
               matrix = full_matrix
           else:
               print(f"Using MINIMAL matrix (3 configs) - feature branch/PR")
@@ -268,25 +257,9 @@ jobs:
 
       - name: Install build dependencies
         run: |
-          # Bump apt's default 3 retries; papers over short upstream blips
-          # like the recurring ppa.launchpadcontent.net outages.
-          echo 'Acquire::Retries "5";' > /etc/apt/apt.conf.d/80-retries
           apt-get update
           apt-get install -y software-properties-common
           add-apt-repository ppa:ubuntu-toolchain-r/test -y
-
-          # apt.llvm.org for Clang versions newer than what Ubuntu 24.04 ships
-          # (24.04 default repos cap at clang-18). The bootstrap script adds
-          # the LLVM apt source for the requested version and runs apt-get update.
-          if [ "${{ matrix.compiler }}" = "clang" ] && [ "${{ matrix.compiler_version }}" -ge 19 ]; then
-            apt-get install -y wget gnupg lsb-release
-            wget -qO /tmp/llvm.sh https://apt.llvm.org/llvm.sh
-            chmod +x /tmp/llvm.sh
-            # `all` installs clang + libllvm + lldb + lld + the llvm-N package
-            # (which provides llvm-profdata-N / llvm-cov-N for coverage runs).
-            /tmp/llvm.sh ${{ matrix.compiler_version }} all
-          fi
-
           apt-get update
           apt-get install -y git python3 python-is-python3 pipx
           pipx ensurepath
@@ -359,16 +332,10 @@ jobs:
           pipx install "conan>=2.0,<3"
           echo "$HOME/.local/bin" >> $GITHUB_PATH
 
-          # Install coverage tooling
+          # Install gcovr for coverage jobs
           if [ "${{ matrix.job_type }}" = "coverage" ]; then
+            pipx install "gcovr>=7,<9"
             apt-get install -y curl lcov
-            if [ "${{ matrix.coverage_tool }}" = "llvm" ]; then
-              # Native LLVM source-based coverage: llvm-profdata + llvm-cov.
-              # The clang-N package doesn't pull these in; the llvm-N package does.
-              apt-get install -y "llvm-${{ matrix.compiler_version }}"
-            else
-              pipx install "gcovr>=7,<9"
-            fi
           fi
 
       - name: Check environment
@@ -381,15 +348,10 @@ jobs:
           which ${{ matrix.cxx }} && ${{ matrix.cxx }} --version || echo "${{ matrix.cxx }} not found"
           which ccache && ccache --version || echo "ccache not found"
 
-          # Check coverage tooling
+          # Check gcovr for coverage jobs
           if [ "${{ matrix.job_type }}" = "coverage" ]; then
-            if [ "${{ matrix.coverage_tool }}" = "llvm" ]; then
-              which "llvm-profdata-${{ matrix.compiler_version }}" && "llvm-profdata-${{ matrix.compiler_version }}" --version || echo "llvm-profdata not found"
-              which "llvm-cov-${{ matrix.compiler_version }}" && "llvm-cov-${{ matrix.compiler_version }}" --version || echo "llvm-cov not found"
-            else
-              which gcov && gcov --version || echo "gcov not found"
-              which gcovr && gcovr --version || echo "gcovr not found"
-            fi
+            which gcov && gcov --version || echo "gcov not found"
+            which gcovr && gcovr --version || echo "gcovr not found"
           fi
 
           echo "---- Full Environment ----"
@@ -416,7 +378,6 @@ jobs:
           cc: ${{ matrix.cc }}
           cxx: ${{ matrix.cxx }}
           stdlib: ${{ matrix.stdlib }}
-          conan_deps_cxxflags: ${{ matrix.conan_deps_cxxflags && toJson(matrix.conan_deps_cxxflags) || '{}' }}
           gha_cache_enabled: 'false' # Disable caching for self hosted runner
 
       - name: Build
@@ -449,9 +410,8 @@ jobs:
           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.
-          # Use *_FLAGS_DEBUG so the build action's stdlib flag (e.g. -stdlib=libc++) in CMAKE_CXX_FLAGS isn't clobbered.
-          cmake-args: '-Dcoverage=ON -Dcoverage_tool=${{ matrix.coverage_tool }} -Dcoverage_format=${{ matrix.coverage_format }} -Dcoverage_test_parallelism=$(($(nproc)/2)) -DCODE_COVERAGE_VERBOSE=ON -DCMAKE_CXX_FLAGS_DEBUG="-g -O0" -DCMAKE_C_FLAGS_DEBUG="-g -O0"'
+          # 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'
 
@@ -483,26 +443,22 @@ jobs:
       - name: Move coverage report
         if: matrix.job_type == 'coverage'
         shell: bash
-        env:
-          COVERAGE_FILE: ${{ matrix.coverage_tool == 'llvm' && 'coverage.lcov' || 'coverage.xml' }}
         run: |
-          mv "${{ env.build_dir }}/${COVERAGE_FILE}" ./
-          echo "COVERAGE_FILE=${COVERAGE_FILE}" >> "$GITHUB_ENV"
+          mv "${{ env.build_dir }}/coverage.xml" ./
 
       - name: Archive coverage report
         if: matrix.job_type == 'coverage'
         uses: actions/upload-artifact@v4
         with:
-          name: ${{ env.COVERAGE_FILE }}-${{ matrix.compiler_id }}
-          path: ${{ env.COVERAGE_FILE }}
+          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: ${{ env.COVERAGE_FILE }}
-          flags: ${{ matrix.coverage_tool }}
+          files: coverage.xml
           fail_ci_if_error: true
           disable_search: true
           verbose: true

CMakeLists.txt

@@ -124,7 +124,8 @@ find_package(date REQUIRED)
 find_package(xxHash REQUIRED)
 find_package(magic_enum REQUIRED)
 
-include(deps/WasmEdge) 
+include(deps/WasmEdge)
+include(deps/Wasmtime)
   if(TARGET nudb::core)
   set(nudb nudb::core)
 elseif(TARGET NuDB::nudb)

build-core.sh

@@ -95,8 +95,16 @@ if [[ "$4" == "" ]]; then
   echo "Non GH, local building, no Action runner magic"
 else
   # GH Action, runner
-  cp /io/release-build/xahaud /data/builds/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4
-  cp /io/release-build/release.info /data/builds/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4.releaseinfo
+    if [[ "$(git rev-parse --abbrev-ref HEAD)" == "release" ]]; then
+        echo "building on the release branch... placing it in builds/candidate"
+        mkdir /data/builds/candidate
+        cp /io/release-build/xahaud /data/builds/candidate/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4
+        cp /io/release-build/release.info /data/builds/candidate/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4.releaseinfo
+    else
+        echo "building non-release branch, placing it in builds root"
+        cp /io/release-build/xahaud /data/builds/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4
+        cp /io/release-build/release.info /data/builds/$(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4.releaseinfo
+    fi  
   echo "Published build to: http://build.xahau.tech/"
   echo $(date +%Y).$(date +%-m).$(date +%-d)-$(git rev-parse --abbrev-ref HEAD)+$4
 fi

cmake/CodeCoverageLLVM.cmake

@@ -1,156 +0,0 @@
-#[===================================================================[
-  Native LLVM source-based code coverage helper.
-
-  Drives the -fprofile-instr-generate / -fcoverage-mapping pipeline:
-    1. Run instrumented binary with LLVM_PROFILE_FILE=...%m-%p.profraw
-    2. llvm-profdata merge -sparse  -> coverage.profdata
-    3. llvm-cov export/show/report  -> final report
-
-  Output filename per coverage_format:
-    lcov              -> coverage.lcov
-    json              -> coverage.json
-    txt | text        -> coverage.txt
-    html | html-details -> <NAME>/index.html
-#]===================================================================]
-
-include(CMakeParseArguments)
-
-# Locate llvm-profdata / llvm-cov, preferring versioned variants matching the
-# Clang we're building with so we don't accidentally pair clang-20 with
-# llvm-cov-14 (profile format mismatch -> hard failure).
-function(_find_llvm_cov_tools)
-  if(LLVM_PROFDATA_PATH AND LLVM_COV_PATH)
-    return()
-  endif()
-
-  string(REGEX MATCH "^[0-9]+" _major "${CMAKE_CXX_COMPILER_VERSION}")
-
-  set(_pd_names llvm-profdata)
-  set(_cov_names llvm-cov)
-  if(_major)
-    list(PREPEND _pd_names "llvm-profdata-${_major}")
-    list(PREPEND _cov_names "llvm-cov-${_major}")
-  endif()
-
-  # Only delegate to xcrun when the *compiler* is AppleClang. On macOS with
-  # Homebrew/system clang-N, xcrun would resolve to Xcode's llvm tools which
-  # could be a different version - exactly the mismatch we want to avoid.
-  if(APPLE AND CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
-    execute_process(COMMAND xcrun -f llvm-profdata
-      OUTPUT_VARIABLE _pd_xcrun OUTPUT_STRIP_TRAILING_WHITESPACE
-      ERROR_QUIET RESULT_VARIABLE _pd_rc)
-    if(_pd_rc EQUAL 0 AND _pd_xcrun)
-      set(LLVM_PROFDATA_PATH "${_pd_xcrun}" CACHE FILEPATH "llvm-profdata" FORCE)
-    endif()
-    execute_process(COMMAND xcrun -f llvm-cov
-      OUTPUT_VARIABLE _cov_xcrun OUTPUT_STRIP_TRAILING_WHITESPACE
-      ERROR_QUIET RESULT_VARIABLE _cov_rc)
-    if(_cov_rc EQUAL 0 AND _cov_xcrun)
-      set(LLVM_COV_PATH "${_cov_xcrun}" CACHE FILEPATH "llvm-cov" FORCE)
-    endif()
-  endif()
-
-  if(NOT LLVM_PROFDATA_PATH)
-    find_program(LLVM_PROFDATA_PATH NAMES ${_pd_names})
-  endif()
-  if(NOT LLVM_COV_PATH)
-    find_program(LLVM_COV_PATH NAMES ${_cov_names})
-  endif()
-endfunction()
-
-function(setup_target_for_coverage_llvm)
-  set(oneValueArgs NAME FORMAT)
-  set(multiValueArgs EXCLUDE EXECUTABLE EXECUTABLE_ARGS DEPENDENCIES)
-  cmake_parse_arguments(Cov "" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
-
-  _find_llvm_cov_tools()
-  if(NOT LLVM_PROFDATA_PATH)
-    message(FATAL_ERROR "llvm-profdata not found (needed for coverage_tool=llvm)")
-  endif()
-  if(NOT LLVM_COV_PATH)
-    message(FATAL_ERROR "llvm-cov not found (needed for coverage_tool=llvm)")
-  endif()
-
-  if(NOT Cov_FORMAT)
-    set(Cov_FORMAT lcov)
-  endif()
-
-  set(_profraw_dir "${PROJECT_BINARY_DIR}/${Cov_NAME}-profraw")
-  set(_profdata    "${PROJECT_BINARY_DIR}/${Cov_NAME}.profdata")
-
-  # Resolve binary path: accept either an absolute path or a bare target name
-  # (resolved against PROJECT_BINARY_DIR). Splice the resolved path back into
-  # Cov_EXECUTABLE so the run command invokes it via absolute path - bare
-  # names aren't on PATH and the build dir isn't `.` either.
-  list(GET Cov_EXECUTABLE 0 _exec_name)
-  if(IS_ABSOLUTE "${_exec_name}")
-    set(_binary "${_exec_name}")
-  else()
-    set(_binary "${PROJECT_BINARY_DIR}/${_exec_name}")
-    list(REMOVE_AT Cov_EXECUTABLE 0)
-    list(PREPEND Cov_EXECUTABLE "${_binary}")
-  endif()
-
-  # llvm-cov takes a single -ignore-filename-regex; OR our excludes together.
-  set(_ignore_regex "")
-  foreach(EXC IN LISTS Cov_EXCLUDE)
-    if(_ignore_regex)
-      string(APPEND _ignore_regex "|")
-    endif()
-    string(APPEND _ignore_regex "${EXC}")
-  endforeach()
-  set(_filter "")
-  if(_ignore_regex)
-    set(_filter "-ignore-filename-regex='${_ignore_regex}'")
-  endif()
-
-  # Pick llvm-cov subcommand + output file for the requested format. Each
-  # branch builds a single shell command string that we'll hand to bash -c.
-  if(Cov_FORMAT STREQUAL "lcov")
-    set(_output "${PROJECT_BINARY_DIR}/coverage.lcov")
-    set(_report_sh "${LLVM_COV_PATH} export -instr-profile='${_profdata}' -format=lcov ${_filter} '${_binary}' > '${_output}'")
-  elseif(Cov_FORMAT STREQUAL "json")
-    set(_output "${PROJECT_BINARY_DIR}/coverage.json")
-    set(_report_sh "${LLVM_COV_PATH} export -instr-profile='${_profdata}' -format=text ${_filter} '${_binary}' > '${_output}'")
-  elseif(Cov_FORMAT STREQUAL "txt" OR Cov_FORMAT STREQUAL "text")
-    set(_output "${PROJECT_BINARY_DIR}/coverage.txt")
-    set(_report_sh "${LLVM_COV_PATH} report -instr-profile='${_profdata}' ${_filter} '${_binary}' > '${_output}'")
-  elseif(Cov_FORMAT STREQUAL "html" OR Cov_FORMAT STREQUAL "html-details")
-    set(_output "${PROJECT_BINARY_DIR}/${Cov_NAME}/index.html")
-    set(_report_sh "${LLVM_COV_PATH} show -instr-profile='${_profdata}' -format=html -output-dir='${PROJECT_BINARY_DIR}/${Cov_NAME}' ${_filter} '${_binary}'")
-  else()
-    message(FATAL_ERROR "coverage_tool=llvm: unsupported coverage_format '${Cov_FORMAT}' (use lcov|json|txt|html)")
-  endif()
-
-  set(_merge_sh "${LLVM_PROFDATA_PATH} merge -sparse -o '${_profdata}' '${_profraw_dir}'/*.profraw")
-
-  if(CODE_COVERAGE_VERBOSE)
-    message(STATUS "[coverage:llvm] binary:   ${_binary}")
-    message(STATUS "[coverage:llvm] profraw:  ${_profraw_dir}")
-    message(STATUS "[coverage:llvm] profdata: ${_profdata}")
-    message(STATUS "[coverage:llvm] format:   ${Cov_FORMAT}")
-    message(STATUS "[coverage:llvm] output:   ${_output}")
-    if(_ignore_regex)
-      message(STATUS "[coverage:llvm] ignore:   ${_ignore_regex}")
-    endif()
-    message(STATUS "[coverage:llvm] merge:    ${_merge_sh}")
-    message(STATUS "[coverage:llvm] report:   ${_report_sh}")
-  endif()
-
-  # %m: hash of the binary, %p: pid. Wipe the dir up front so stale profraw
-  # files can't leak into a fresh merge.
-  add_custom_target(${Cov_NAME}
-    COMMAND ${CMAKE_COMMAND} -E rm -rf "${_profraw_dir}"
-    COMMAND ${CMAKE_COMMAND} -E make_directory "${_profraw_dir}"
-    COMMAND ${CMAKE_COMMAND} -E env
-        "LLVM_PROFILE_FILE=${_profraw_dir}/rippled-%m-%p.profraw"
-        ${Cov_EXECUTABLE} ${Cov_EXECUTABLE_ARGS}
-    COMMAND bash -c "${_merge_sh}"
-    COMMAND bash -c "${_report_sh}"
-    BYPRODUCTS ${_output}
-    WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
-    DEPENDS ${Cov_DEPENDENCIES}
-    VERBATIM
-    COMMENT "Running llvm-cov (${Cov_FORMAT}) -> ${_output}"
-  )
-endfunction()

cmake/RippledCore.cmake

@@ -58,6 +58,7 @@ target_link_libraries(xrpl.imports.main
     OpenSSL::Crypto
     Ripple::boost
     wasmedge::wasmedge
+    wasmtime::wasmtime
     Ripple::opts
     Ripple::syslibs
     absl::random_random

cmake/RippledCov.cmake

@@ -11,21 +11,6 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
   return()
 endif()
 
-if(coverage_tool STREQUAL "llvm")
-  include(CodeCoverageLLVM)
-
-  setup_target_for_coverage_llvm(
-    NAME coverage
-    FORMAT ${coverage_format}
-    EXECUTABLE rippled
-    EXECUTABLE_ARGS --unittest$<$<BOOL:${coverage_test}>:=${coverage_test}> --unittest-jobs ${coverage_test_parallelism} --quiet --unittest-log
-    EXCLUDE "src/test" "include/xrpl/beast/test" "include/xrpl/beast/unit_test" "${CMAKE_BINARY_DIR}/pb-xrpl.libpb"
-    DEPENDENCIES rippled
-  )
-  return()
-endif()
-
-# coverage_tool == "gcov" (default): existing gcovr-driven pipeline.
 include(CodeCoverage)
 
 # The instructions for these commands come from the `CodeCoverage` module,

cmake/RippledInterface.cmake

@@ -28,17 +28,15 @@ target_compile_options (opts
     $<$<AND:$<BOOL:${is_gcc}>,$<COMPILE_LANGUAGE:CXX>>:-Wsuggest-override>
     $<$<BOOL:${is_gcc}>:-Wno-maybe-uninitialized>
     $<$<BOOL:${perf}>:-fno-omit-frame-pointer>
-    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>,$<STREQUAL:${coverage_tool},gcov>>:-g --coverage -fprofile-abs-path>
-    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>,$<STREQUAL:${coverage_tool},gcov>>:-g --coverage>
-    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>,$<STREQUAL:${coverage_tool},llvm>>:-g -fprofile-instr-generate -fcoverage-mapping>
+    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-g --coverage -fprofile-abs-path>
+    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-g --coverage>
     $<$<BOOL:${profile}>:-pg>
     $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
 
 target_link_libraries (opts
   INTERFACE
-    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>,$<STREQUAL:${coverage_tool},gcov>>:-g --coverage -fprofile-abs-path>
-    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>,$<STREQUAL:${coverage_tool},gcov>>:-g --coverage>
-    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>,$<STREQUAL:${coverage_tool},llvm>>:-g -fprofile-instr-generate -fcoverage-mapping>
+    $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${coverage}>>:-g --coverage -fprofile-abs-path>
+    $<$<AND:$<BOOL:${is_clang}>,$<BOOL:${coverage}>>:-g --coverage>
     $<$<BOOL:${profile}>:-pg>
     $<$<AND:$<BOOL:${is_gcc}>,$<BOOL:${profile}>>:-p>)
 

cmake/RippledSettings.cmake

@@ -29,25 +29,13 @@ if(is_gcc OR is_clang)
     "Unit tests parallelism for the purpose of coverage report.")
   set(coverage_format "html-details" CACHE STRING
     "Output format of the coverage report.")
-  set(coverage_tool "gcov" CACHE STRING
-    "Coverage instrumentation tool: 'gcov' (default, gcc/clang via --coverage + gcovr) or 'llvm' (clang only, native source-based coverage via -fprofile-instr-generate).")
-  set_property(CACHE coverage_tool PROPERTY STRINGS "gcov" "llvm")
-  if(NOT coverage_tool MATCHES "^(gcov|llvm)$")
-    message(FATAL_ERROR "coverage_tool must be 'gcov' or 'llvm', got '${coverage_tool}'")
-  endif()
   set(coverage_extra_args "" CACHE STRING
-    "Additional arguments to pass to gcovr (gcov tool only).")
+    "Additional arguments to pass to gcovr.")
   set(coverage_test "" CACHE STRING
     "On gcc & clang, the specific unit test(s) to run for coverage. Default is all tests.")
   if(coverage_test AND NOT coverage)
     set(coverage ON CACHE BOOL "gcc/clang only" FORCE)
   endif()
-  # Validate after coverage_test may have flipped coverage on, otherwise
-  # `-Dcoverage_tool=llvm -Dcoverage_test=Foo` on gcc would silently slip
-  # past the Clang guard and produce a broken instrumentation combo.
-  if(coverage AND coverage_tool STREQUAL "llvm" AND NOT is_clang)
-    message(FATAL_ERROR "coverage_tool=llvm requires Clang (got ${CMAKE_CXX_COMPILER_ID})")
-  endif()
   option(wextra "compile with extra gcc/clang warnings enabled" ON)
 else()
   set(profile OFF CACHE BOOL "gcc/clang only" FORCE)

cmake/deps/Wasmtime.cmake

@@ -0,0 +1 @@
+find_package(wasmtime REQUIRED)

conanfile.py

@@ -22,6 +22,7 @@ class Xrpl(ConanFile):
         'unity': [True, False],
         'xrpld': [True, False],
         'with_wasmedge': [True, False],
+        'with_wasmtime': [True, False],
         'tool_requires_b2': [True, False],
     }
 
@@ -53,6 +54,7 @@ class Xrpl(ConanFile):
         'unity': False,
         'xrpld': False,
         'with_wasmedge': True,
+        'with_wasmtime': True,
         'tool_requires_b2': False,
 
         'date/*:header_only': False,
@@ -121,6 +123,8 @@ class Xrpl(ConanFile):
 
         if self.options.with_wasmedge:
             self.requires('wasmedge/0.11.2@xahaud/stable')
+        if self.options.with_wasmtime:
+            self.requires('wasmtime/44.0.1@xahaud/stable')
         if self.options.jemalloc:
             self.requires('jemalloc/5.3.0')
         if self.options.rocksdb:

external/wasmtime/conandata.yml

@@ -0,0 +1,25 @@
+sources:
+  "44.0.1":
+    Macos:
+      "armv8":
+        "gcc":
+          url: "https://github.com/bytecodealliance/wasmtime/releases/download/v44.0.1/wasmtime-v44.0.1-aarch64-macos-c-api.tar.xz"
+          sha256: "5da6d09fa6340db6d7afc8b73d189eff4973825c9a6fa5e814d2f9b1ddfd8998"
+      "x86_64":
+        "gcc":
+          url: "https://github.com/bytecodealliance/wasmtime/releases/download/v44.0.1/wasmtime-v44.0.1-x86_64-macos-c-api.tar.xz"
+          sha256: ""
+    Linux:
+      "x86_64":
+        "gcc":
+          url: "https://github.com/bytecodealliance/wasmtime/releases/download/v44.0.1/wasmtime-v44.0.1-x86_64-linux-c-api.tar.xz"
+          sha256: "fe9b4bfa87724054cebcc09b83a17d5ded66a465054b77c8de0ebc166ad78d7a"
+      "armv8":
+        "gcc":
+          url: "https://github.com/bytecodealliance/wasmtime/releases/download/v44.0.1/wasmtime-v44.0.1-aarch64-linux-c-api.tar.xz"
+          sha256: ""
+    Windows:
+      "x86_64":
+        "Visual Studio":
+          url: "https://github.com/bytecodealliance/wasmtime/releases/download/v44.0.1/wasmtime-v44.0.1-x86_64-windows-c-api.zip"
+          sha256: ""

external/wasmtime/conanfile.py

@@ -0,0 +1,87 @@
+from conan import ConanFile
+from conan.tools.files import get, copy
+from conan.errors import ConanInvalidConfiguration
+
+import os
+
+required_conan_version = ">=1.53.0"
+
+class WasmtimeConan(ConanFile):
+    name = "wasmtime"
+    description = ("Wasmtime is a fast and secure runtime for WebAssembly. "
+                   "It is a standalone wasm-only optimizing runtime for WebAssembly and WASI.")
+    license = "Apache-2.0"
+    url = "https://github.com/bytecodealliance/wasmtime"
+    homepage = "https://github.com/bytecodealliance/wasmtime"
+    topics = ("webassembly", "wasm", "wasi")
+    package_type = "static-library"
+    settings = "os", "arch", "compiler", "build_type"
+
+    @property
+    def _compiler_alias(self):
+        return {
+            "Visual Studio": "Visual Studio",
+            "msvc": "Visual Studio",
+        }.get(str(self.info.settings.compiler), "gcc")
+
+    def configure(self):
+        self.settings.compiler.rm_safe("libcxx")
+        self.settings.compiler.rm_safe("cppstd")
+
+    def validate(self):
+        try:
+            self.conan_data["sources"][self.version][str(self.settings.os)][str(self.settings.arch)][self._compiler_alias]
+        except KeyError:
+            raise ConanInvalidConfiguration(
+                f"Binaries for this combination of version/os/arch/compiler are not available "
+                f"({self.version}/{self.settings.os}/{self.settings.arch}/{self._compiler_alias})"
+            )
+        entry = self.conan_data["sources"][self.version][str(self.settings.os)][str(self.settings.arch)][self._compiler_alias]
+        if not entry.get("sha256"):
+            raise ConanInvalidConfiguration(
+                f"SHA256 not configured for {self.version}/{self.settings.os}/{self.settings.arch}/{self._compiler_alias}"
+            )
+
+    def package_id(self):
+        # Make binary compatible across compiler versions (since we're downloading prebuilt)
+        self.info.settings.rm_safe("compiler.version")
+        # Group compilers by their binary compatibility
+        compiler_name = str(self.info.settings.compiler)
+        if compiler_name in ["Visual Studio", "msvc"]:
+            self.info.settings.compiler = "Visual Studio"
+        else:
+            self.info.settings.compiler = "gcc"
+
+    def build(self):
+        # Download the prebuilt tarball
+        entry = self.conan_data["sources"][self.version][str(self.settings.os)][str(self.settings.arch)][self._compiler_alias]
+        get(self, url=entry["url"], sha256=entry["sha256"],
+            destination=self.source_folder, strip_root=True)
+
+    def package(self):
+        copy(self, pattern="*.h", dst=os.path.join(self.package_folder, "include"),
+             src=os.path.join(self.source_folder, "include"), keep_path=True)
+
+        srclibdir = os.path.join(self.source_folder, "lib")
+        dstlibdir = os.path.join(self.package_folder, "lib")
+
+        if self.settings.os == "Windows":
+            copy(self, pattern="wasmtime.lib", src=srclibdir, dst=dstlibdir, keep_path=False)
+            copy(self, pattern="wasmtime.dll", src=srclibdir, dst=os.path.join(self.package_folder, "bin"), keep_path=False)
+        elif self.settings.os == "Macos":
+            copy(self, pattern="libwasmtime.a", src=srclibdir, dst=dstlibdir, keep_path=False)
+            copy(self, pattern="libwasmtime.dylib", src=srclibdir, dst=dstlibdir, keep_path=False)
+        else:
+            copy(self, pattern="libwasmtime.a", src=srclibdir, dst=dstlibdir, keep_path=False)
+            copy(self, pattern="libwasmtime.so*", src=srclibdir, dst=dstlibdir, keep_path=False)
+
+        copy(self, pattern="LICENSE", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"), keep_path=False)
+
+    def package_info(self):
+        self.cpp_info.libs = ["wasmtime"]
+
+        if self.settings.os == "Windows":
+            self.cpp_info.system_libs += ["ws2_32", "bcrypt", "advapi32", "userenv", "ntdll", "shell32", "ole32"]
+
+        if self.settings.os in ["Linux", "FreeBSD"]:
+            self.cpp_info.system_libs += ["pthread", "dl", "m"]

include/xrpl/hook/Macro.h

@@ -10,6 +10,8 @@
  * were then used.
  */
 
+#include <xrpl/hook/WasmTypes.h>
+
 #define LPAREN (
 #define RPAREN )
 #define COMMA ,
@@ -68,104 +70,90 @@
 #define SEP_uint64_t LPAREN uint64_t COMMA
 #define SEP_int64_t LPAREN int64_t COMMA
 
-#define VAL_uint32_t WasmEdge_ValueGetI32(in[_stack++])
-#define VAL_int32_t WasmEdge_ValueGetI32(in[_stack++])
-#define VAL_uint64_t WasmEdge_ValueGetI64(in[_stack++])
-#define VAL_int64_t WasmEdge_ValueGetI64(in[_stack++])
+// VAL_* : extract typed value from WasmValue in[] array (engine-agnostic)
+#define VAL_uint32_t (uint32_t) in[_stack++].asI32()
+#define VAL_int32_t (int32_t) in[_stack++].asI32()
+#define VAL_uint64_t (uint64_t) in[_stack++].asI64()
+#define VAL_int64_t (int64_t) in[_stack++].asI64()
 
 #define VAR_ASSIGN(T, V) T V = CAT(VAL_##T)
 
-#define RET_uint32_t(return_code) WasmEdge_ValueGenI32(return_code)
-#define RET_int32_t(return_code) WasmEdge_ValueGenI32(return_code)
-#define RET_uint64_t(return_code) WasmEdge_ValueGenI64(return_code)
-#define RET_int64_t(return_code) WasmEdge_ValueGenI64(return_code)
+// RET_* : wrap a C return value into a WasmValue
+#define RET_uint32_t(return_code) hook::WasmValue::i32((uint32_t)(return_code))
+#define RET_int32_t(return_code) hook::WasmValue::i32((uint32_t)(return_code))
+#define RET_uint64_t(return_code) hook::WasmValue::i64((uint64_t)(return_code))
+#define RET_int64_t(return_code) hook::WasmValue::i64((uint64_t)(return_code))
 
 #define RET_ASSIGN(T, return_code) CAT2(RET_, T(return_code))
 
-#define TYP_uint32_t WasmEdge_ValType_I32
-#define TYP_int32_t WasmEdge_ValType_I32
-#define TYP_uint64_t WasmEdge_ValType_I64
-#define TYP_int64_t WasmEdge_ValType_I64
+// TYP_* : map C type to WasmValue::Kind (used by WasmEdgeEngine.cpp registry)
+#define TYP_uint32_t hook::WasmValue::Kind::I32
+#define TYP_int32_t hook::WasmValue::Kind::I32
+#define TYP_uint64_t hook::WasmValue::Kind::I64
+#define TYP_int64_t hook::WasmValue::Kind::I64
 
 #define WASM_VAL_TYPE(T, b) CAT2(TYP_, T)
 
 #define UNSIGNED_TYPE(T) std::make_unsigned_t<T>
 
+// DECLARE_HOOK_FUNCTION: forward-declares the impl function and the engine
+// wrapper
 #define DECLARE_HOOK_FUNCTION(R, F, ...)                          \
     std::variant<UNSIGNED_TYPE(R), hook_api::hook_return_code> F( \
         hook::HookContext& hookCtx,                               \
-        WasmEdge_CallingFrameContext const& frameCtx __VA_OPT__(  \
-            COMMA __VA_ARGS__));                                  \
-    extern WasmEdge_Result WasmFunction##F(                       \
-        void* data_ptr,                                           \
-        const WasmEdge_CallingFrameContext* frameCtx,             \
-        const WasmEdge_Value* in,                                 \
-        WasmEdge_Value* out);                                     \
-    extern WasmEdge_ValType WasmFunctionParams##F[];              \
-    extern WasmEdge_ValType WasmFunctionResult##F[];              \
-    extern WasmEdge_FunctionTypeContext* WasmFunctionType##F;     \
-    extern WasmEdge_String WasmFunctionName##F;
+        hook::GuestMemory& mem __VA_OPT__(COMMA __VA_ARGS__));    \
+    extern hook::HostCallStatus WasmFunction##F(                  \
+        void* userData,                                           \
+        hook::GuestMemory& mem,                                   \
+        hook::WasmValue const* in,                                \
+        size_t inLen,                                             \
+        hook::WasmValue* out,                                     \
+        size_t outLen);
 
+// DEFINE_HOOK_FUNCTION: defines the engine-agnostic wrapper + the impl function
+// body
 #define DEFINE_HOOK_FUNCTION(R, F, ...)                                        \
-    WasmEdge_Result hook_api::WasmFunction##F(                                 \
+    hook::HostCallStatus hook_api::WasmFunction##F(                            \
         void* data_ptr,                                                        \
-        const WasmEdge_CallingFrameContext* frameCtx,                          \
-        const WasmEdge_Value* in,                                              \
-        WasmEdge_Value* out)                                                   \
+        hook::GuestMemory& mem,                                                \
+        hook::WasmValue const* in,                                             \
+        size_t /*inLen*/,                                                      \
+        hook::WasmValue* out,                                                  \
+        size_t /*outLen*/)                                                     \
     {                                                                          \
         __VA_OPT__(int _stack = 0;)                                            \
         __VA_OPT__(FOR_VARS(VAR_ASSIGN, 2, __VA_ARGS__);)                      \
         hook::HookContext* hookCtx =                                           \
             reinterpret_cast<hook::HookContext*>(data_ptr);                    \
         auto const& return_code = hook_api::F(                                 \
-            *hookCtx,                                                          \
-            *const_cast<WasmEdge_CallingFrameContext*>(frameCtx)               \
-                __VA_OPT__(COMMA STRIP_TYPES(__VA_ARGS__)));                   \
+            *hookCtx, mem __VA_OPT__(COMMA STRIP_TYPES(__VA_ARGS__)));         \
         if (std::holds_alternative<hook_api::hook_return_code>(return_code) && \
             (std::get<hook_api::hook_return_code>(return_code) ==              \
                  RC_ROLLBACK ||                                                \
              std::get<hook_api::hook_return_code>(return_code) == RC_ACCEPT))  \
-            return WasmEdge_Result_Terminate;                                  \
+            return hook::HostCallStatus::Terminate;                            \
         out[0] = RET_ASSIGN(                                                   \
             R,                                                                 \
             std::holds_alternative<UNSIGNED_TYPE(R)>(return_code)              \
                 ? std::get<UNSIGNED_TYPE(R)>(return_code)                      \
                 : R(std::get<hook_api::hook_return_code>(return_code)));       \
-        return WasmEdge_Result_Success;                                        \
+        return hook::HostCallStatus::Success;                                  \
     };                                                                         \
-    WasmEdge_ValType hook_api::WasmFunctionParams##F[] = {                     \
-        __VA_OPT__(FOR_VARS(WASM_VAL_TYPE, 0, __VA_ARGS__))};                  \
-    WasmEdge_ValType hook_api::WasmFunctionResult##F[1] = {                    \
-        WASM_VAL_TYPE(R, dummy)};                                              \
-    WasmEdge_FunctionTypeContext* hook_api::WasmFunctionType##F =              \
-        WasmEdge_FunctionTypeCreate(                                           \
-            WasmFunctionParams##F,                                             \
-            VA_NARGS(NULL __VA_OPT__(, __VA_ARGS__)),                          \
-            WasmFunctionResult##F,                                             \
-            1);                                                                \
-    WasmEdge_String hook_api::WasmFunctionName##F =                            \
-        WasmEdge_StringCreateByCString(#F);                                    \
     std::variant<UNSIGNED_TYPE(R), hook_api::hook_return_code> hook_api::F(    \
         hook::HookContext& hookCtx,                                            \
-        WasmEdge_CallingFrameContext const& frameCtx __VA_OPT__(               \
-            COMMA __VA_ARGS__))
+        hook::GuestMemory& mem __VA_OPT__(COMMA __VA_ARGS__))
 
-#define HOOK_SETUP()                                                 \
-    using enum hook_api::hook_return_code;                           \
-    try                                                              \
-    {                                                                \
-        [[maybe_unused]] ApplyContext& applyCtx = hookCtx.applyCtx;  \
-        [[maybe_unused]] auto& view = applyCtx.view();               \
-        [[maybe_unused]] auto j = applyCtx.app.journal("View");      \
-        [[maybe_unused]] WasmEdge_MemoryInstanceContext* memoryCtx = \
-            WasmEdge_CallingFrameGetMemoryInstance(&frameCtx, 0);    \
-        [[maybe_unused]] unsigned char* memory =                     \
-            WasmEdge_MemoryInstanceGetPointer(memoryCtx, 0, 0);      \
-        [[maybe_unused]] const uint64_t memory_length =              \
-            WasmEdge_MemoryInstanceGetPageSize(memoryCtx) *          \
-            WasmEdge_kPageSize;                                      \
-        [[maybe_unused]] auto& api = hookCtx.api();                  \
-        if (!memoryCtx || !memory || !memory_length)                 \
+#define HOOK_SETUP()                                                \
+    using enum hook_api::hook_return_code;                          \
+    try                                                             \
+    {                                                               \
+        [[maybe_unused]] ApplyContext& applyCtx = hookCtx.applyCtx; \
+        [[maybe_unused]] auto& view = applyCtx.view();              \
+        [[maybe_unused]] auto j = applyCtx.app.journal("View");     \
+        [[maybe_unused]] unsigned char* memory = mem.base;          \
+        [[maybe_unused]] const uint64_t memory_length = mem.size;   \
+        [[maybe_unused]] auto& api = hookCtx.api();                 \
+        if (!memory || !memory_length)                              \
             return INTERNAL_ERROR;
 
 #define HOOK_TEARDOWN()                                        \
@@ -197,11 +185,10 @@
                            << " bytes past end of wasm memory";             \
             return OUT_OF_BOUNDS;                                           \
         }                                                                   \
-        if (!WasmEdge_ResultOK(WasmEdge_MemoryInstanceSetData(              \
-                memoryCtx,                                                  \
-                reinterpret_cast<const uint8_t*>(host_src_ptr),             \
+        if (!mem.write(                                                     \
                 guest_dst_ptr,                                              \
-                bytes_to_write)))                                           \
+                reinterpret_cast<uint8_t const*>(host_src_ptr),             \
+                static_cast<uint64_t>(bytes_to_write)))                     \
             return INTERNAL_ERROR;                                          \
         bytes_written += bytes_to_write;                                    \
     }

include/xrpl/hook/WasmTypes.h

@@ -0,0 +1,114 @@
+#ifndef RIPPLE_HOOK_WASMTYPES_H_INCLUDED
+#define RIPPLE_HOOK_WASMTYPES_H_INCLUDED
+
+#include <xrpl/basics/base_uint.h>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+namespace hook {
+
+struct GuestMemory
+{
+    uint8_t* base;
+    uint64_t size;
+
+    inline bool
+    inBounds(uint64_t guestPtr, uint64_t len) const
+    {
+        if (len > 0 && guestPtr > (UINT64_MAX - len + 1))
+            return false;
+        return (guestPtr + len) <= size;
+    }
+
+    inline bool
+    write(uint64_t guestPtr, void const* src, uint64_t len)
+    {
+        if (!inBounds(guestPtr, len))
+            return false;
+        std::memcpy(base + guestPtr, src, len);
+        return true;
+    }
+
+    inline bool
+    read(uint64_t guestPtr, void* dst, uint64_t len) const
+    {
+        if (!inBounds(guestPtr, len))
+            return false;
+        std::memcpy(dst, base + guestPtr, len);
+        return true;
+    }
+};
+
+struct WasmValue
+{
+    enum Kind : uint8_t
+    {
+        I32,
+        I64
+    } kind;
+
+    union
+    {
+        uint32_t u32;
+        uint64_t u64;
+    };
+
+    static inline WasmValue
+    i32(uint32_t v)
+    {
+        WasmValue w;
+        w.kind = I32;
+        w.u32 = v;
+        return w;
+    }
+
+    static inline WasmValue
+    i64(uint64_t v)
+    {
+        WasmValue w;
+        w.kind = I64;
+        w.u64 = v;
+        return w;
+    }
+
+    inline uint32_t
+    asI32() const
+    {
+        return u32;
+    }
+
+    inline uint64_t
+    asI64() const
+    {
+        return u64;
+    }
+};
+
+enum class HostCallStatus
+{
+    Success,
+    Terminate,
+    Trap,
+};
+
+using HostFunctionFn = HostCallStatus (*)(
+    void* userData,
+    GuestMemory& mem,
+    WasmValue const* in,
+    size_t inLen,
+    WasmValue* out,
+    size_t outLen);
+
+struct HostFunctionDecl
+{
+    char const* name;
+    HostFunctionFn fn;
+    std::vector<WasmValue::Kind> params;
+    WasmValue::Kind result;
+    ripple::uint256 const* featureGate;
+};
+
+}  // namespace hook
+
+#endif  // RIPPLE_HOOK_WASMTYPES_H_INCLUDED

include/xrpl/protocol/detail/features.macro

@@ -34,6 +34,7 @@
 // If you add an amendment here, then do not forget to increment `numFeatures`
 // in include/xrpl/protocol/Feature.h.
 
+XRPL_FEATURE(WasmtimeEngine,             Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (HookMap,                    Supported::yes, VoteBehavior::DefaultYes)
 XRPL_FIX    (GuardDepth32,               Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(NamedHooks,                 Supported::yes, VoteBehavior::DefaultNo)

src/test/app/SetHook_test.cpp

@@ -15202,8 +15202,9 @@ public:
         using namespace test::jtx;
         static FeatureBitset const all{supported_amendments()};
 
-        static std::array<FeatureBitset, 8> const feats{
+        static std::array<FeatureBitset, 9> const feats{
             all,
+            all - featureWasmtimeEngine,
             all - fixXahauV2,
             all - fixXahauV1 - fixXahauV2,
             all - fixXahauV1 - fixXahauV2 - fixNSDelete,
@@ -15474,7 +15475,8 @@ SETHOOK_TEST(3, false)
 SETHOOK_TEST(4, false)
 SETHOOK_TEST(5, false)
 SETHOOK_TEST(6, false)
-SETHOOK_TEST(7, true)
+SETHOOK_TEST(7, false)
+SETHOOK_TEST(8, true)
 
 BEAST_DEFINE_TESTSUITE_PRIO(SetHook0, app, ripple, 2);
 BEAST_DEFINE_TESTSUITE_PRIO(SetHook1, app, ripple, 2);
@@ -15484,6 +15486,7 @@ BEAST_DEFINE_TESTSUITE_PRIO(SetHook4, app, ripple, 2);
 BEAST_DEFINE_TESTSUITE_PRIO(SetHook5, app, ripple, 2);
 BEAST_DEFINE_TESTSUITE_PRIO(SetHook6, app, ripple, 2);
 BEAST_DEFINE_TESTSUITE_PRIO(SetHook7, app, ripple, 2);
+BEAST_DEFINE_TESTSUITE_PRIO(SetHook8, app, ripple, 2);
 }  // namespace test
 }  // namespace ripple
 #undef M

src/test/jtx/hook.h

@@ -97,7 +97,6 @@ struct StubHookContext
     std::map<uint32_t, uint32_t> guard_map{};
     StubHookResult result = {};
     std::optional<ripple::STObject> emitFailure = std::nullopt;
-    const hook::HookExecutor* module = 0;
 };
 
 // Overload that takes external stateMap to avoid dangling reference

src/test/jtx/impl/hook.cpp

@@ -145,8 +145,7 @@ makeStubHookContext(
                 .executeAgainAsWeak = result.executeAgainAsWeak,
                 .provisionalMeta = result.provisionalMeta,
             },
-        .emitFailure = stubHookContext.emitFailure,
-        .module = nullptr};
+        .emitFailure = stubHookContext.emitFailure};
 }
 
 // Original function - WARNING: stateMap reference may become dangling

src/xrpld/app/hook/applyHook.h

@@ -17,7 +17,6 @@
 #include <queue>
 #include <utility>
 #include <vector>
-#include <wasmedge/wasmedge.h>
 
 namespace hook {
 struct HookContext;
@@ -179,8 +178,6 @@ struct HookResult
         foreignStateGrantCache;  // add found grants here to avoid rechecking
 };
 
-class HookExecutor;
-
 struct SlotEntry
 {
     std::shared_ptr<const ripple::STObject> storage;
@@ -217,7 +214,6 @@ struct HookContext
         emitFailure;  // if this is a callback from a failed
                       // emitted txn then this optional becomes
                       // populated with the SLE
-    const HookExecutor* module = 0;
 
     // Lazy-initialized HookAPI member
     mutable std::unique_ptr<HookAPI> api_;
@@ -272,231 +268,9 @@ gatherHookParameters(
     std::map<std::vector<uint8_t>, std::vector<uint8_t>>& parameters,
     beast::Journal const& j_);
 
-// RH TODO: call destruct for these on rippled shutdown
-#define ADD_HOOK_FUNCTION(F, ctx)                          \
-    {                                                      \
-        WasmEdge_FunctionInstanceContext* hf =             \
-            WasmEdge_FunctionInstanceCreate(               \
-                hook_api::WasmFunctionType##F,             \
-                hook_api::WasmFunction##F,                 \
-                (void*)(&ctx),                             \
-                0);                                        \
-        WasmEdge_ModuleInstanceAddFunction(                \
-            importObj, hook_api::WasmFunctionName##F, hf); \
-    }
-
 #define HR_ACC() hookResult.account << "-" << hookResult.otxnAccount
 #define HC_ACC() hookCtx.result.account << "-" << hookCtx.result.otxnAccount
 
-// create these once at boot and keep them
-static WasmEdge_String exportName = WasmEdge_StringCreateByCString("env");
-static WasmEdge_String tableName = WasmEdge_StringCreateByCString("table");
-static auto* tableType = WasmEdge_TableTypeCreate(
-    WasmEdge_RefType_FuncRef,
-    {.HasMax = true, .Shared = false, .Min = 10, .Max = 20});
-static auto* memType = WasmEdge_MemoryTypeCreate(
-    {.HasMax = true, .Shared = false, .Min = 1, .Max = 1});
-static WasmEdge_String memName = WasmEdge_StringCreateByCString("memory");
-static WasmEdge_String cbakFunctionName =
-    WasmEdge_StringCreateByCString("cbak");
-static WasmEdge_String hookFunctionName =
-    WasmEdge_StringCreateByCString("hook");
-
-// see: lib/system/allocator.cpp
-#define WasmEdge_kPageSize 65536ULL
-
-/**
- * HookExecutor is effectively a two-part function:
- * The first part sets up the Hook Api inside the wasm import, ready for use
- * (this is done during object construction.)
- * The second part is actually executing webassembly instructions
- * this is done during execteWasm function.
- * The instance is single use.
- */
-class HookExecutor
-{
-private:
-    bool spent = false;  // a HookExecutor can only be used once
-
-public:
-    HookContext& hookCtx;
-    WasmEdge_ModuleInstanceContext* importObj;
-
-    class WasmEdgeVM
-    {
-    public:
-        WasmEdge_ConfigureContext* conf = NULL;
-        WasmEdge_VMContext* ctx = NULL;
-
-        WasmEdgeVM()
-        {
-            conf = WasmEdge_ConfigureCreate();
-            if (!conf)
-                return;
-            WasmEdge_ConfigureStatisticsSetInstructionCounting(conf, true);
-            ctx = WasmEdge_VMCreate(conf, NULL);
-        }
-
-        bool
-        sane()
-        {
-            return ctx && conf;
-        }
-
-        ~WasmEdgeVM()
-        {
-            if (conf)
-                WasmEdge_ConfigureDelete(conf);
-            if (ctx)
-                WasmEdge_VMDelete(ctx);
-        }
-    };
-
-    // if an error occured return a string prefixed with `prefix` followed by
-    // the error description
-    static std::optional<std::string>
-    getWasmError(std::string prefix, WasmEdge_Result& res)
-    {
-        if (WasmEdge_ResultOK(res))
-            return {};
-
-        const char* msg = WasmEdge_ResultGetMessage(res);
-        return prefix + ": " + (msg ? msg : "unknown error");
-    }
-
-    /**
-     * Validate that a web assembly blob can be loaded by wasmedge
-     */
-    static std::optional<std::string>
-    validateWasm(const void* wasm, size_t len)
-    {
-        WasmEdgeVM vm;
-
-        if (!vm.sane())
-            return "Could not create WASMEDGE instance";
-
-        WasmEdge_Result res = WasmEdge_VMLoadWasmFromBuffer(
-            vm.ctx, reinterpret_cast<const uint8_t*>(wasm), len);
-
-        if (auto err = getWasmError("VMLoadWasmFromBuffer failed", res); err)
-            return *err;
-
-        res = WasmEdge_VMValidate(vm.ctx);
-
-        if (auto err = getWasmError("VMValidate failed", res); err)
-            return *err;
-
-        return {};
-    }
-
-    /**
-     * Execute web assembly byte code against the constructed Hook Context
-     * Once execution has occured the exector is spent and cannot be used again
-     * and should be destructed Information about the execution is populated
-     * into hookCtx
-     */
-    void
-    executeWasm(
-        const void* wasm,
-        size_t len,
-        bool callback,
-        uint32_t wasmParam,
-        beast::Journal const& j)
-    {
-        // HookExecutor can only execute once
-        XRPL_ASSERT(
-            !spent,
-            "HookExecutor::executeWasm : HookExecutor can only execute once");
-
-        spent = true;
-
-        JLOG(j.trace()) << "HookInfo[" << HC_ACC()
-                        << "]: creating wasm instance";
-
-        WasmEdge_LogOff();
-
-        WasmEdgeVM vm;
-
-        if (!vm.sane())
-        {
-            JLOG(j.warn()) << "HookError[" << HC_ACC()
-                           << "]: Could not create WASMEDGE instance.";
-
-            hookCtx.result.exitType = hook_api::ExitType::WASM_ERROR;
-            return;
-        }
-
-        WasmEdge_Result res =
-            WasmEdge_VMRegisterModuleFromImport(vm.ctx, this->importObj);
-
-        if (auto err = getWasmError("Import phase failed", res); err)
-        {
-            hookCtx.result.exitType = hook_api::ExitType::WASM_ERROR;
-            JLOG(j.trace()) << "HookError[" << HC_ACC() << "]: " << *err;
-            return;
-        }
-
-        WasmEdge_Value params[1] = {WasmEdge_ValueGenI32((int64_t)wasmParam)};
-        WasmEdge_Value returns[1];
-
-        res = WasmEdge_VMRunWasmFromBuffer(
-            vm.ctx,
-            reinterpret_cast<const uint8_t*>(wasm),
-            len,
-            callback ? cbakFunctionName : hookFunctionName,
-            params,
-            1,
-            returns,
-            1);
-
-        if (auto err = getWasmError("WASM VM error", res); err)
-        {
-            JLOG(j.warn()) << "HookError[" << HC_ACC() << "]: " << *err;
-            hookCtx.result.exitType = hook_api::ExitType::WASM_ERROR;
-            return;
-        }
-
-        auto* statsCtx = WasmEdge_VMGetStatisticsContext(vm.ctx);
-        hookCtx.result.instructionCount =
-            WasmEdge_StatisticsGetInstrCount(statsCtx);
-
-        // RH NOTE: stack unwind will clean up WasmEdgeVM
-    }
-
-    HookExecutor(HookContext& ctx)
-        : hookCtx(ctx), importObj(WasmEdge_ModuleInstanceCreate(exportName))
-    {
-        ctx.module = this;
-
-        WasmEdge_LogSetDebugLevel();
-
-#pragma push_macro("HOOK_API_DEFINITION")
-#undef HOOK_API_DEFINITION
-
-#define HOOK_WRAP_PARAMS(...) __VA_ARGS__
-#define HOOK_API_DEFINITION(RETURN_TYPE, FUNCTION_NAME, PARAMS_TUPLE, ...) \
-    ADD_HOOK_FUNCTION(FUNCTION_NAME, ctx);
-
-#include <xrpl/hook/hook_api.macro>
-
-#undef HOOK_API_DEFINITION
-#undef HOOK_WRAP_PARAMS
-#pragma pop_macro("HOOK_API_DEFINITION")
-
-        WasmEdge_TableInstanceContext* hostTable =
-            WasmEdge_TableInstanceCreate(tableType);
-        WasmEdge_ModuleInstanceAddTable(importObj, tableName, hostTable);
-        WasmEdge_MemoryInstanceContext* hostMem =
-            WasmEdge_MemoryInstanceCreate(memType);
-        WasmEdge_ModuleInstanceAddMemory(importObj, memName, hostMem);
-    }
-
-    ~HookExecutor()
-    {
-        WasmEdge_ModuleInstanceDelete(importObj);
-    };
-};
-
 }  // namespace hook
 
 #endif

src/xrpld/app/hook/detail/WasmEdgeEngine.cpp

@@ -0,0 +1,336 @@
+#include <xrpld/app/hook/detail/WasmEdgeEngine.h>
+#include <xrpld/app/hook/applyHook.h>
+#include <xrpl/protocol/Feature.h>
+#include <memory>
+#include <optional>
+#include <string>
+#include <type_traits>
+#include <vector>
+#include <wasmedge/wasmedge.h>
+
+using namespace ripple;
+
+namespace hook {
+
+namespace {
+
+// ── Type-level helpers ──────────────────────────────────────────────────────
+
+template <typename T>
+constexpr WasmValue::Kind
+kindOf()
+{
+    if constexpr (
+        std::is_same_v<T, uint64_t> || std::is_same_v<T, int64_t>)
+        return WasmValue::Kind::I64;
+    return WasmValue::Kind::I32;
+}
+
+template <typename... Ts>
+std::vector<WasmValue::Kind>
+buildKinds()
+{
+    return {kindOf<Ts>()...};
+}
+
+// ── WasmEdge VM RAII ────────────────────────────────────────────────────────
+
+struct WasmEdgeVM
+{
+    WasmEdge_ConfigureContext* conf = nullptr;
+    WasmEdge_VMContext* ctx = nullptr;
+
+    WasmEdgeVM()
+    {
+        conf = WasmEdge_ConfigureCreate();
+        if (!conf)
+            return;
+        WasmEdge_ConfigureStatisticsSetInstructionCounting(conf, true);
+        ctx = WasmEdge_VMCreate(conf, nullptr);
+    }
+
+    bool
+    sane() const
+    {
+        return ctx && conf;
+    }
+
+    ~WasmEdgeVM()
+    {
+        if (ctx)
+            WasmEdge_VMDelete(ctx);
+        if (conf)
+            WasmEdge_ConfigureDelete(conf);
+    }
+};
+
+static std::optional<std::string>
+getWasmError(std::string const& prefix, WasmEdge_Result res)
+{
+    if (WasmEdge_ResultOK(res))
+        return {};
+    const char* msg = WasmEdge_ResultGetMessage(res);
+    return prefix + ": " + (msg ? msg : "unknown error");
+}
+
+// ── Bridge: single WasmEdge callback → HostFunctionFn ──────────────────────
+
+struct BridgeData
+{
+    HostFunctionDecl const* decl;
+    HookContext* ctx;
+};
+
+static WasmEdge_Result
+bridgeFn(
+    void* data_ptr,
+    WasmEdge_CallingFrameContext const* frameCtx,
+    WasmEdge_Value const* in,
+    WasmEdge_Value* out)
+{
+    auto* bridge = static_cast<BridgeData*>(data_ptr);
+
+    auto* memCtx = WasmEdge_CallingFrameGetMemoryInstance(frameCtx, 0);
+    GuestMemory mem{
+        WasmEdge_MemoryInstanceGetPointer(memCtx, 0, 0),
+        WasmEdge_MemoryInstanceGetPageSize(memCtx) * 65536ULL};
+
+    size_t const paramCount = bridge->decl->params.size();
+    std::vector<WasmValue> inVals(paramCount);
+    for (size_t i = 0; i < paramCount; ++i)
+    {
+        if (bridge->decl->params[i] == WasmValue::Kind::I32)
+            inVals[i] = WasmValue::i32((uint32_t)WasmEdge_ValueGetI32(in[i]));
+        else
+            inVals[i] = WasmValue::i64((uint64_t)WasmEdge_ValueGetI64(in[i]));
+    }
+
+    WasmValue outVal;
+    auto status = bridge->decl->fn(
+        bridge->ctx, mem, inVals.data(), paramCount, &outVal, 1);
+
+    if (status == HostCallStatus::Terminate || status == HostCallStatus::Trap)
+        return WasmEdge_Result_Terminate;
+
+    if (bridge->decl->result == WasmValue::Kind::I32)
+        out[0] = WasmEdge_ValueGenI32((int32_t)outVal.asI32());
+    else
+        out[0] = WasmEdge_ValueGenI64((int64_t)outVal.asI64());
+
+    return WasmEdge_Result_Success;
+}
+
+// ── WasmEdgeEngineImpl ──────────────────────────────────────────────────────
+
+class WasmEdgeEngineImpl : public IWasmEngine
+{
+public:
+    std::optional<std::string>
+    validate(void const* wasm, size_t len) override
+    {
+        WasmEdgeVM vm;
+        if (!vm.sane())
+            return "Could not create WASMEDGE instance";
+
+        WasmEdge_Result res = WasmEdge_VMLoadWasmFromBuffer(
+            vm.ctx, reinterpret_cast<uint8_t const*>(wasm), len);
+        if (auto err = getWasmError("VMLoadWasmFromBuffer failed", res))
+            return *err;
+
+        res = WasmEdge_VMValidate(vm.ctx);
+        if (auto err = getWasmError("VMValidate failed", res))
+            return *err;
+
+        return {};
+    }
+
+    ExecutionResult
+    execute(
+        void const* wasm,
+        size_t len,
+        bool isCallback,
+        uint32_t wasmParam,
+        HookContext& ctx,
+        std::vector<HostFunctionDecl> const& imports,
+        ripple::Rules const& rules,
+        beast::Journal const& j) override
+    {
+        static WasmEdge_String exportName =
+            WasmEdge_StringCreateByCString("env");
+        static WasmEdge_String tableName =
+            WasmEdge_StringCreateByCString("table");
+        static auto* tableType = WasmEdge_TableTypeCreate(
+            WasmEdge_RefType_FuncRef,
+            {.HasMax = true, .Shared = false, .Min = 10, .Max = 20});
+        static auto* memType = WasmEdge_MemoryTypeCreate(
+            {.HasMax = true, .Shared = false, .Min = 1, .Max = 1});
+        static WasmEdge_String memName =
+            WasmEdge_StringCreateByCString("memory");
+        static WasmEdge_String cbakFunctionName =
+            WasmEdge_StringCreateByCString("cbak");
+        static WasmEdge_String hookFunctionName =
+            WasmEdge_StringCreateByCString("hook");
+
+        // Bridge data must not reallocate during registration
+        std::vector<BridgeData> bridgeData;
+        bridgeData.reserve(imports.size());
+
+        auto* importObj = WasmEdge_ModuleInstanceCreate(exportName);
+
+        for (auto const& decl : imports)
+        {
+            // featureGate: if non-null and not zero, check rules
+            if (decl.featureGate && !(*decl.featureGate).isZero() &&
+                !rules.enabled(*decl.featureGate))
+                continue;
+
+            bridgeData.push_back({&decl, &ctx});
+
+            std::vector<WasmEdge_ValType> paramTypes;
+            paramTypes.reserve(decl.params.size());
+            for (auto k : decl.params)
+                paramTypes.push_back(
+                    k == WasmValue::Kind::I32 ? WasmEdge_ValType_I32
+                                              : WasmEdge_ValType_I64);
+
+            WasmEdge_ValType resultType =
+                decl.result == WasmValue::Kind::I32 ? WasmEdge_ValType_I32
+                                                    : WasmEdge_ValType_I64;
+
+            auto* fnType = WasmEdge_FunctionTypeCreate(
+                paramTypes.data(), paramTypes.size(), &resultType, 1);
+            auto* fn = WasmEdge_FunctionInstanceCreate(
+                fnType, bridgeFn, &bridgeData.back(), 0);
+            WasmEdge_FunctionTypeDelete(fnType);
+
+            auto nameStr = WasmEdge_StringCreateByCString(decl.name);
+            WasmEdge_ModuleInstanceAddFunction(importObj, nameStr, fn);
+            WasmEdge_StringDelete(nameStr);
+        }
+
+        WasmEdge_ModuleInstanceAddTable(
+            importObj, tableName, WasmEdge_TableInstanceCreate(tableType));
+        WasmEdge_ModuleInstanceAddMemory(
+            importObj, memName, WasmEdge_MemoryInstanceCreate(memType));
+
+        JLOG(j.trace()) << "HookInfo[" << ctx.result.account << "-"
+                        << ctx.result.otxnAccount
+                        << "]: creating wasm instance";
+
+        WasmEdge_LogOff();
+
+        WasmEdgeVM vm;
+        if (!vm.sane())
+        {
+            WasmEdge_ModuleInstanceDelete(importObj);
+            JLOG(j.warn()) << "HookError[" << ctx.result.account << "-"
+                           << ctx.result.otxnAccount
+                           << "]: Could not create WASMEDGE instance.";
+            return {false, 0, "Could not create WASMEDGE instance"};
+        }
+
+        WasmEdge_Result res =
+            WasmEdge_VMRegisterModuleFromImport(vm.ctx, importObj);
+        if (auto err = getWasmError("Import phase failed", res))
+        {
+            JLOG(j.trace()) << "HookError[" << ctx.result.account << "-"
+                            << ctx.result.otxnAccount << "]: " << *err;
+            WasmEdge_ModuleInstanceDelete(importObj);
+            return {false, 0, *err};
+        }
+
+        WasmEdge_Value params[1] = {
+            WasmEdge_ValueGenI32((int64_t)wasmParam)};
+        WasmEdge_Value returns[1];
+
+        res = WasmEdge_VMRunWasmFromBuffer(
+            vm.ctx,
+            reinterpret_cast<uint8_t const*>(wasm),
+            len,
+            isCallback ? cbakFunctionName : hookFunctionName,
+            params,
+            1,
+            returns,
+            1);
+
+        ExecutionResult result;
+        if (auto err = getWasmError("WASM VM error", res))
+        {
+            result.ok = false;
+            result.instructionCount = 0;
+            result.error = *err;
+        }
+        else
+        {
+            result.ok = true;
+            auto* statsCtx = WasmEdge_VMGetStatisticsContext(vm.ctx);
+            result.instructionCount =
+                WasmEdge_StatisticsGetInstrCount(statsCtx);
+        }
+
+        WasmEdge_ModuleInstanceDelete(importObj);
+        return result;
+    }
+};
+
+}  // anonymous namespace
+
+// ── hookHostFunctionDecls registry ─────────────────────────────────────────
+// Expand hook_api.macro with custom HOOK_API_DEFINITION to build the list.
+// Each entry stores the WasmFunction##F pointer and parameter kinds.
+// For featureGate: uint256{} means "always available" (stored as nullptr),
+// named features are stored as their address.
+
+#pragma push_macro("HOOK_API_DEFINITION")
+#pragma push_macro("HOOK_WRAP_PARAMS")
+#undef HOOK_API_DEFINITION
+#undef HOOK_WRAP_PARAMS
+
+// Helper to convert feature gate argument: uint256{} → nullptr,
+// named feature variable → address of that variable.
+// We use an inline helper function template to do this.
+namespace {
+template <typename T>
+static inline uint256 const*
+featureGatePtr(T const& gate)
+{
+    // If gate is zero (default uint256{}), return nullptr (no gate).
+    if (gate.isZero())
+        return nullptr;
+    return &gate;
+}
+}  // namespace
+
+#define HOOK_WRAP_PARAMS(...) __VA_ARGS__
+#define HOOK_API_DEFINITION(R, F, P, GATE)              \
+    {                                                    \
+        #F,                                              \
+        &hook_api::WasmFunction##F,                      \
+        buildKinds<HOOK_WRAP_PARAMS P>(),               \
+        kindOf<R>(),                                     \
+        featureGatePtr(GATE),                            \
+    },
+
+std::vector<HostFunctionDecl> const&
+hookHostFunctionDecls()
+{
+    static std::vector<HostFunctionDecl> const decls = {
+#include <xrpl/hook/hook_api.macro>
+    };
+    return decls;
+}
+
+#undef HOOK_API_DEFINITION
+#undef HOOK_WRAP_PARAMS
+#pragma pop_macro("HOOK_WRAP_PARAMS")
+#pragma pop_macro("HOOK_API_DEFINITION")
+
+// ── Factory ─────────────────────────────────────────────────────────────────
+
+std::unique_ptr<IWasmEngine>
+makeWasmEdgeEngine()
+{
+    return std::make_unique<WasmEdgeEngineImpl>();
+}
+
+}  // namespace hook

src/xrpld/app/hook/detail/WasmEdgeEngine.h

@@ -0,0 +1,14 @@
+#ifndef RIPPLE_APP_HOOK_DETAIL_WASMEDGEENGINE_H_INCLUDED
+#define RIPPLE_APP_HOOK_DETAIL_WASMEDGEENGINE_H_INCLUDED
+
+#include <xrpld/app/hook/detail/WasmEngine.h>
+#include <memory>
+
+namespace hook {
+
+std::unique_ptr<IWasmEngine>
+makeWasmEdgeEngine();
+
+}  // namespace hook
+
+#endif  // RIPPLE_APP_HOOK_DETAIL_WASMEDGEENGINE_H_INCLUDED

src/xrpld/app/hook/detail/WasmEngine.h

@@ -0,0 +1,51 @@
+#ifndef RIPPLE_APP_HOOK_DETAIL_WASMENGINE_H_INCLUDED
+#define RIPPLE_APP_HOOK_DETAIL_WASMENGINE_H_INCLUDED
+
+#include <xrpl/hook/WasmTypes.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/protocol/Rules.h>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace hook {
+
+/// Initial fuel budget per Hook execution (consensus-fixed; changing
+/// this value requires a separate Amendment).
+constexpr uint64_t kWasmtimeInitialFuel = 10'000'000'000ULL;
+
+struct HookContext;
+
+struct ExecutionResult
+{
+    bool ok;
+    uint64_t instructionCount;
+    std::optional<std::string> error;
+};
+
+class IWasmEngine
+{
+public:
+    virtual ~IWasmEngine() = default;
+
+    virtual std::optional<std::string>
+    validate(void const* wasm, size_t len) = 0;
+
+    virtual ExecutionResult
+    execute(
+        void const* wasm,
+        size_t len,
+        bool isCallback,
+        uint32_t wasmParam,
+        HookContext& ctx,
+        std::vector<HostFunctionDecl> const& imports,
+        ripple::Rules const& rules,
+        beast::Journal const& j) = 0;
+};
+
+std::vector<HostFunctionDecl> const&
+hookHostFunctionDecls();
+
+}  // namespace hook
+
+#endif  // RIPPLE_APP_HOOK_DETAIL_WASMENGINE_H_INCLUDED

src/xrpld/app/hook/detail/WasmtimeEngine.cpp

@@ -0,0 +1,819 @@
+// WasmtimeEngine.cpp — Wasmtime backend for the IWasmEngine abstraction.
+//
+// WHY THIS FILE IS LARGER THAN WasmEdgeEngine.cpp
+// ─────────────────────────────────────────────────
+// WasmEdge provides WasmEdge_CallingFrameGetMemoryInstance(frame, index),
+// which retrieves a module's linear memory by index regardless of whether it
+// is exported.  Wasmtime has no equivalent: the only way to access memory
+// from inside a host-function callback is wasmtime_caller_export_get(), which
+// only works for *exported* memories.
+//
+// Hook WASM modules compiled by wasmcc define their own linear memory
+// (WebAssembly section 5) but do not export it.  Without an export the memory
+// pointer is unavailable inside host callbacks, causing every Hook API call
+// that touches guest memory to see mem.base == nullptr and return
+// INTERNAL_ERROR, ultimately crashing the execution.
+//
+// The ensureMemoryExported() function (≈200 lines) works around this by
+// scanning the binary before instantiation and injecting a "memory" export
+// entry into section 7 when the module owns but does not export its memory.
+// The patched binary is semantically identical to the original.
+//
+// A potential alternative — storing the wasmtime_memory_t handle directly in
+// BridgeData — requires knowing at setup time which memory the module will
+// actually use (its own vs. an import from "env"), which itself requires
+// binary inspection.  The export-injection approach is therefore the simplest
+// correct solution.
+#include <xrpld/app/hook/detail/WasmtimeEngine.h>
+#include <xrpld/app/hook/detail/WasmEngine.h>
+#include <xrpld/app/hook/applyHook.h>
+#include <xrpl/protocol/Feature.h>
+#include <cstring>
+#include <memory>
+#include <optional>
+#include <string>
+#include <type_traits>
+#include <vector>
+// wasmtime.h must come LAST to avoid int128_t pollution
+#include <wasmtime.h>
+
+using namespace ripple;
+
+namespace hook {
+
+namespace {
+
+// ── Type-level helpers ──────────────────────────────────────────────────────
+
+template <typename T>
+constexpr WasmValue::Kind
+kindOf()
+{
+    if constexpr (
+        std::is_same_v<T, uint64_t> || std::is_same_v<T, int64_t>)
+        return WasmValue::Kind::I64;
+    return WasmValue::Kind::I32;
+}
+
+template <typename... Ts>
+std::vector<WasmValue::Kind>
+buildKinds()
+{
+    return {kindOf<Ts>()...};
+}
+
+// ── Error helpers ────────────────────────────────────────────────────────────
+
+static std::optional<std::string>
+wasmtimeError(wasmtime_error_t* err)
+{
+    if (!err)
+        return {};
+    wasm_byte_vec_t msg;
+    wasmtime_error_message(err, &msg);
+    std::string s(msg.data, msg.size);
+    wasm_byte_vec_delete(&msg);
+    wasmtime_error_delete(err);
+    return s;
+}
+
+static std::optional<std::string>
+wasmtimeTrap(wasm_trap_t* trap)
+{
+    if (!trap)
+        return {};
+    wasm_byte_vec_t msg;
+    wasm_trap_message(trap, &msg);
+    std::string s(msg.data, msg.size);
+    wasm_byte_vec_delete(&msg);
+    wasm_trap_delete(trap);
+    return s;
+}
+
+// ── Process-global engine (thread-safe; created once) ────────────────────────
+
+static wasm_engine_t*
+getGlobalEngine()
+{
+    static wasm_engine_t* gEngine = []() -> wasm_engine_t* {
+        wasm_config_t* cfg = wasm_config_new();
+        if (!cfg)
+            return nullptr;
+
+        // Consensus-fixed configuration – never change without an Amendment
+        wasmtime_config_consume_fuel_set(cfg, true);
+        wasmtime_config_wasm_simd_set(cfg, true);
+        wasmtime_config_wasm_relaxed_simd_set(cfg, false);
+        wasmtime_config_wasm_reference_types_set(cfg, true);
+        wasmtime_config_wasm_bulk_memory_set(cfg, true);
+        wasmtime_config_wasm_multi_value_set(cfg, false);
+        wasmtime_config_cranelift_nan_canonicalization_set(cfg, true);
+
+        // wasm_threads is behind a feature flag; only set if available.
+        // The compile-time feature guard in config.h controls whether
+        // wasmtime_config_wasm_threads_set exists.
+#ifdef WASMTIME_FEATURE_THREADS
+        wasmtime_config_wasm_threads_set(cfg, false);
+#endif
+
+        // wasm_engine_new_with_config takes ownership of cfg
+        return wasm_engine_new_with_config(cfg);
+    }();
+    return gEngine;
+}
+
+// ── WASM binary normalisation ─────────────────────────────────────────────────
+//
+// Hook WASM modules typically have their own memory (WebAssembly Section 5)
+// but do NOT export it.  Wasmtime's wasmtime_caller_export_get() only works
+// for *exported* memories, so without an export the memory pointer is
+// unavailable inside host callbacks.
+//
+// This function inspects the binary and, when the module owns a memory but
+// does not already export it as "memory", injects a new export entry for
+// memory index 0.  The resulting binary is semantically identical to the
+// original but now exposes its memory to the host.
+//
+// Modules that already export "memory" (or that import memory from "env") are
+// returned unchanged.
+
+// LEB128 helpers (unsigned, forward-only)
+static uint32_t
+readUleb128(uint8_t const* p, size_t& pos, size_t limit)
+{
+    uint32_t result = 0;
+    uint32_t shift = 0;
+    while (pos < limit)
+    {
+        uint8_t b = p[pos++];
+        result |= (uint32_t)(b & 0x7F) << shift;
+        if (!(b & 0x80))
+            break;
+        shift += 7;
+    }
+    return result;
+}
+
+// Encode a value as unsigned LEB128 (appends to out)
+static void
+writeUleb128(std::vector<uint8_t>& out, uint32_t val)
+{
+    do
+    {
+        uint8_t b = val & 0x7F;
+        val >>= 7;
+        if (val)
+            b |= 0x80;
+        out.push_back(b);
+    } while (val);
+}
+
+// Ensure the WASM binary exports its first memory as "memory".
+// Returns the original bytes unchanged if no patching is needed,
+// otherwise returns a patched copy.
+static std::vector<uint8_t>
+ensureMemoryExported(void const* wasm, size_t len)
+{
+    uint8_t const* p = reinterpret_cast<uint8_t const*>(wasm);
+
+    // Validate magic + version.
+    // NOTE: the magic bytes are  0x00 0x61 0x73 0x6D 0x01 0x00 0x00 0x00
+    // Written as a string literal, "\x00asm…" is ambiguous because \x hex
+    // escapes are greedy: "\x00a" == "\x0a" (newline).  Use a byte array.
+    static constexpr uint8_t kWasmMagic[8] = {
+        0x00, 0x61, 0x73, 0x6D,  // \0asm
+        0x01, 0x00, 0x00, 0x00   // version 1
+    };
+    if (len < 8 || std::memcmp(p, kWasmMagic, 8) != 0)
+        return {p, p + len};  // not a valid WASM binary, return as-is
+
+    bool hasOwnMemory = false;
+    bool exportsMemory = false;
+
+    // offset to memory section (for the insert point) and export section
+    size_t exportSectionOffset = 0;   // byte offset of existing export section
+    size_t exportSectionPayloadOff = 0; // offset of payload start
+    size_t exportSectionPayloadLen = 0; // payload length
+
+    size_t pos = 8;
+    while (pos + 1 < len)
+    {
+        uint8_t sectionId = p[pos++];
+        size_t secLenPos = pos;
+        uint32_t secLen = readUleb128(p, pos, len);
+        size_t payloadStart = pos;
+
+        if (sectionId == 5)  // memory section
+        {
+            // At least one memory entry means the module owns a memory
+            size_t tmp = pos;
+            uint32_t count = readUleb128(p, tmp, len);
+            if (count > 0)
+                hasOwnMemory = true;
+        }
+        else if (sectionId == 7)  // export section
+        {
+            exportSectionOffset = secLenPos - 1;  // start of section id byte
+            exportSectionPayloadOff = payloadStart;
+            exportSectionPayloadLen = secLen;
+
+            size_t tmp = pos;
+            uint32_t count = readUleb128(p, tmp, len);
+            for (uint32_t i = 0; i < count; ++i)
+            {
+                uint32_t nameLen = readUleb128(p, tmp, len);
+                if (tmp + nameLen > len)
+                    break;
+                bool isMemoryName = (nameLen == 6 &&
+                    std::memcmp(p + tmp, "memory", 6) == 0);
+                tmp += nameLen;
+                if (tmp >= len)
+                    break;
+                uint8_t kind = p[tmp++];     // export kind byte
+                readUleb128(p, tmp, len);    // export index
+                if (isMemoryName && kind == 0x02)  // kind 2 == memory
+                {
+                    exportsMemory = true;
+                    break;
+                }
+            }
+        }
+
+        pos = payloadStart + secLen;
+    }
+
+    // No patching needed if:
+    // - module does not own a memory (it may import one; caller_export_get works)
+    // - module already exports its memory
+    if (!hasOwnMemory || exportsMemory)
+        return {p, p + len};
+
+    // Build a new memory export entry:  \x06 m e m o r y \x02 \x00
+    // (name_len=6, "memory", kind=2 (memory), index=0)
+    std::vector<uint8_t> newExportEntry;
+    writeUleb128(newExportEntry, 6);  // name length
+    for (char c : std::string("memory"))
+        newExportEntry.push_back((uint8_t)c);
+    newExportEntry.push_back(0x02);   // export kind: memory
+    writeUleb128(newExportEntry, 0);  // memory index 0
+
+    if (exportSectionOffset == 0)
+    {
+        // No export section exists at all – create one from scratch.
+        // New section: id=7, payload = count(1) + entry
+        std::vector<uint8_t> newSection;
+        newSection.push_back(0x07);  // export section id
+        std::vector<uint8_t> payload;
+        writeUleb128(payload, 1);  // 1 export
+        payload.insert(payload.end(), newExportEntry.begin(), newExportEntry.end());
+        writeUleb128(newSection, (uint32_t)payload.size());
+        newSection.insert(newSection.end(), payload.begin(), payload.end());
+
+        // Insert the new section before the code section (id=10) or at end.
+        // For correctness we append after the last known section.
+        std::vector<uint8_t> result(p, p + len);
+        result.insert(result.end(), newSection.begin(), newSection.end());
+        return result;
+    }
+    else
+    {
+        // Patch the existing export section: increment count, append entry.
+
+        // Read existing export count (as a LEB128)
+        size_t countPos = exportSectionPayloadOff;
+        uint32_t existingCount = readUleb128(p, countPos, len);
+        uint32_t newCount = existingCount + 1;
+        std::vector<uint8_t> newCountBytes;
+        writeUleb128(newCountBytes, newCount);
+
+        // New payload = new count + existing entries (skip old count bytes) + new entry
+        std::vector<uint8_t> newPayload;
+        newPayload.insert(newPayload.end(), newCountBytes.begin(), newCountBytes.end());
+        // Existing entries start at countPos, end at exportSectionPayloadOff + exportSectionPayloadLen
+        size_t entriesStart = countPos;
+        size_t entriesEnd = exportSectionPayloadOff + exportSectionPayloadLen;
+        if (entriesEnd > len)
+            entriesEnd = len;
+        newPayload.insert(newPayload.end(), p + entriesStart, p + entriesEnd);
+        newPayload.insert(newPayload.end(), newExportEntry.begin(), newExportEntry.end());
+
+        // Encode new section length as LEB128
+        std::vector<uint8_t> newSecLen;
+        writeUleb128(newSecLen, (uint32_t)newPayload.size());
+
+        // Reconstruct the full binary:
+        //   bytes before export section + id(0x07) + new_len + new_payload + bytes after
+        std::vector<uint8_t> result;
+        result.reserve(len + newExportEntry.size() + 4);
+        // Part 1: everything before the export section
+        result.insert(result.end(), p, p + exportSectionOffset);
+        // Part 2: section id
+        result.push_back(0x07);
+        // Part 3: new length
+        result.insert(result.end(), newSecLen.begin(), newSecLen.end());
+        // Part 4: new payload
+        result.insert(result.end(), newPayload.begin(), newPayload.end());
+        // Part 5: everything after the export section
+        size_t afterExport = exportSectionPayloadOff + exportSectionPayloadLen;
+        if (afterExport < len)
+            result.insert(result.end(), p + afterExport, p + len);
+        return result;
+    }
+}
+
+// ── Per-execution state shared between the host callback and caller ──────────
+
+struct ExecState
+{
+    bool terminated = false;
+};
+
+struct BridgeData
+{
+    HostFunctionDecl const* decl;
+    HookContext* ctx;
+    ExecState* state;
+};
+
+// ── wasm_functype_t builder helper ───────────────────────────────────────────
+
+static wasm_functype_t*
+buildFuncType(
+    std::vector<WasmValue::Kind> const& params,
+    WasmValue::Kind result)
+{
+    wasm_valtype_vec_t paramVec;
+    wasm_valtype_vec_t resultVec;
+
+    if (params.empty())
+    {
+        wasm_valtype_vec_new_empty(&paramVec);
+    }
+    else
+    {
+        std::vector<wasm_valtype_t*> ptrs;
+        ptrs.reserve(params.size());
+        for (auto k : params)
+            ptrs.push_back(
+                wasm_valtype_new(k == WasmValue::Kind::I32 ? WASM_I32 : WASM_I64));
+        wasm_valtype_vec_new(&paramVec, ptrs.size(), ptrs.data());
+    }
+
+    {
+        wasm_valtype_t* rs[1] = {
+            wasm_valtype_new(result == WasmValue::Kind::I32 ? WASM_I32 : WASM_I64)};
+        wasm_valtype_vec_new(&resultVec, 1, rs);
+    }
+
+    return wasm_functype_new(&paramVec, &resultVec);
+}
+
+// ── Bridge callback ──────────────────────────────────────────────────────────
+
+static wasm_trap_t*
+bridgeFn(
+    void* envPtr,
+    wasmtime_caller_t* caller,
+    wasmtime_val_t const* args,
+    size_t nargs,
+    wasmtime_val_t* results,
+    size_t nresults)
+{
+    auto* bridge = static_cast<BridgeData*>(envPtr);
+
+    // The module's memory is always exported as "memory" after
+    // ensureMemoryExported() normalises the binary.  For modules that import
+    // memory from "env" (rare) the imported memory is also accessible via
+    // the same export path once the linker resolves it.
+    wasmtime_extern_t memExtern;
+    GuestMemory mem{nullptr, 0};
+    if (wasmtime_caller_export_get(
+            caller, "memory", 6 /* strlen("memory") */, &memExtern))
+    {
+        if (memExtern.kind == WASMTIME_EXTERN_MEMORY)
+        {
+            wasmtime_context_t* ctx = wasmtime_caller_context(caller);
+            mem.base = wasmtime_memory_data(ctx, &memExtern.of.memory);
+            mem.size = wasmtime_memory_data_size(ctx, &memExtern.of.memory);
+        }
+    }
+
+    // Convert incoming wasmtime_val_t args to WasmValue
+    size_t const paramCount = bridge->decl->params.size();
+    std::vector<WasmValue> inVals(paramCount);
+    for (size_t i = 0; i < paramCount && i < nargs; ++i)
+    {
+        if (bridge->decl->params[i] == WasmValue::Kind::I32)
+            inVals[i] = WasmValue::i32((uint32_t)args[i].of.i32);
+        else
+            inVals[i] = WasmValue::i64((uint64_t)args[i].of.i64);
+    }
+
+    WasmValue outVal;
+    auto status =
+        bridge->decl->fn(bridge->ctx, mem, inVals.data(), paramCount, &outVal, 1);
+
+    if (status == HostCallStatus::Terminate || status == HostCallStatus::Trap)
+    {
+        // Signal termination to the outer caller
+        bridge->state->terminated = true;
+        // Return a trap to unwind the WASM stack
+        return wasmtime_trap_new("hook terminated", 15);
+    }
+
+    // Write result
+    if (nresults > 0)
+    {
+        if (bridge->decl->result == WasmValue::Kind::I32)
+        {
+            results[0].kind = WASMTIME_I32;
+            results[0].of.i32 = (int32_t)outVal.asI32();
+        }
+        else
+        {
+            results[0].kind = WASMTIME_I64;
+            results[0].of.i64 = (int64_t)outVal.asI64();
+        }
+    }
+
+    return nullptr;  // success
+}
+
+// ── WasmtimeEngineImpl ───────────────────────────────────────────────────────
+
+class WasmtimeEngineImpl : public IWasmEngine
+{
+public:
+    std::optional<std::string>
+    validate(void const* wasm, size_t len) override
+    {
+        wasm_engine_t* engine = getGlobalEngine();
+        if (!engine)
+            return "Could not create Wasmtime engine";
+
+        // Normalise the binary so validation sees the same form as execution.
+        auto patched = ensureMemoryExported(wasm, len);
+
+        wasmtime_module_t* mod = nullptr;
+        wasmtime_error_t* err = wasmtime_module_new(
+            engine,
+            patched.data(),
+            patched.size(),
+            &mod);
+
+        if (auto msg = wasmtimeError(err))
+            return "Wasmtime validate failed: " + *msg;
+
+        wasmtime_module_delete(mod);
+        return {};
+    }
+
+    ExecutionResult
+    execute(
+        void const* wasm,
+        size_t len,
+        bool isCallback,
+        uint32_t wasmParam,
+        HookContext& ctx,
+        std::vector<HostFunctionDecl> const& imports,
+        ripple::Rules const& rules,
+        beast::Journal const& j) override
+    {
+        wasm_engine_t* engine = getGlobalEngine();
+        if (!engine)
+            return {false, 0, "Could not obtain Wasmtime engine"};
+
+        // Ensure the module's memory is exported so that bridgeFn can access it
+        // via wasmtime_caller_export_get("memory").  Hook modules often define
+        // their own memory section without a corresponding export entry.
+        auto patched = ensureMemoryExported(wasm, len);
+
+        // ── Compile module ─────────────────────────────────────────────────
+        wasmtime_module_t* mod = nullptr;
+        {
+            wasmtime_error_t* err = wasmtime_module_new(
+                engine,
+                patched.data(),
+                patched.size(),
+                &mod);
+            if (auto msg = wasmtimeError(err))
+                return {false, 0, "Wasmtime compile failed: " + *msg};
+        }
+
+        // ── Create store + context ─────────────────────────────────────────
+        wasmtime_store_t* store = wasmtime_store_new(engine, nullptr, nullptr);
+        if (!store)
+        {
+            wasmtime_module_delete(mod);
+            return {false, 0, "Could not create Wasmtime store"};
+        }
+        wasmtime_context_t* storeCtx = wasmtime_store_context(store);
+
+        // Set initial fuel (consensus-fixed)
+        {
+            wasmtime_error_t* err =
+                wasmtime_context_set_fuel(storeCtx, kWasmtimeInitialFuel);
+            if (auto msg = wasmtimeError(err))
+            {
+                wasmtime_store_delete(store);
+                wasmtime_module_delete(mod);
+                return {false, 0, "Could not set fuel: " + *msg};
+            }
+        }
+
+        // ── Per-execution termination state ───────────────────────────────
+        ExecState execState;
+
+        // ── Build bridge data (must stay stable in memory) ─────────────────
+        std::vector<BridgeData> bridgeData;
+        bridgeData.reserve(imports.size());
+
+        // ── Create linker ──────────────────────────────────────────────────
+        wasmtime_linker_t* linker = wasmtime_linker_new(engine);
+
+        static const char kEnvModule[] = "env";
+        static const size_t kEnvModuleLen = 3;  // strlen("env")
+
+        for (auto const& decl : imports)
+        {
+            // Feature gate: skip if this API is behind a disabled Amendment
+            if (decl.featureGate && !(*decl.featureGate).isZero() &&
+                !rules.enabled(*decl.featureGate))
+                continue;
+
+            bridgeData.push_back({&decl, &ctx, &execState});
+
+            wasm_functype_t* ft = buildFuncType(decl.params, decl.result);
+
+            // NOTE: wasmtime_linker_define_func takes a raw `data` pointer
+            // but does NOT call the finalizer per-call (only when the linker
+            // is deleted or shadowed). Since bridgeData is alive for the
+            // duration of the execution, this is safe.
+            wasmtime_error_t* err = wasmtime_linker_define_func(
+                linker,
+                kEnvModule,
+                kEnvModuleLen,
+                decl.name,
+                std::strlen(decl.name),
+                ft,
+                bridgeFn,
+                &bridgeData.back(),
+                nullptr);
+
+            wasm_functype_delete(ft);
+
+            if (auto msg = wasmtimeError(err))
+            {
+                wasmtime_linker_delete(linker);
+                wasmtime_store_delete(store);
+                wasmtime_module_delete(mod);
+                return {false, 0, "Linker define_func failed: " + *msg};
+            }
+        }
+
+        // ── Define the "table" import (funcref, min=10, max=20) ────────────
+        {
+            wasm_limits_t tableLimits = {10, 20};
+            wasm_tabletype_t* tt =
+                wasm_tabletype_new(wasm_valtype_new(WASM_FUNCREF), &tableLimits);
+
+            wasmtime_table_t tbl;
+            wasmtime_val_t initVal;
+            initVal.kind = WASMTIME_FUNCREF;
+            wasmtime_funcref_set_null(&initVal.of.funcref);
+
+            wasmtime_error_t* err =
+                wasmtime_table_new(storeCtx, tt, &initVal, &tbl);
+            wasm_tabletype_delete(tt);
+
+            if (auto msg = wasmtimeError(err))
+            {
+                wasmtime_linker_delete(linker);
+                wasmtime_store_delete(store);
+                wasmtime_module_delete(mod);
+                return {false, 0, "Table creation failed: " + *msg};
+            }
+
+            wasmtime_extern_t ext;
+            ext.kind = WASMTIME_EXTERN_TABLE;
+            ext.of.table = tbl;
+
+            err = wasmtime_linker_define(
+                linker,
+                storeCtx,
+                kEnvModule,
+                kEnvModuleLen,
+                "table",
+                5,
+                &ext);
+
+            if (auto msg = wasmtimeError(err))
+            {
+                wasmtime_linker_delete(linker);
+                wasmtime_store_delete(store);
+                wasmtime_module_delete(mod);
+                return {false, 0, "Linker define table failed: " + *msg};
+            }
+        }
+
+        // ── Define the "memory" import (min=1, max=1 pages) ───────────────
+        // This is provided for modules that import their memory from "env".
+        // Modules with own memory sections (Section 5) ignore this definition
+        // and use their own memory instead (which ensureMemoryExported() will
+        // have made accessible via a "memory" export).
+        {
+            wasm_memorytype_t* mt;
+            {
+                wasmtime_error_t* err = wasmtime_memorytype_new(
+                    1,      // min pages
+                    true,   // max_present
+                    1,      // max pages
+                    false,  // is_64
+                    false,  // shared
+                    0,      // page_size_log2 (0 = default 64KiB)
+                    &mt);
+                if (auto msg = wasmtimeError(err))
+                {
+                    wasmtime_linker_delete(linker);
+                    wasmtime_store_delete(store);
+                    wasmtime_module_delete(mod);
+                    return {false, 0, "Memory type creation failed: " + *msg};
+                }
+            }
+
+            wasmtime_memory_t mem;
+            wasmtime_error_t* err = wasmtime_memory_new(storeCtx, mt, &mem);
+            wasm_memorytype_delete(mt);
+
+            if (auto msg = wasmtimeError(err))
+            {
+                wasmtime_linker_delete(linker);
+                wasmtime_store_delete(store);
+                wasmtime_module_delete(mod);
+                return {false, 0, "Memory creation failed: " + *msg};
+            }
+
+            wasmtime_extern_t ext;
+            ext.kind = WASMTIME_EXTERN_MEMORY;
+            ext.of.memory = mem;
+
+            err = wasmtime_linker_define(
+                linker,
+                storeCtx,
+                kEnvModule,
+                kEnvModuleLen,
+                "memory",
+                6,
+                &ext);
+
+            if (auto msg = wasmtimeError(err))
+            {
+                wasmtime_linker_delete(linker);
+                wasmtime_store_delete(store);
+                wasmtime_module_delete(mod);
+                return {false, 0, "Linker define memory failed: " + *msg};
+            }
+        }
+
+        JLOG(j.trace()) << "HookInfo[" << ctx.result.account << "-"
+                        << ctx.result.otxnAccount
+                        << "]: creating wasmtime instance";
+
+        // ── Instantiate ───────────────────────────────────────────────────
+        wasmtime_instance_t instance;
+        {
+            wasm_trap_t* trap = nullptr;
+            wasmtime_error_t* err = wasmtime_linker_instantiate(
+                linker, storeCtx, mod, &instance, &trap);
+
+            if (auto msg = wasmtimeError(err))
+            {
+                wasmtime_linker_delete(linker);
+                wasmtime_store_delete(store);
+                wasmtime_module_delete(mod);
+                return {false, 0, "Instantiation error: " + *msg};
+            }
+            if (trap)
+            {
+                auto msg = wasmtimeTrap(trap);
+                wasmtime_linker_delete(linker);
+                wasmtime_store_delete(store);
+                wasmtime_module_delete(mod);
+                return {
+                    false,
+                    0,
+                    "Instantiation trap: " + (msg ? *msg : "unknown")};
+            }
+        }
+
+        // ── Look up "hook" or "cbak" export ───────────────────────────────
+        const char* funcName = isCallback ? "cbak" : "hook";
+        size_t funcNameLen = isCallback ? 4 : 4;
+
+        wasmtime_extern_t funcExtern;
+        if (!wasmtime_instance_export_get(
+                storeCtx,
+                &instance,
+                funcName,
+                funcNameLen,
+                &funcExtern) ||
+            funcExtern.kind != WASMTIME_EXTERN_FUNC)
+        {
+            wasmtime_linker_delete(linker);
+            wasmtime_store_delete(store);
+            wasmtime_module_delete(mod);
+            return {
+                false,
+                0,
+                std::string("WASM export '") + funcName + "' not found"};
+        }
+
+        // ── Call hook/cbak with wasmParam ──────────────────────────────────
+        wasmtime_val_t callArgs[1];
+        callArgs[0].kind = WASMTIME_I32;
+        callArgs[0].of.i32 = (int32_t)wasmParam;
+
+        wasmtime_val_t callResults[1];
+        wasm_trap_t* callTrap = nullptr;
+
+        wasmtime_error_t* callErr = wasmtime_func_call(
+            storeCtx,
+            &funcExtern.of.func,
+            callArgs,
+            1,
+            callResults,
+            1,
+            &callTrap);
+
+        // Capture fuel consumed before cleaning up
+        uint64_t fuelRemaining = 0;
+        wasmtime_context_get_fuel(storeCtx, &fuelRemaining);
+        uint64_t instructionCount = 0;
+        if (kWasmtimeInitialFuel >= fuelRemaining)
+            instructionCount = kWasmtimeInitialFuel - fuelRemaining;
+
+        wasmtime_linker_delete(linker);
+        wasmtime_store_delete(store);
+        wasmtime_module_delete(mod);
+
+        // ── Interpret result ───────────────────────────────────────────────
+        //
+        // When a host callback returns a wasm_trap_t* to signal accept() or
+        // rollback(), Wasmtime propagates that as a wasmtime_error_t (with the
+        // trap embedded as the cause) rather than via the wasm_trap_t** output.
+        // We therefore check execState.terminated FIRST — before inspecting
+        // callErr or callTrap — so that clean hook terminations (accept/rollback)
+        // are always reported as ok=true regardless of which output pointer
+        // Wasmtime chose to use.
+
+        if (execState.terminated)
+        {
+            // Hook called accept() or rollback(): clean termination.
+            // Free any error/trap resources Wasmtime may have allocated.
+            if (callErr)
+                wasmtime_error_delete(callErr);
+            if (callTrap)
+                wasm_trap_delete(callTrap);
+            return {true, instructionCount, {}};
+        }
+
+        // Programmer error (wrong arg types, mismatched store, etc.)
+        if (callErr)
+        {
+            auto msg = wasmtimeError(callErr);
+            return {false, instructionCount, "WASM call error: " + (msg ? *msg : "")};
+        }
+
+        if (callTrap)
+        {
+            // Check for out-of-fuel trap
+            wasmtime_trap_code_t code = 0;
+            if (wasmtime_trap_code(callTrap, &code) &&
+                code == WASMTIME_TRAP_CODE_OUT_OF_FUEL)
+            {
+                wasm_trap_delete(callTrap);
+                return {false, instructionCount, "WASM out of fuel"};
+            }
+
+            auto msg = wasmtimeTrap(callTrap);
+            return {
+                false,
+                instructionCount,
+                "WASM trap: " + (msg ? *msg : "unknown trap")};
+        }
+
+        return {true, instructionCount, {}};
+    }
+};
+
+}  // anonymous namespace
+
+// ── Factory ──────────────────────────────────────────────────────────────────
+
+std::unique_ptr<IWasmEngine>
+makeWasmtimeEngine()
+{
+    return std::make_unique<WasmtimeEngineImpl>();
+}
+
+}  // namespace hook

src/xrpld/app/hook/detail/WasmtimeEngine.h

@@ -0,0 +1,14 @@
+#ifndef RIPPLE_APP_HOOK_DETAIL_WASMTIMEENGINE_H_INCLUDED
+#define RIPPLE_APP_HOOK_DETAIL_WASMTIMEENGINE_H_INCLUDED
+
+#include <xrpld/app/hook/detail/WasmEngine.h>
+#include <memory>
+
+namespace hook {
+
+std::unique_ptr<IWasmEngine>
+makeWasmtimeEngine();
+
+}  // namespace hook
+
+#endif  // RIPPLE_APP_HOOK_DETAIL_WASMTIMEENGINE_H_INCLUDED

src/xrpld/app/hook/detail/applyHook.cpp

@@ -19,7 +19,9 @@
 #include <string>
 #include <utility>
 #include <vector>
-#include <wasmedge/wasmedge.h>
+#include <xrpld/app/hook/detail/WasmEngine.h>
+#include <xrpld/app/hook/detail/WasmEdgeEngine.h>
+#include <xrpld/app/hook/detail/WasmtimeEngine.h>
 
 using namespace ripple;
 
@@ -1082,10 +1084,25 @@ hook::apply(
 
     auto const& j = applyCtx.app.journal("View");
 
-    HookExecutor executor{hookCtx};
-
-    executor.executeWasm(
-        wasm.data(), (size_t)wasm.size(), isCallback, wasmParam, j);
+    auto engine = applyCtx.view().rules().enabled(featureWasmtimeEngine)
+        ? makeWasmtimeEngine()
+        : makeWasmEdgeEngine();
+    auto const engineResult = engine->execute(
+        wasm.data(),
+        (size_t)wasm.size(),
+        isCallback,
+        wasmParam,
+        hookCtx,
+        hookHostFunctionDecls(),
+        applyCtx.view().rules(),
+        j);
+    hookCtx.result.instructionCount = engineResult.instructionCount;
+    if (!engineResult.ok)
+    {
+        hookCtx.result.exitType = hook_api::ExitType::WASM_ERROR;
+        JLOG(j.warn()) << "HookError[" << HC_ACC() << "]: "
+                       << engineResult.error.value_or("unknown");
+    }
 
     JLOG(j.trace()) << "HookInfo[" << HC_ACC() << "]: "
                     << (hookCtx.result.exitType == hook_api::ExitType::ROLLBACK
@@ -1256,7 +1273,7 @@ DEFINE_HOOK_FUNCTION(
 {
     return state_foreign_set(
         hookCtx,
-        frameCtx,
+        mem,
         read_ptr,
         read_len,
         kread_ptr,
@@ -1634,7 +1651,7 @@ DEFINE_HOOK_FUNCTION(
 {
     return state_foreign(
         hookCtx,
-        frameCtx,
+        mem,
         write_ptr,
         write_len,
         kread_ptr,
@@ -3196,7 +3213,7 @@ DEFINE_HOOK_FUNCTION(
     // proxy only no setup or teardown
     auto ret = sto_emplace(
         hookCtx,
-        frameCtx,
+        mem,
         write_ptr,
         write_len,
         read_ptr,

src/xrpld/app/tx/detail/Change.cpp

@@ -18,6 +18,8 @@
 //==============================================================================
 
 #include <xrpld/app/hook/applyHook.h>
+#include <xrpld/app/hook/detail/WasmEdgeEngine.h>
+#include <xrpld/app/hook/detail/WasmtimeEngine.h>
 #include <xrpld/app/ledger/Ledger.h>
 #include <xrpld/app/main/Application.h>
 #include <xrpld/app/misc/AmendmentTable.h>
@@ -637,8 +639,11 @@ Change::activateXahauGenesis()
                 return;
             }
 
+            auto wasmValidator = ctx_.view().rules().enabled(featureWasmtimeEngine)
+                ? hook::makeWasmtimeEngine()
+                : hook::makeWasmEdgeEngine();
             std::optional<std::string> result2 =
-                hook::HookExecutor::validateWasm(
+                wasmValidator->validate(
                     wasmBytes.data(), (size_t)wasmBytes.size());
 
             if (result2)

src/xrpld/app/tx/detail/SetHook.cpp

@@ -48,7 +48,9 @@
 #include <utility>
 #include <variant>
 #include <vector>
-#include <wasmedge/wasmedge.h>
+#include <xrpld/app/hook/detail/WasmEngine.h>
+#include <xrpld/app/hook/detail/WasmEdgeEngine.h>
+#include <xrpld/app/hook/detail/WasmtimeEngine.h>
 
 #define DEBUG_GUARD_CHECK 1
 #define HS_ACC() \
@@ -592,8 +594,11 @@ SetHook::validateHookSetEntry(SetHookCtx& ctx, STObject const& hookSetObj)
                     << "]: Trying to wasm instantiate proposed hook "
                     << "size = " << hook.size();
 
+                auto wasmValidator = ctx.rules.enabled(featureWasmtimeEngine)
+                    ? hook::makeWasmtimeEngine()
+                    : hook::makeWasmEdgeEngine();
                 std::optional<std::string> result2 =
-                    hook::HookExecutor::validateWasm(
+                    wasmValidator->validate(
                         hook.data(), (size_t)hook.size());
 
                 if (result2)