Wasmi memory limits

Add host-functions cost for wasmi (#6078 )
* Add host-functions cost for wasmi * Fix codecov * Add trap generation to gas check in HF * Wasmi conan refactoring
2026-10-21 19:18:22 +00:00 · 2025-12-02 15:18:53 -05:00 · 2025-12-02 15:18:53 -05:00 · 2025-12-02 15:18:52 -05:00 · 2025-12-02 15:18:52 -05:00 · 2025-12-02 15:18:52 -05:00
92 changed files with 19539 additions and 194 deletions
@@ -1,8 +1,2 @@
 # Allow anyone to review any change by default.
 *
-
-# Require the rpc-reviewers team to review changes to the rpc code.
-include/xrpl/protocol/ @xrplf/rpc-reviewers
-src/libxrpl/protocol/ @xrplf/rpc-reviewers
-src/xrpld/rpc/ @xrplf/rpc-reviewers
-src/xrpld/app/misc/ @xrplf/rpc-reviewers
@@ -35,6 +35,7 @@ runs:
        LOG_VERBOSITY: ${{ inputs.log_verbosity }}
      run: |
        echo 'Installing dependencies.'
+        conan export --version 0.42.1 external/wasmi  #TODO Switch to conan package
        mkdir -p "${BUILD_DIR}"
        cd "${BUILD_DIR}"
        conan install \
@@ -15,196 +15,196 @@
      "distro_version": "bookworm",
      "compiler_name": "gcc",
      "compiler_version": "12",
-      "image_sha": "0525eae"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "debian",
      "distro_version": "bookworm",
      "compiler_name": "gcc",
      "compiler_version": "13",
-      "image_sha": "0525eae"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "debian",
      "distro_version": "bookworm",
      "compiler_name": "gcc",
      "compiler_version": "14",
-      "image_sha": "0525eae"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "debian",
      "distro_version": "bookworm",
      "compiler_name": "gcc",
      "compiler_version": "15",
-      "image_sha": "0525eae"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "debian",
      "distro_version": "bookworm",
      "compiler_name": "clang",
      "compiler_version": "16",
-      "image_sha": "0525eae"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "debian",
      "distro_version": "bookworm",
      "compiler_name": "clang",
      "compiler_version": "17",
-      "image_sha": "0525eae"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "debian",
      "distro_version": "bookworm",
      "compiler_name": "clang",
      "compiler_version": "18",
-      "image_sha": "0525eae"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "debian",
      "distro_version": "bookworm",
      "compiler_name": "clang",
      "compiler_version": "19",
-      "image_sha": "0525eae"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "debian",
      "distro_version": "bookworm",
      "compiler_name": "clang",
      "compiler_version": "20",
-      "image_sha": "0525eae"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "debian",
      "distro_version": "trixie",
      "compiler_name": "gcc",
      "compiler_version": "14",
-      "image_sha": "0525eae"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "debian",
      "distro_version": "trixie",
      "compiler_name": "gcc",
      "compiler_version": "15",
-      "image_sha": "0525eae"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "debian",
      "distro_version": "trixie",
      "compiler_name": "clang",
      "compiler_version": "20",
-      "image_sha": "0525eae"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "debian",
      "distro_version": "trixie",
      "compiler_name": "clang",
      "compiler_version": "21",
-      "image_sha": "0525eae"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "rhel",
      "distro_version": "8",
      "compiler_name": "gcc",
      "compiler_version": "14",
-      "image_sha": "e1782cd"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "rhel",
      "distro_version": "8",
      "compiler_name": "clang",
      "compiler_version": "any",
-      "image_sha": "e1782cd"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "rhel",
      "distro_version": "9",
      "compiler_name": "gcc",
      "compiler_version": "12",
-      "image_sha": "e1782cd"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "rhel",
      "distro_version": "9",
      "compiler_name": "gcc",
      "compiler_version": "13",
-      "image_sha": "e1782cd"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "rhel",
      "distro_version": "9",
      "compiler_name": "gcc",
      "compiler_version": "14",
-      "image_sha": "e1782cd"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "rhel",
      "distro_version": "9",
      "compiler_name": "clang",
      "compiler_version": "any",
-      "image_sha": "e1782cd"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "rhel",
      "distro_version": "10",
      "compiler_name": "gcc",
      "compiler_version": "14",
-      "image_sha": "e1782cd"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "rhel",
      "distro_version": "10",
      "compiler_name": "clang",
      "compiler_version": "any",
-      "image_sha": "e1782cd"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "ubuntu",
      "distro_version": "jammy",
      "compiler_name": "gcc",
      "compiler_version": "12",
-      "image_sha": "e1782cd"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "ubuntu",
      "distro_version": "noble",
      "compiler_name": "gcc",
      "compiler_version": "13",
-      "image_sha": "e1782cd"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "ubuntu",
      "distro_version": "noble",
      "compiler_name": "gcc",
      "compiler_version": "14",
-      "image_sha": "e1782cd"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "ubuntu",
      "distro_version": "noble",
      "compiler_name": "clang",
      "compiler_version": "16",
-      "image_sha": "e1782cd"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "ubuntu",
      "distro_version": "noble",
      "compiler_name": "clang",
      "compiler_version": "17",
-      "image_sha": "e1782cd"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "ubuntu",
      "distro_version": "noble",
      "compiler_name": "clang",
      "compiler_version": "18",
-      "image_sha": "e1782cd"
+      "image_sha": "ca4517d"
    },
    {
      "distro_name": "ubuntu",
      "distro_version": "noble",
      "compiler_name": "clang",
      "compiler_version": "19",
-      "image_sha": "e1782cd"
+      "image_sha": "ca4517d"
    }
  ],
  "build_type": ["Debug", "Release"],
@@ -77,7 +77,7 @@ jobs:
        uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0

      - name: Prepare runner
-        uses: XRPLF/actions/.github/actions/prepare-runner@99685816bb60a95a66852f212f382580e180df3a
+        uses: XRPLF/actions/.github/actions/prepare-runner@ff9f8f649df5855ffe1a1ae715df43e51807f2e0
        with:
          disable_ccache: false

@@ -70,7 +70,7 @@ jobs:
        uses: actions/checkout@08eba0b27e820071cde6df949e0beb9ba4906955 # v4.3.0

      - name: Prepare runner
-        uses: XRPLF/actions/.github/actions/prepare-runner@99685816bb60a95a66852f212f382580e180df3a
+        uses: XRPLF/actions/.github/actions/prepare-runner@ff9f8f649df5855ffe1a1ae715df43e51807f2e0
        with:
          disable_ccache: false

@@ -153,6 +153,7 @@ git checkout master
 conan export --version 2015.03 recipes/ed25519/all
 conan export --version 1.1.10 recipes/snappy/all
 conan export --version 4.0.3 recipes/soci/all
+conan export --version 0.42.1 external/wasmi
 rm -rf .git
 ```

@@ -119,6 +119,7 @@ endif()
 find_package(date REQUIRED)
 find_package(ed25519 REQUIRED)
 find_package(nudb REQUIRED)
+find_package(wasmi REQUIRED)
 find_package(xxHash REQUIRED)

 target_link_libraries(xrpl_libs INTERFACE
@@ -1290,6 +1290,39 @@
 #       Example:
 #           owner_reserve = 2000000      # 2 XRP
 #
+#   extension_compute_limit = <gas>
+#
+#       The extension compute limit is the maximum amount of gas that can be
+#       consumed by a single transaction. The gas limit is used to prevent
+#       transactions from consuming too many resources.
+#
+#       If this parameter is unspecified, rippled will use an internal
+#       default. Don't change this without understanding the consequences.
+#
+#       Example:
+#           extension_compute_limit = 1000000      # 1 million gas
+#
+#   extension_size_limit = <bytes>
+#
+#       The extension size limit is the maximum size of a WASM extension in
+#       bytes. The size limit is used to prevent extensions from consuming
+#       too many resources.
+#
+#       If this parameter is unspecified, rippled will use an internal
+#       default. Don't change this without understanding the consequences.
+#
+#       Example:
+#           extension_size_limit = 100000      # 100 kb
+#
+#   gas_price = <bytes>
+#
+#       The gas price is the conversion between WASM gas and its price in drops.
+#
+#       If this parameter is unspecified, rippled will use an internal
+#       default. Don't change this without understanding the consequences.
+#
+#       Example:
+#           gas_price = 1000000      # 1 drop per gas
 #-------------------------------------------------------------------------------
 #
 # 9. Misc Settings
@@ -63,6 +63,7 @@ target_link_libraries(xrpl.imports.main
    Xrpl::opts
    Xrpl::syslibs
    secp256k1::secp256k1
+    wasmi::wasmi
    xrpl.libpb
    xxHash::xxhash
    $<$<BOOL:${voidstar}>:antithesis-sdk-cpp>
@@ -1,61 +0,0 @@
-{
-    "version": "0.5",
-    "requires": [
-        "zlib/1.3.1#b8bc2603263cf7eccbd6e17e66b0ed76%1756234269.497",
-        "xxhash/0.8.3#681d36a0a6111fc56e5e45ea182c19cc%1756234289.683",
-        "sqlite3/3.49.1#8631739a4c9b93bd3d6b753bac548a63%1756234266.869",
-        "soci/4.0.3#a9f8d773cd33e356b5879a4b0564f287%1756234262.318",
-        "snappy/1.1.10#968fef506ff261592ec30c574d4a7809%1756234314.246",
-        "rocksdb/10.5.1#4a197eca381a3e5ae8adf8cffa5aacd0%1762797952.535",
-        "re2/20230301#ca3b241baec15bd31ea9187150e0b333%1764175362.029",
-        "protobuf/3.21.12#44ee56c0a6eea0c19aeeaca680370b88%1764175361.456",
-        "openssl/3.5.4#a1d5835cc6ed5c5b8f3cd5b9b5d24205%1760106486.594",
-        "nudb/2.0.9#fb8dfd1a5557f5e0528114c2da17721e%1763150366.909",
-        "lz4/1.10.0#59fc63cac7f10fbe8e05c7e62c2f3504%1756234228.999",
-        "libiconv/1.17#1e65319e945f2d31941a9d28cc13c058%1756223727.64",
-        "libbacktrace/cci.20210118#a7691bfccd8caaf66309df196790a5a1%1756230911.03",
-        "libarchive/3.8.1#ffee18995c706e02bf96e7a2f7042e0d%1764175360.142",
-        "jemalloc/5.3.0#e951da9cf599e956cebc117880d2d9f8%1729241615.244",
-        "grpc/1.50.1#02291451d1e17200293a409410d1c4e1%1756234248.958",
-        "ed25519/2015.03#17c1f1910e769f368025267a53c23c13%1764259445.491",
-        "doctest/2.4.12#eb9fb352fb2fdfc8abb17ec270945165%1762797941.757",
-        "date/3.0.4#862e11e80030356b53c2c38599ceb32b%1763584497.32",
-        "c-ares/1.34.5#5581c2b62a608b40bb85d965ab3ec7c8%1764175359.429",
-        "bzip2/1.0.8#c470882369c2d95c5c77e970c0c7e321%1764175359.429",
-        "boost/1.88.0#8852c0b72ce8271fb8ff7c53456d4983%1756223752.326",
-        "abseil/20230802.1#90ba607d4ee8fb5fb157c3db540671fc%1764175359.429"
-    ],
-    "build_requires": [
-        "zlib/1.3.1#b8bc2603263cf7eccbd6e17e66b0ed76%1756234269.497",
-        "strawberryperl/5.32.1.1#707032463aa0620fa17ec0d887f5fe41%1756234281.733",
-        "protobuf/3.21.12#44ee56c0a6eea0c19aeeaca680370b88%1764175361.456",
-        "nasm/2.16.01#31e26f2ee3c4346ecd347911bd126904%1756234232.901",
-        "msys2/cci.latest#5b73b10144f73cc5bfe0572ed9be39e1%1751977009.857",
-        "m4/1.4.19#70dc8bbb33e981d119d2acc0175cf381%1763158052.846",
-        "cmake/4.2.0#ae0a44f44a1ef9ab68fd4b3e9a1f8671%1764175359.44",
-        "cmake/3.31.10#313d16a1aa16bbdb2ca0792467214b76%1764175359.429",
-        "b2/5.3.3#107c15377719889654eb9a162a673975%1756234226.28",
-        "automake/1.16.5#b91b7c384c3deaa9d535be02da14d04f%1755524470.56",
-        "autoconf/2.71#51077f068e61700d65bb05541ea1e4b0%1731054366.86"
-    ],
-    "python_requires": [],
-    "overrides": {
-        "protobuf/3.21.12": [
-            null,
-            "protobuf/3.21.12"
-        ],
-        "lz4/1.9.4": [
-            "lz4/1.10.0"
-        ],
-        "boost/1.83.0": [
-            "boost/1.88.0"
-        ],
-        "sqlite3/3.44.2": [
-            "sqlite3/3.49.1"
-        ],
-        "lz4/[>=1.9.4 <2]": [
-            "lz4/1.10.0#59fc63cac7f10fbe8e05c7e62c2f3504"
-        ]
-    },
-    "config_requires": []
-}
@@ -34,6 +34,7 @@ class Xrpl(ConanFile):
        "nudb/2.0.9",
        "openssl/3.5.4",
        "soci/4.0.3",
+        "wasmi/0.42.1",
        "zlib/1.3.1",
    ]

@@ -198,6 +199,7 @@ class Xrpl(ConanFile):
            "protobuf::libprotobuf",
            "soci::soci",
            "sqlite3::sqlite",
+            "wasmi::wasmi",
            "xxhash::xxhash",
            "zlib::zlib",
        ]
@@ -0,0 +1,11 @@
+# Do not update. Maintained by programmability team.
+
+sources:
+  "0.42.1":
+    url: https://github.com/wasmi-labs/wasmi/archive/refs/tags/v0.42.1.tar.gz
+    sha256: 2a5697be33c7afce8f671af4a5a3621d9e93ce55d253d31bd8201458e465fbb8
+patches:
+  "0.42.1":
+    - patch_file: "patches/0001-xrplf-0.42.1.patch"
+      patch_description: Integrate wasmi lib into smart-escrow.
+      patch_type: conan
@@ -0,0 +1,43 @@
+from conan import ConanFile, tools
+from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout
+from conan.tools.files import apply_conandata_patches, export_conandata_patches, get
+import os
+
+required_conan_version = ">=2.0.0"
+
+class WasmiConan(ConanFile):
+    name = "wasmi"
+    license = "Apache License v2.0"
+    url = "https://github.com/wasmi-labs/wasmi.git"
+    description = "WebAssembly (Wasm) interpreter"
+    package_type = "library"
+    settings = "os", "arch", "compiler", "build_type"
+    options = {"shared": [False]}
+    default_options = {"shared": False}
+
+    def export_sources(self):
+        export_conandata_patches(self)
+
+    def layout(self):
+        cmake_layout(self, src_folder="src")
+
+    def source(self):
+        get(self, **self.conan_data["sources"][self.version], strip_root=True)
+        apply_conandata_patches(self)
+
+    def generate(self):
+        tc = CMakeToolchain(self)
+        tc.variables["BUILD_SHARED_LIBS"] = self.options.shared
+        tc.generate()
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure(build_script_folder=os.path.join(self.source_folder, "crates", "c_api"))
+        cmake.build()
+
+    def package(self):
+        cmake = CMake(self)
+        cmake.install()
+
+    def package_info(self):
+        self.cpp_info.libs = ["wasmi"]
@@ -0,0 +1,287 @@
+diff --git a/crates/c_api/CMakeLists.txt b/crates/c_api/CMakeLists.txt
+index b15c787..54eaed2 100644
+--- a/crates/c_api/CMakeLists.txt
+++ b/crates/c_api/CMakeLists.txt
+@@ -6,6 +6,8 @@ option(BUILD_SHARED_LIBS "Build using shared libraries" OFF)
+ option(WASMI_ALWAYS_BUILD "If cmake should always invoke cargo to build Wasmi" ON)
+ set(WASMI_TARGET "" CACHE STRING "Rust target to build for")
+ 
+add_compile_definitions(COMPILING_WASM_RUNTIME_API=1)
+
+ if(NOT WASMI_TARGET)
+     execute_process(
+         COMMAND rustc -vV
+@@ -43,6 +45,10 @@ endif()
+ list(TRANSFORM WASMI_SHARED_FILES PREPEND ${WASMI_TARGET_DIR}/)
+ list(TRANSFORM WASMI_STATIC_FILES PREPEND ${WASMI_TARGET_DIR}/)
+ 
+if(NOT BUILD_SHARED_LIBS)
+  set(WASMI_SHARED_FILES)
+endif()
+
+ # Instructions on how to build and install the Wasmi Rust crate.
+ find_program(WASMI_CARGO_BINARY cargo REQUIRED)
+ include(ExternalProject)
+@@ -79,7 +85,6 @@ else()
+     target_link_libraries(wasmi INTERFACE ${WASMI_STATIC_FILES})
+ 
+     if(WASMI_TARGET MATCHES "windows")
+-        target_compile_options(wasmi INTERFACE -DWASM_API_EXTERN= -DWASI_API_EXTERN=)
+         target_link_libraries(wasmi INTERFACE ws2_32 advapi32 userenv ntdll shell32 ole32 bcrypt)
+     elseif(NOT WASMI_TARGET MATCHES "darwin")
+         target_link_libraries(wasmi INTERFACE pthread dl m)
+@@ -112,6 +117,7 @@ install(
+     DESTINATION ${CMAKE_INSTALL_LIBDIR}
+ )
+ 
+if(BUILD_SHARED_LIBS)
+ if(WASMI_TARGET MATCHES "darwin")
+     set(INSTALLED_LIB "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/libwasmi.dylib")
+     install(
+@@ -131,6 +137,7 @@ if(WASMI_TARGET MATCHES "darwin")
+         install(CODE "execute_process(COMMAND ${install_name_tool_cmd})")
+     endif()
+ endif()
+endif()
+ 
+ # Documentation Generation via Doxygen:
+ set(DOXYGEN_CONF_IN ${CMAKE_CURRENT_SOURCE_DIR}/doxygen.conf.in)
+@@ -141,19 +148,3 @@ add_custom_target(doc
+     DEPENDS ${WASMI_GENERATED_CONF_H} ${DOXYGEN_CONF_OUT}
+     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+ )
+-
+-# C-Header Formatting via clang-format:
+-find_program(CLANG_FORMAT clang-format REQUIRED)
+-file(GLOB_RECURSE HEADER_FILES
+-    ${CMAKE_CURRENT_SOURCE_DIR}/include/wasmi.h
+-    ${CMAKE_CURRENT_SOURCE_DIR}/include/wasmi/*.h
+-    ${CMAKE_CURRENT_SOURCE_DIR}/include/wasmi/*.hh
+-)
+-add_custom_target(check-format
+-    COMMAND ${CLANG_FORMAT} -style=llvm -Werror --dry-run ${HEADER_FILES}
+-    COMMENT "clang-format: Check formatting for Wasmi C-API header files"
+-)
+-add_custom_target(format
+-    COMMAND ${CLANG_FORMAT} -style=llvm -i ${HEADER_FILES}
+-    COMMENT "clang-format: Apply formatting rules for Wasmi C-API header files"
+-)
+diff --git a/crates/c_api/include/wasm.h b/crates/c_api/include/wasm.h
+index 5ee617f..a76f10e 100644
+--- a/crates/c_api/include/wasm.h
+++ b/crates/c_api/include/wasm.h
+@@ -13,11 +13,17 @@
+ #include <assert.h>
+ 
+ #ifndef WASM_API_EXTERN
+-#if defined(_WIN32) && !defined(__MINGW32__) && !defined(LIBWASM_STATIC)
+#if defined(_MSC_BUILD)
+#if defined(COMPILING_WASM_RUNTIME_API)
+#define WASM_API_EXTERN __declspec(dllexport)
+#elif defined(_DLL)
+ #define WASM_API_EXTERN __declspec(dllimport)
+ #else
+ #define WASM_API_EXTERN
+ #endif
+#else
+#define WASM_API_EXTERN
+#endif
+ #endif
+ 
+ #ifdef __cplusplus
+@@ -145,7 +151,13 @@ WASM_API_EXTERN own wasm_engine_t* wasm_engine_new_with_config(own wasm_config_t
+ WASM_DECLARE_OWN(store)
+ 
+ WASM_API_EXTERN own wasm_store_t* wasm_store_new(wasm_engine_t*);
+WASM_API_EXTERN own wasm_store_t* wasm_store_new_with_memory_max_pages(wasm_engine_t*, uint32_t max_pages);
+
+// Store fuel functions (forward declarations)
+struct wasmi_error;
+ 
+WASM_API_EXTERN struct wasmi_error* wasm_store_get_fuel(const wasm_store_t*, uint64_t* fuel);
+WASM_API_EXTERN struct wasmi_error* wasm_store_set_fuel(wasm_store_t*, uint64_t fuel);
+ 
+ ///////////////////////////////////////////////////////////////////////////////
+ // Type Representations
+diff --git a/crates/c_api/include/wasmi.h b/crates/c_api/include/wasmi.h
+index 2caffa3..0c0584e 100644
+--- a/crates/c_api/include/wasmi.h
+++ b/crates/c_api/include/wasmi.h
+@@ -10,7 +10,7 @@
+ /**
+  * \brief Wasmi version string.
+  */
+-#define WASMI_VERSION "0.35.0"
+#define WASMI_VERSION "0.42.1"
+ /**
+  * \brief Wasmi major version number.
+  */
+@@ -18,10 +18,10 @@
+ /**
+  * \brief Wasmi minor version number.
+  */
+-#define WASMI_VERSION_MINOR 35
+#define WASMI_VERSION_MINOR 42
+ /**
+  * \brief Wasmi patch version number.
+  */
+-#define WASMI_VERSION_PATCH 0
+#define WASMI_VERSION_PATCH 1
+ 
+ #endif // WASMI_H
+diff --git a/crates/c_api/src/store.rs b/crates/c_api/src/store.rs
+index 56d4898..9abda8e 100644
+--- a/crates/c_api/src/store.rs
+++ b/crates/c_api/src/store.rs
+@@ -1,7 +1,7 @@
+ use crate::{wasm_engine_t, wasmi_error_t, ForeignData};
+ use alloc::{boxed::Box, sync::Arc};
+ use core::{cell::UnsafeCell, ffi};
+-use wasmi::{AsContext, AsContextMut, Store, StoreContext, StoreContextMut};
+use wasmi::{AsContext, AsContextMut, Store, StoreContext, StoreContextMut, StoreLimits, StoreLimitsBuilder};
+ 
+ /// This representation of a `Store` is used to implement the `wasm.h` API (and
+ /// *not* the `wasmi.h` API!)
+@@ -16,7 +16,7 @@ use wasmi::{AsContext, AsContextMut, Store, StoreContext, StoreContextMut};
+ /// least Wasmi's implementation).
+ #[derive(Clone)]
+ pub struct WasmStoreRef {
+-    inner: Arc<UnsafeCell<Store<()>>>,
+    inner: Arc<UnsafeCell<Store<StoreLimits>>>,
+ }
+ 
+ impl WasmStoreRef {
+@@ -27,7 +27,7 @@ impl WasmStoreRef {
+     /// # Safety
+     ///
+     /// It is the callers responsibility to provide a valid `self`.
+-    pub unsafe fn context(&self) -> StoreContext<'_, ()> {
+    pub unsafe fn context(&self) -> StoreContext<'_, StoreLimits> {
+         (*self.inner.get()).as_context()
+     }
+ 
+@@ -38,7 +38,7 @@ impl WasmStoreRef {
+     /// # Safety
+     ///
+     /// It is the callers responsibility to provide a valid `self`.
+-    pub unsafe fn context_mut(&mut self) -> StoreContextMut<'_, ()> {
+    pub unsafe fn context_mut(&mut self) -> StoreContextMut<'_, StoreLimits> {
+         (*self.inner.get()).as_context_mut()
+     }
+ }
+@@ -56,17 +56,71 @@ pub struct wasm_store_t {
+ 
+ wasmi_c_api_macros::declare_own!(wasm_store_t);
+ 
+-/// Creates a new [`Store<()>`](wasmi::Store) for the given `engine`.
+/// Creates a new [`Store<StoreLimits>`](wasmi::Store) for the given `engine`.
+///
+/// The store is created with no resource limits (original behavior).
+/// For memory-limited stores, use [`wasm_store_new_with_memory_max_pages`].
+ ///
+ /// The returned [`wasm_store_t`] must be freed using [`wasm_store_delete`].
+ ///
+-/// Wraps [`<wasmi::Store<()>>::new`](wasmi::Store::new).
+/// Wraps [`<wasmi::Store<StoreLimits>>::new`](wasmi::Store::new).
+ #[cfg_attr(not(feature = "prefix-symbols"), no_mangle)]
+ #[allow(clippy::arc_with_non_send_sync)]
+ #[cfg_attr(feature = "prefix-symbols", wasmi_c_api_macros::prefix_symbol)]
+ pub extern "C" fn wasm_store_new(engine: &wasm_engine_t) -> Box<wasm_store_t> {
+     let engine = &engine.inner;
+-    let store = Store::new(engine, ());
+
+    // Create store with no resource limits (original behavior)
+    let limits = StoreLimitsBuilder::new().build();
+    let store = Store::new(engine, limits);
+
+    Box::new(wasm_store_t {
+        inner: WasmStoreRef {
+            inner: Arc::new(UnsafeCell::new(store)),
+        },
+    })
+}
+
+/// Creates a new [`Store<StoreLimits>`](wasmi::Store) for the given `engine` with memory limits.
+///
+/// This function creates a store with resource limits suitable for blockchain smart contracts.
+/// The memory limit is enforced during WebAssembly execution.
+///
+/// If `max_pages` exceeds 1024 (64MB), this function will panic.
+///
+/// The returned [`wasm_store_t`] must be freed using [`wasm_store_delete`].
+///
+/// Wraps [`<wasmi::Store<StoreLimits>>::new`](wasmi::Store::new).
+#[cfg_attr(not(feature = "prefix-symbols"), no_mangle)]
+#[allow(clippy::arc_with_non_send_sync)]
+#[cfg_attr(feature = "prefix-symbols", wasmi_c_api_macros::prefix_symbol)]
+pub extern "C" fn wasm_store_new_with_memory_max_pages(
+    engine: &wasm_engine_t,
+    max_pages: u32,
+) -> Box<wasm_store_t> {
+    // Validate max_pages limit (64MB = 1024 pages)
+    if max_pages > 1024 {
+        panic!("max_pages ({}) exceeds maximum allowed value of 1024 pages (64MB)", max_pages);
+    }
+
+    // Convert pages to bytes (each page is 64KB)
+    let max_memory_bytes = (max_pages as usize) * (64 * 1024);
+
+    // Create store limits with blockchain-suitable defaults
+    let limits = StoreLimitsBuilder::new()
+        .memory_size(max_memory_bytes) // User-specified memory limit
+        .instances(1) // Single instance for blockchain
+        .tables(1) // Single table for blockchain
+        .memories(1) // Single memory for blockchain
+        .table_elements(64) // Limited table elements for blockchain
+        .trap_on_grow_failure(false) // Return -1 on growth failure instead of trapping
+        .build();
+
+    let mut store = Store::new(&engine.inner, limits);
+
+    // Install the resource limiter
+    store.limiter(|limits| limits);
+
+     Box::new(wasm_store_t {
+         inner: WasmStoreRef {
+             inner: Arc::new(UnsafeCell::new(store)),
+@@ -175,3 +229,40 @@ pub extern "C" fn wasmi_context_set_fuel(
+ ) -> Option<Box<wasmi_error_t>> {
+     crate::handle_result(store.set_fuel(fuel), |()| {})
+ }
+
+////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////
+
+/// Returns the current fuel of the wasm store context in `fuel`.
+///
+/// Wraps [`Store::get_fuel`].
+///
+/// # Errors
+///
+/// If [`Store::get_fuel`] errors.
+#[no_mangle]
+pub extern "C" fn wasm_store_get_fuel(
+    store: &wasm_store_t,
+    fuel: &mut u64,
+) -> Option<Box<wasmi_error_t>> {
+    let context = unsafe { store.inner.context() };
+    crate::handle_result(context.get_fuel(), |amt| {
+        *fuel = amt;
+    })
+}
+
+/// Sets the current fuel of the wasm store context to `fuel`.
+///
+/// Wraps [`Store::set_fuel`].
+///
+/// # Errors
+///
+/// If [`Store::set_fuel`] errors.
+#[no_mangle]
+pub extern "C" fn wasm_store_set_fuel(
+    store: &mut wasm_store_t,
+    fuel: u64,
+) -> Option<Box<wasmi_error_t>> {
+    let mut context = unsafe { store.inner.context_mut() };
+    crate::handle_result(context.set_fuel(fuel), |()| {})
+}
@@ -339,6 +339,10 @@ abs(Number x) noexcept
 Number
 power(Number const& f, unsigned n);

+// logarithm with base 10
+Number
+lg(Number const& value);
+
 // Returns f^(1/d)
 // Uses Newton–Raphson iterations until the result stops changing
 // to find the root of the polynomial g(x) = x^d - f
@@ -55,6 +55,18 @@ public:
        deliver_ = amount;
    }

+    void
+    setGasUsed(std::optional<std::uint32_t> const gasUsed)
+    {
+        gasUsed_ = gasUsed;
+    }
+
+    void
+    setWasmReturnCode(std::int32_t const wasmReturnCode)
+    {
+        wasmReturnCode_ = wasmReturnCode;
+    }
+
    /** Get the number of modified entries
     */
    std::size_t
@@ -73,6 +85,8 @@ public:

 private:
    std::optional<STAmount> deliver_;
+    std::optional<std::uint32_t> gasUsed_;
+    std::optional<std::int32_t> wasmReturnCode_;
 };

 }  // namespace ripple
@@ -53,6 +53,8 @@ public:
        TER ter,
        std::optional<STAmount> const& deliver,
        std::optional<uint256 const> const& parentBatchId,
+        std::optional<std::uint32_t> const& gasUsed,
+        std::optional<std::int32_t> const& wasmReturnCode,
        bool isDryRun,
        beast::Journal j);

@@ -5,6 +5,8 @@

 namespace ripple {

+constexpr std::uint32_t MICRO_DROPS_PER_DROP{1'000'000};
+
 /** Reflects the fee settings for a particular ledger.

    The fees are always the same for any transactions applied
@@ -15,6 +17,10 @@ struct Fees
    XRPAmount base{0};       // Reference tx cost (drops)
    XRPAmount reserve{0};    // Reserve base (drops)
    XRPAmount increment{0};  // Reserve increment (drops)
+    std::uint32_t extensionComputeLimit{
+        0};  // Extension compute limit (instructions)
+    std::uint32_t extensionSizeLimit{0};  // Extension size limit (bytes)
+    std::uint32_t gasPrice{0};            // price of WASM gas (micro-drops)

    explicit Fees() = default;
    Fees(Fees const&) = default;
@@ -39,6 +39,13 @@ private:
    normalize();

 public:
+    /* The range for the mantissa when normalized */
+    static std::int64_t constexpr minMantissa = 1000000000000000ull;
+    static std::int64_t constexpr maxMantissa = 9999999999999999ull;
+    /* The range for the exponent when normalized */
+    static int constexpr minExponent = -96;
+    static int constexpr maxExponent = 80;
+
    IOUAmount() = default;
    explicit IOUAmount(Number const& other);
    IOUAmount(beast::Zero);
@@ -212,6 +212,12 @@ page(Keylet const& root, std::uint64_t index = 0) noexcept
 Keylet
 escrow(AccountID const& src, std::uint32_t seq) noexcept;

+inline Keylet
+escrow(uint256 const& key) noexcept
+{
+    return {ltESCROW, key};
+}
+
 /** A PaymentChannel */
 Keylet
 payChan(AccountID const& src, AccountID const& dst, std::uint32_t seq) noexcept;
@@ -251,6 +251,13 @@ std::uint8_t constexpr vaultMaximumIOUScale = 18;
 * another vault; counted from 0 */
 std::uint8_t constexpr maxAssetCheckDepth = 5;

+/** The maximum length of a Data field in Escrow object that can be updated by
+ * Wasm code */
+std::size_t constexpr maxWasmDataLength = 4 * 1024;
+
+/** The maximum length of a parameters passed from Wasm code*/
+std::size_t constexpr maxWasmParamLength = 1024;
+
 /** A ledger index. */
 using LedgerIndex = std::uint32_t;

@@ -122,6 +122,8 @@ enum TEMcodes : TERUnderlyingType {
    temARRAY_TOO_LARGE,
    temBAD_TRANSFER_FEE,
    temINVALID_INNER_BATCH,
+
+    temBAD_WASM,
 };

 //------------------------------------------------------------------------------
@@ -166,6 +168,8 @@ enum TEFcodes : TERUnderlyingType {
    tefNO_TICKET,
    tefNFTOKEN_IS_NOT_TRANSFERABLE,
    tefINVALID_LEDGER_FIX_TYPE,
+    tefNO_WASM,
+    tefWASM_FIELD_NOT_INCLUDED,
 };

 //------------------------------------------------------------------------------
@@ -347,6 +351,7 @@ enum TECcodes : TERUnderlyingType {
    // backward compatibility with historical data on non-prod networks, can be
    // reclaimed after those networks reset.
    tecNO_DELEGATE_PERMISSION = 198,
+    tecWASM_REJECTED = 199,
 };

 //------------------------------------------------------------------------------
@@ -85,6 +85,12 @@ public:

        if (obj.isFieldPresent(sfParentBatchID))
            parentBatchID_ = obj.getFieldH256(sfParentBatchID);
+
+        if (obj.isFieldPresent(sfGasUsed))
+            gasUsed_ = obj.getFieldU32(sfGasUsed);
+
+        if (obj.isFieldPresent(sfWasmReturnCode))
+            wasmReturnCode_ = obj.getFieldI32(sfWasmReturnCode);
    }

    std::optional<STAmount> const&
@@ -105,6 +111,30 @@ public:
        parentBatchID_ = id;
    }

+    void
+    setGasUsed(std::optional<std::uint32_t> const gasUsed)
+    {
+        gasUsed_ = gasUsed;
+    }
+
+    std::optional<std::uint32_t> const&
+    getGasUsed() const
+    {
+        return gasUsed_;
+    }
+
+    void
+    setWasmReturnCode(std::optional<std::int32_t> const wasmReturnCode)
+    {
+        wasmReturnCode_ = wasmReturnCode;
+    }
+
+    std::optional<std::int32_t> const&
+    getWasmReturnCode() const
+    {
+        return wasmReturnCode_;
+    }
+
 private:
    uint256 transactionID_;
    std::uint32_t ledgerSeq_;
@@ -113,6 +143,8 @@ private:

    std::optional<STAmount> deliveredAmount_;
    std::optional<uint256> parentBatchID_;
+    std::optional<std::uint32_t> gasUsed_;
+    std::optional<std::int32_t> wasmReturnCode_;

    STArray nodes_;
 };
@@ -16,6 +16,7 @@
 // Add new amendments to the top of this list.
 // Keep it sorted in reverse chronological order.

+XRPL_FEATURE(SmartEscrow,                Supported::no,  VoteBehavior::DefaultNo)
 XRPL_FEATURE(LendingProtocol,            Supported::no,  VoteBehavior::DefaultNo)
 XRPL_FEATURE(PermissionDelegationV1_1,   Supported::no,  VoteBehavior::DefaultNo)
 XRPL_FIX    (DirectoryLimit,             Supported::yes, VoteBehavior::DefaultNo)
@@ -32,7 +33,6 @@ XRPL_FEATURE(PermissionedDEX,            Supported::yes, VoteBehavior::DefaultNo
 XRPL_FEATURE(Batch,                      Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(SingleAssetVault,           Supported::no,  VoteBehavior::DefaultNo)
 XRPL_FIX    (PayChanCancelAfter,         Supported::yes, VoteBehavior::DefaultNo)
-// Check flags in Credential transactions
 XRPL_FIX    (InvalidTxFlags,             Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FIX    (FrozenLPTokenTransfer,      Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(DeepFreeze,                 Supported::yes, VoteBehavior::DefaultNo)
@@ -302,6 +302,11 @@ LEDGER_ENTRY(ltFEE_SETTINGS, 0x0073, FeeSettings, fee, ({
    {sfBaseFeeDrops,           soeOPTIONAL},
    {sfReserveBaseDrops,       soeOPTIONAL},
    {sfReserveIncrementDrops,  soeOPTIONAL},
+    // Smart Escrow fields
+    {sfExtensionComputeLimit,  soeOPTIONAL},
+    {sfExtensionSizeLimit,     soeOPTIONAL},
+    {sfGasPrice,               soeOPTIONAL},
+
    {sfPreviousTxnID,          soeOPTIONAL},
    {sfPreviousTxnLgrSeq,      soeOPTIONAL},
 }))
@@ -332,6 +337,8 @@ LEDGER_ENTRY(ltESCROW, 0x0075, Escrow, escrow, ({
    {sfCondition,            soeOPTIONAL},
    {sfCancelAfter,          soeOPTIONAL},
    {sfFinishAfter,          soeOPTIONAL},
+    {sfFinishFunction,       soeOPTIONAL},
+    {sfData,                 soeOPTIONAL},
    {sfSourceTag,            soeOPTIONAL},
    {sfDestinationTag,       soeOPTIONAL},
    {sfOwnerNode,            soeREQUIRED},
@@ -114,6 +114,11 @@ TYPED_SFIELD(sfInterestRate,             UINT32,    65) // 1/10 basis points (bi
 TYPED_SFIELD(sfLateInterestRate,         UINT32,    66) // 1/10 basis points (bips)
 TYPED_SFIELD(sfCloseInterestRate,        UINT32,    67) // 1/10 basis points (bips)
 TYPED_SFIELD(sfOverpaymentInterestRate,  UINT32,    68) // 1/10 basis points (bips)
+TYPED_SFIELD(sfExtensionComputeLimit,    UINT32,    69)
+TYPED_SFIELD(sfExtensionSizeLimit,       UINT32,    70)
+TYPED_SFIELD(sfGasPrice,                 UINT32,    71)
+TYPED_SFIELD(sfComputationAllowance,     UINT32,    72)
+TYPED_SFIELD(sfGasUsed,                  UINT32,    73)

 // 64-bit integers (common)
 TYPED_SFIELD(sfIndexNext,                UINT64,     1)
@@ -226,6 +231,7 @@ TYPED_SFIELD(sfManagementFeeOutstanding, NUMBER,     17)

 // int32
 TYPED_SFIELD(sfLoanScale,                INT32,      1)
+TYPED_SFIELD(sfWasmReturnCode,           INT32,      2)

 // currency amount (common)
 TYPED_SFIELD(sfAmount,                   AMOUNT,     1)
@@ -255,7 +261,7 @@ TYPED_SFIELD(sfBaseFeeDrops,             AMOUNT,    22)
 TYPED_SFIELD(sfReserveBaseDrops,         AMOUNT,    23)
 TYPED_SFIELD(sfReserveIncrementDrops,    AMOUNT,    24)

-// currency amount (AMM)
+// currency amount (more)
 TYPED_SFIELD(sfLPTokenOut,               AMOUNT,    25)
 TYPED_SFIELD(sfLPTokenIn,                AMOUNT,    26)
 TYPED_SFIELD(sfEPrice,                   AMOUNT,    27)
@@ -297,6 +303,7 @@ TYPED_SFIELD(sfAssetClass,               VL,        28)
 TYPED_SFIELD(sfProvider,                 VL,        29)
 TYPED_SFIELD(sfMPTokenMetadata,          VL,        30)
 TYPED_SFIELD(sfCredentialType,           VL,        31)
+TYPED_SFIELD(sfFinishFunction,           VL,        32)

 // account (common)
 TYPED_SFIELD(sfAccount,                  ACCOUNT,    1)
@@ -50,11 +50,13 @@ TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate,
    noPriv,
    ({
    {sfDestination, soeREQUIRED},
+    {sfDestinationTag, soeOPTIONAL},
    {sfAmount, soeREQUIRED, soeMPTSupported},
    {sfCondition, soeOPTIONAL},
    {sfCancelAfter, soeOPTIONAL},
    {sfFinishAfter, soeOPTIONAL},
-    {sfDestinationTag, soeOPTIONAL},
+    {sfFinishFunction, soeOPTIONAL},
+    {sfData,           soeOPTIONAL},
 }))

 /** This transaction type completes an existing escrow. */
@@ -68,6 +70,7 @@ TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish,
    {sfFulfillment, soeOPTIONAL},
    {sfCondition, soeOPTIONAL},
    {sfCredentialIDs, soeOPTIONAL},
+    {sfComputationAllowance, soeOPTIONAL},
 }))


@@ -1092,6 +1095,10 @@ TRANSACTION(ttFEE, 101, SetFee,
    {sfBaseFeeDrops, soeOPTIONAL},
    {sfReserveBaseDrops, soeOPTIONAL},
    {sfReserveIncrementDrops, soeOPTIONAL},
+    // Smart Escrow fields
+    {sfExtensionComputeLimit, soeOPTIONAL},
+    {sfExtensionSizeLimit, soeOPTIONAL},
+    {sfGasPrice, soeOPTIONAL},
 }))

 /** This system-generated transaction type is used to update the network's negative UNL
@@ -255,6 +255,9 @@ JSS(expected_date_UTC);       // out: any (warnings)
 JSS(expected_ledger_size);    // out: TxQ
 JSS(expiration);              // out: AccountOffers, AccountChannels,
                              //      ValidatorList, amm_info
+JSS(extension_compute);       // out: NetworkOps
+JSS(extension_size);          // out: NetworkOps
+JSS(gas_price);               // out: NetworkOps
 JSS(fail_hard);               // in: Sign, Submit
 JSS(failed);                  // out: InboundLedger
 JSS(feature);                 // in: Feature
@@ -709,11 +712,11 @@ JSS(write_load);              // out: GetCounts
 #pragma push_macro("LEDGER_ENTRY_DUPLICATE")
 #undef LEDGER_ENTRY_DUPLICATE

-#define LEDGER_ENTRY(tag, value, name, rpcName, ...) \
-    JSS(name);                                       \
+#define LEDGER_ENTRY(tag, value, name, rpcName, fields) \
+    JSS(name);                                          \
    JSS(rpcName);

-#define LEDGER_ENTRY_DUPLICATE(tag, value, name, rpcName, ...) JSS(rpcName);
+#define LEDGER_ENTRY_DUPLICATE(tag, value, name, rpcName, fields) JSS(rpcName);

 #include <xrpl/protocol/detail/ledger_entries.macro>

@@ -632,6 +632,48 @@ power(Number const& f, unsigned n)
    return r;
 }

+// Continued fraction approximation of ln(x)
+static Number
+ln(Number const& x, unsigned iterations = 50)
+{
+    if (x <= 0)
+        throw std::runtime_error("Not positive value");
+
+    Number const z = (x - 1) / (x + 1);
+    Number const zz = z * z;
+    Number denom = Number(1, -10);
+
+    // Construct the fraction from the bottom up
+    for (int i = iterations; i > 0; --i)
+    {
+        Number k(2 * i - 1);
+        denom = k - (i * i * zz / denom);
+    }
+
+    auto const r = 2 * z / denom;
+    return r;
+}
+
+Number
+lg(Number const& x)
+{
+    static Number const ln10 = ln(Number(10));
+
+    if (x <= Number(10))
+    {
+        auto const r = ln(x) / ln10;
+        return r;
+    }
+
+    // ln(x) = ln(normX * 10^norm) = ln(normX) + norm * ln(10)
+    int diffExp = 15 + x.exponent();
+    Number const normalX = x / Number(1, diffExp);  // (1 <= normalX < 10)
+    auto const lnX = ln(normalX) + diffExp * ln10;
+
+    auto const r = lnX / ln10;
+    return r;
+}
+
 // Returns f^(1/d)
 // Uses Newton–Raphson iterations until the result stops changing
 // to find the non-negative root of the polynomial g(x) = x^d - f
@@ -97,6 +97,8 @@ ApplyStateTable::apply(
    TER ter,
    std::optional<STAmount> const& deliver,
    std::optional<uint256 const> const& parentBatchId,
+    std::optional<std::uint32_t> const& gasUsed,
+    std::optional<std::int32_t> const& wasmReturnCode,
    bool isDryRun,
    beast::Journal j)
 {
@@ -111,6 +113,8 @@ ApplyStateTable::apply(

        meta.setDeliveredAmount(deliver);
        meta.setParentBatchID(parentBatchId);
+        meta.setGasUsed(gasUsed);
+        meta.setWasmReturnCode(wasmReturnCode);

        Mods newMod;
        for (auto& item : items_)
@@ -16,7 +16,16 @@ ApplyViewImpl::apply(
    bool isDryRun,
    beast::Journal j)
 {
-    return items_.apply(to, tx, ter, deliver_, parentBatchId, isDryRun, j);
+    return items_.apply(
+        to,
+        tx,
+        ter,
+        deliver_,
+        parentBatchId,
+        gasUsed_,
+        wasmReturnCode_,
+        isDryRun,
+        j);
 }

 std::size_t
@@ -39,13 +39,6 @@ setSTNumberSwitchover(bool v)
    *getStaticSTNumberSwitchover() = v;
 }

-/* The range for the mantissa when normalized */
-static std::int64_t constexpr minMantissa = 1000000000000000ull;
-static std::int64_t constexpr maxMantissa = 9999999999999999ull;
-/* The range for the exponent when normalized */
-static int constexpr minExponent = -96;
-static int constexpr maxExponent = 80;
-
 IOUAmount
 IOUAmount::minPositiveAmount()
 {
@@ -293,7 +286,8 @@ mulRatio(
        {
            if (!result)
            {
-                return IOUAmount(-minMantissa, minExponent);
+                return IOUAmount(
+                    -IOUAmount::minMantissa, IOUAmount::minExponent);
            }
            // This subtraction cannot underflow because `result` is not zero
            return IOUAmount(result.mantissa() - 1, result.exponent());
@@ -58,6 +58,10 @@ STValidation::validationFormat()
        {sfBaseFeeDrops,          soeOPTIONAL},
        {sfReserveBaseDrops,      soeOPTIONAL},
        {sfReserveIncrementDrops, soeOPTIONAL},
+        // featureSmartEscrow
+        {sfExtensionComputeLimit,  soeOPTIONAL},
+        {sfExtensionSizeLimit,     soeOPTIONAL},
+        {sfGasPrice,               soeOPTIONAL},
    };
    // clang-format on

@@ -108,6 +108,7 @@ transResults()
        MAKE_ERROR(tecLIMIT_EXCEEDED,                "Limit exceeded."),
        MAKE_ERROR(tecPSEUDO_ACCOUNT,                "This operation is not allowed against a pseudo-account."),
        MAKE_ERROR(tecPRECISION_LOSS,                "The amounts used by the transaction cannot interact."),
+        MAKE_ERROR(tecWASM_REJECTED,                 "The custom WASM code that was run rejected your transaction."),

        MAKE_ERROR(tefALREADY,                     "The exact transaction was already in this ledger."),
        MAKE_ERROR(tefBAD_ADD_AUTH,                "Not authorized to add account."),
@@ -131,6 +132,8 @@ transResults()
        MAKE_ERROR(tefNO_TICKET,                   "Ticket is not in ledger."),
        MAKE_ERROR(tefNFTOKEN_IS_NOT_TRANSFERABLE, "The specified NFToken is not transferable."),
        MAKE_ERROR(tefINVALID_LEDGER_FIX_TYPE,     "The LedgerFixType field has an invalid value."),
+        MAKE_ERROR(tefNO_WASM,                     "There is no WASM code to run, but a WASM-specific field was included."),
+        MAKE_ERROR(tefWASM_FIELD_NOT_INCLUDED,     "WASM code requires a field to be included that was not included."),

        MAKE_ERROR(telLOCAL_ERROR,            "Local failure."),
        MAKE_ERROR(telBAD_DOMAIN,             "Domain too long."),
@@ -200,6 +203,7 @@ transResults()
        MAKE_ERROR(temARRAY_TOO_LARGE,           "Malformed: Array is too large."),
        MAKE_ERROR(temBAD_TRANSFER_FEE,          "Malformed: Transfer fee is outside valid range."),
        MAKE_ERROR(temINVALID_INNER_BATCH,       "Malformed: Invalid inner batch transaction."),
+        MAKE_ERROR(temBAD_WASM,                  "Malformed: Provided WASM code is invalid."),

        MAKE_ERROR(terRETRY,                  "Retry transaction."),
        MAKE_ERROR(terFUNDS_SPENT,            "DEPRECATED."),
@@ -211,6 +211,12 @@ TxMeta::getAsObject() const
    if (parentBatchID_.has_value())
        metaData.setFieldH256(sfParentBatchID, *parentBatchID_);

+    if (gasUsed_.has_value())
+        metaData.setFieldU32(sfGasUsed, *gasUsed_);
+
+    if (wasmReturnCode_.has_value())
+        metaData.setFieldI32(sfWasmReturnCode, *wasmReturnCode_);
+
    return metaData;
 }

@@ -7466,7 +7466,7 @@ private:
        using namespace test::jtx;

        auto const testCase = [&](std::string suffix, FeatureBitset features) {
-            testcase("Fail pseudo-account allocation " + suffix);
+            testcase("Pseudo-account allocation failure " + suffix);
            std::string logs;
            Env env{*this, features, std::make_unique<CaptureLogs>(&logs)};
            env.fund(XRP(30'000), gw, alice);
@@ -0,0 +1,916 @@
+#include <test/app/wasm_fixtures/fixtures.h>
+#include <test/jtx.h>
+
+#include <xrpld/app/tx/applySteps.h>
+#include <xrpld/app/wasm/WasmVM.h>
+
+#include <xrpl/ledger/Dir.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/TxFlags.h>
+#include <xrpl/protocol/jss.h>
+
+#include <algorithm>
+#include <iterator>
+
+namespace ripple {
+namespace test {
+
+struct EscrowSmart_test : public beast::unit_test::suite
+{
+    void
+    testCreateFinishFunctionPreflight(FeatureBitset features)
+    {
+        testcase("Test preflight checks involving FinishFunction");
+
+        using namespace jtx;
+        using namespace std::chrono;
+
+        Account const alice{"alice"};
+        Account const carol{"carol"};
+
+        // Tests whether the ledger index is >= 5
+        // getLedgerSqn() >= 5}
+        static auto wasmHex = ledgerSqnWasmHex;
+
+        {
+            // featureSmartEscrow disabled
+            Env env(*this, features - featureSmartEscrow);
+            env.fund(XRP(5000), alice, carol);
+            XRPAmount const txnFees = env.current()->fees().base + 1000;
+            auto escrowCreate = escrow::create(alice, carol, XRP(1000));
+            env(escrowCreate,
+                escrow::finish_function(wasmHex),
+                escrow::cancel_time(env.now() + 100s),
+                fee(txnFees),
+                ter(temDISABLED));
+            env.close();
+
+            env(escrowCreate,
+                escrow::finish_function(wasmHex),
+                escrow::cancel_time(env.now() + 100s),
+                escrow::data("00112233"),
+                fee(txnFees),
+                ter(temDISABLED));
+            env.close();
+        }
+
+        {
+            // FinishFunction > max length
+            Env env(
+                *this,
+                envconfig([](std::unique_ptr<Config> cfg) {
+                    cfg->FEES.extension_size_limit = 10;  // 10 bytes
+                    return cfg;
+                }),
+                features);
+            XRPAmount const txnFees = env.current()->fees().base + 1000;
+            // create escrow
+            env.fund(XRP(5000), alice, carol);
+
+            auto escrowCreate = escrow::create(alice, carol, XRP(500));
+
+            // 11-byte string
+            std::string longWasmHex = "00112233445566778899AA";
+            env(escrowCreate,
+                escrow::finish_function(longWasmHex),
+                escrow::cancel_time(env.now() + 100s),
+                fee(txnFees),
+                ter(temMALFORMED));
+            env.close();
+        }
+
+        {
+            // Data without FinishFunction
+            Env env(*this, features);
+            XRPAmount const txnFees = env.current()->fees().base + 100000;
+            // create escrow
+            env.fund(XRP(5000), alice, carol);
+
+            auto escrowCreate = escrow::create(alice, carol, XRP(500));
+
+            std::string longData(4, 'A');
+            env(escrowCreate,
+                escrow::data(longData),
+                escrow::finish_time(env.now() + 100s),
+                fee(txnFees),
+                ter(temMALFORMED));
+            env.close();
+        }
+
+        {
+            // Data > max length
+            Env env(*this, features);
+            XRPAmount const txnFees = env.current()->fees().base + 100000;
+            // create escrow
+            env.fund(XRP(5000), alice, carol);
+
+            auto escrowCreate = escrow::create(alice, carol, XRP(500));
+
+            // string of length maxWasmDataLength * 2 + 2
+            std::string longData(maxWasmDataLength * 2 + 2, 'B');
+            env(escrowCreate,
+                escrow::data(longData),
+                escrow::finish_function(wasmHex),
+                escrow::cancel_time(env.now() + 100s),
+                fee(txnFees),
+                ter(temMALFORMED));
+            env.close();
+        }
+
+        Env env(
+            *this,
+            envconfig([](std::unique_ptr<Config> cfg) {
+                cfg->START_UP = Config::FRESH;
+                return cfg;
+            }),
+            features);
+        XRPAmount const txnFees =
+            env.current()->fees().base * 10 + wasmHex.size() / 2 * 5;
+        // create escrow
+        env.fund(XRP(5000), alice, carol);
+
+        auto escrowCreate = escrow::create(alice, carol, XRP(500));
+
+        // Success situations
+        {
+            // FinishFunction + CancelAfter
+            env(escrowCreate,
+                escrow::finish_function(wasmHex),
+                escrow::cancel_time(env.now() + 20s),
+                fee(txnFees));
+            env.close();
+        }
+        {
+            // FinishFunction + Condition + CancelAfter
+            env(escrowCreate,
+                escrow::finish_function(wasmHex),
+                escrow::cancel_time(env.now() + 30s),
+                escrow::condition(escrow::cb1),
+                fee(txnFees));
+            env.close();
+        }
+        {
+            // FinishFunction + FinishAfter + CancelAfter
+            env(escrowCreate,
+                escrow::finish_function(wasmHex),
+                escrow::cancel_time(env.now() + 40s),
+                escrow::finish_time(env.now() + 2s),
+                fee(txnFees));
+            env.close();
+        }
+        {
+            // FinishFunction + FinishAfter + Condition + CancelAfter
+            env(escrowCreate,
+                escrow::finish_function(wasmHex),
+                escrow::cancel_time(env.now() + 50s),
+                escrow::condition(escrow::cb1),
+                escrow::finish_time(env.now() + 2s),
+                fee(txnFees));
+            env.close();
+        }
+
+        // Failure situations (i.e. all other combinations)
+        {
+            // only FinishFunction
+            env(escrowCreate,
+                escrow::finish_function(wasmHex),
+                fee(txnFees),
+                ter(temBAD_EXPIRATION));
+            env.close();
+        }
+        {
+            // FinishFunction + FinishAfter
+            env(escrowCreate,
+                escrow::finish_function(wasmHex),
+                escrow::finish_time(env.now() + 2s),
+                fee(txnFees),
+                ter(temBAD_EXPIRATION));
+            env.close();
+        }
+        {
+            // FinishFunction + Condition
+            env(escrowCreate,
+                escrow::finish_function(wasmHex),
+                escrow::condition(escrow::cb1),
+                fee(txnFees),
+                ter(temBAD_EXPIRATION));
+            env.close();
+        }
+        {
+            // FinishFunction + FinishAfter + Condition
+            env(escrowCreate,
+                escrow::finish_function(wasmHex),
+                escrow::condition(escrow::cb1),
+                escrow::finish_time(env.now() + 2s),
+                fee(txnFees),
+                ter(temBAD_EXPIRATION));
+            env.close();
+        }
+        {
+            // FinishFunction 0 length
+            env(escrowCreate,
+                escrow::finish_function(""),
+                escrow::cancel_time(env.now() + 60s),
+                fee(txnFees),
+                ter(temMALFORMED));
+            env.close();
+        }
+        {
+            // Not enough fees
+            env(escrowCreate,
+                escrow::finish_function(wasmHex),
+                escrow::cancel_time(env.now() + 70s),
+                fee(txnFees - 1),
+                ter(telINSUF_FEE_P));
+            env.close();
+        }
+
+        {
+            // FinishFunction nonexistent host function
+            // pub fn finish() -> bool {
+            //     unsafe { host_lib::bad() >= 5 }
+            // }
+            auto const badWasmHex =
+                "0061736d010000000105016000017f02100108686f73745f6c696203626164"
+                "00000302010005030100100611027f00418080c0000b7f00418080c0000b07"
+                "2e04066d656d6f727902000666696e69736800010a5f5f646174615f656e64"
+                "03000b5f5f686561705f6261736503010a09010700100041044a0b004d0970"
+                "726f64756365727302086c616e6775616765010452757374000c70726f6365"
+                "737365642d6279010572757374631d312e38352e3120283465623136313235"
+                "3020323032352d30332d31352900490f7461726765745f6665617475726573"
+                "042b0f6d757461626c652d676c6f62616c732b087369676e2d6578742b0f72"
+                "65666572656e63652d74797065732b0a6d756c746976616c7565";
+            env(escrowCreate,
+                escrow::finish_function(badWasmHex),
+                escrow::cancel_time(env.now() + 100s),
+                fee(txnFees),
+                ter(temBAD_WASM));
+            env.close();
+        }
+    }
+
+    void
+    testFinishWasmFailures(FeatureBitset features)
+    {
+        testcase("EscrowFinish Smart Escrow failures");
+
+        using namespace jtx;
+        using namespace std::chrono;
+
+        Account const alice{"alice"};
+        Account const carol{"carol"};
+
+        // Tests whether the ledger index is >= 5
+        // getLedgerSqn() >= 5}
+        static auto wasmHex = ledgerSqnWasmHex;
+
+        {
+            // featureSmartEscrow disabled
+            Env env(*this, features - featureSmartEscrow);
+            env.fund(XRP(5000), alice, carol);
+            XRPAmount const txnFees =
+                env.current()->fees().base * 10 + wasmHex.size() / 2 * 5;
+            env(escrow::finish(carol, alice, 1),
+                fee(txnFees),
+                escrow::comp_allowance(4),
+                ter(temDISABLED));
+            env.close();
+        }
+
+        {
+            // ComputationAllowance > max compute limit
+            Env env(
+                *this,
+                envconfig([](std::unique_ptr<Config> cfg) {
+                    cfg->FEES.extension_compute_limit = 1'000;  // in gas
+                    return cfg;
+                }),
+                features);
+            env.fund(XRP(5000), alice, carol);
+            // Run past the flag ledger so that a Fee change vote occurs and
+            // updates FeeSettings. (It also activates all supported
+            // amendments.)
+            for (auto i = env.current()->seq(); i <= 257; ++i)
+                env.close();
+
+            auto const allowance = 1'001;
+            env(escrow::finish(carol, alice, 1),
+                fee(env.current()->fees().base + allowance),
+                escrow::comp_allowance(allowance),
+                ter(temBAD_LIMIT));
+        }
+
+        Env env(*this, features);
+
+        // Run past the flag ledger so that a Fee change vote occurs and
+        // updates FeeSettings. (It also activates all supported
+        // amendments.)
+        for (auto i = env.current()->seq(); i <= 257; ++i)
+            env.close();
+
+        XRPAmount const txnFees =
+            env.current()->fees().base * 10 + wasmHex.size() / 2 * 5;
+        env.fund(XRP(5000), alice, carol);
+
+        // create escrow
+        auto const seq = env.seq(alice);
+        env(escrow::create(alice, carol, XRP(500)),
+            escrow::finish_function(wasmHex),
+            escrow::cancel_time(env.now() + 100s),
+            fee(txnFees));
+        env.close();
+
+        {
+            // no ComputationAllowance field
+            env(escrow::finish(carol, alice, seq),
+                ter(tefWASM_FIELD_NOT_INCLUDED));
+        }
+
+        {
+            // ComputationAllowance value of 0
+            env(escrow::finish(carol, alice, seq),
+                escrow::comp_allowance(0),
+                ter(temBAD_LIMIT));
+        }
+
+        {
+            // not enough fees
+            // This function takes 4 gas
+            // In testing, 1 gas costs 1 drop
+            auto const finishFee = env.current()->fees().base;
+            env(escrow::finish(carol, alice, seq),
+                fee(finishFee),
+                escrow::comp_allowance(4),
+                ter(telINSUF_FEE_P));
+        }
+
+        {
+            // not enough gas
+            // This function takes 4 gas
+            // In testing, 1 gas costs 1 drop
+            auto const finishFee = env.current()->fees().base + 4;
+            env(escrow::finish(carol, alice, seq),
+                fee(finishFee),
+                escrow::comp_allowance(2),
+                ter(tecFAILED_PROCESSING));
+        }
+
+        {
+            // ComputationAllowance field included w/no FinishFunction on
+            // escrow
+            auto const seq2 = env.seq(alice);
+            env(escrow::create(alice, carol, XRP(500)),
+                escrow::finish_time(env.now() + 10s),
+                escrow::cancel_time(env.now() + 100s));
+            env.close();
+
+            auto const allowance = 100;
+            env(escrow::finish(carol, alice, seq2),
+                fee(env.current()->fees().base +
+                    (allowance * env.current()->fees().gasPrice) /
+                        MICRO_DROPS_PER_DROP +
+                    1),
+                escrow::comp_allowance(allowance),
+                ter(tefNO_WASM));
+        }
+    }
+
+    void
+    testFinishFunction(FeatureBitset features)
+    {
+        testcase("Example escrow function");
+
+        using namespace jtx;
+        using namespace std::chrono;
+
+        Account const alice{"alice"};
+        Account const carol{"carol"};
+
+        // Tests whether the ledger index is >= 5
+        // getLedgerSqn() >= 5}
+        auto const& wasmHex = ledgerSqnWasmHex;
+        std::uint32_t const allowance = 65;
+        auto escrowCreate = escrow::create(alice, carol, XRP(1000));
+        auto [createFee, finishFee] = [&]() {
+            Env env(*this, features);
+            auto createFee =
+                env.current()->fees().base * 10 + wasmHex.size() / 2 * 5;
+            auto finishFee = env.current()->fees().base +
+                (allowance * env.current()->fees().gasPrice) /
+                    MICRO_DROPS_PER_DROP +
+                1;
+            return std::make_pair(createFee, finishFee);
+        }();
+
+        {
+            // basic FinishFunction situation
+            Env env(*this, features);
+            // create escrow
+            env.fund(XRP(5000), alice, carol);
+            auto const seq = env.seq(alice);
+            BEAST_EXPECT(env.ownerCount(alice) == 0);
+            env(escrowCreate,
+                escrow::finish_function(wasmHex),
+                escrow::cancel_time(env.now() + 100s),
+                fee(createFee));
+            env.close();
+
+            if (BEAST_EXPECT(env.ownerCount(alice) == 2))
+            {
+                env.require(balance(alice, XRP(4000) - createFee));
+                env.require(balance(carol, XRP(5000)));
+
+                env(escrow::finish(carol, alice, seq),
+                    escrow::comp_allowance(allowance),
+                    fee(finishFee),
+                    ter(tecWASM_REJECTED));
+                env(escrow::finish(alice, alice, seq),
+                    escrow::comp_allowance(allowance),
+                    fee(finishFee),
+                    ter(tecWASM_REJECTED));
+                env(escrow::finish(alice, alice, seq),
+                    escrow::comp_allowance(allowance),
+                    fee(finishFee),
+                    ter(tecWASM_REJECTED));
+                env(escrow::finish(carol, alice, seq),
+                    escrow::comp_allowance(allowance),
+                    fee(finishFee),
+                    ter(tecWASM_REJECTED));
+                env(escrow::finish(carol, alice, seq),
+                    escrow::comp_allowance(allowance),
+                    fee(finishFee),
+                    ter(tecWASM_REJECTED));
+                env.close();
+
+                {
+                    auto const txMeta = env.meta();
+                    if (BEAST_EXPECT(txMeta->isFieldPresent(sfGasUsed)))
+                        BEAST_EXPECTS(
+                            env.meta()->getFieldU32(sfGasUsed) == allowance,
+                            std::to_string(env.meta()->getFieldU32(sfGasUsed)));
+                }
+
+                env(escrow::finish(alice, alice, seq),
+                    fee(finishFee),
+                    escrow::comp_allowance(allowance),
+                    ter(tesSUCCESS));
+
+                auto const txMeta = env.meta();
+                if (BEAST_EXPECT(txMeta->isFieldPresent(sfGasUsed)))
+                    BEAST_EXPECTS(
+                        txMeta->getFieldU32(sfGasUsed) == allowance,
+                        std::to_string(txMeta->getFieldU32(sfGasUsed)));
+                if (BEAST_EXPECT(txMeta->isFieldPresent(sfWasmReturnCode)))
+                    BEAST_EXPECTS(
+                        txMeta->getFieldI32(sfWasmReturnCode) == 5,
+                        std::to_string(txMeta->getFieldI32(sfWasmReturnCode)));
+
+                BEAST_EXPECT(env.ownerCount(alice) == 0);
+            }
+        }
+
+        {
+            // FinishFunction + Condition
+            Env env(*this, features);
+            env.fund(XRP(5000), alice, carol);
+            BEAST_EXPECT(env.ownerCount(alice) == 0);
+            auto const seq = env.seq(alice);
+            // create escrow
+            env(escrowCreate,
+                escrow::finish_function(wasmHex),
+                escrow::condition(escrow::cb1),
+                escrow::cancel_time(env.now() + 100s),
+                fee(createFee));
+            env.close();
+            auto const conditionFinishFee = finishFee +
+                env.current()->fees().base * (32 + (escrow::fb1.size() / 16));
+
+            if (BEAST_EXPECT(env.ownerCount(alice) == 2))
+            {
+                env.require(balance(alice, XRP(4000) - createFee));
+                env.require(balance(carol, XRP(5000)));
+
+                // no fulfillment provided, function fails
+                env(escrow::finish(carol, alice, seq),
+                    escrow::comp_allowance(allowance),
+                    fee(finishFee),
+                    ter(tecCRYPTOCONDITION_ERROR));
+                // fulfillment provided, function fails
+                env(escrow::finish(carol, alice, seq),
+                    escrow::condition(escrow::cb1),
+                    escrow::fulfillment(escrow::fb1),
+                    escrow::comp_allowance(allowance),
+                    fee(conditionFinishFee),
+                    ter(tecWASM_REJECTED));
+                if (BEAST_EXPECT(env.meta()->isFieldPresent(sfGasUsed)))
+                    BEAST_EXPECTS(
+                        env.meta()->getFieldU32(sfGasUsed) == allowance,
+                        std::to_string(env.meta()->getFieldU32(sfGasUsed)));
+                env.close();
+                // no fulfillment provided, function succeeds
+                env(escrow::finish(alice, alice, seq),
+                    escrow::comp_allowance(allowance),
+                    fee(conditionFinishFee),
+                    ter(tecCRYPTOCONDITION_ERROR));
+                // wrong fulfillment provided, function succeeds
+                env(escrow::finish(alice, alice, seq),
+                    escrow::condition(escrow::cb1),
+                    escrow::fulfillment(escrow::fb2),
+                    escrow::comp_allowance(allowance),
+                    fee(conditionFinishFee),
+                    ter(tecCRYPTOCONDITION_ERROR));
+                // fulfillment provided, function succeeds, tx succeeds
+                env(escrow::finish(alice, alice, seq),
+                    escrow::condition(escrow::cb1),
+                    escrow::fulfillment(escrow::fb1),
+                    escrow::comp_allowance(allowance),
+                    fee(conditionFinishFee),
+                    ter(tesSUCCESS));
+
+                auto const txMeta = env.meta();
+                if (BEAST_EXPECT(txMeta->isFieldPresent(sfGasUsed)))
+                    BEAST_EXPECT(txMeta->getFieldU32(sfGasUsed) == allowance);
+                if (BEAST_EXPECT(txMeta->isFieldPresent(sfWasmReturnCode)))
+                    BEAST_EXPECTS(
+                        txMeta->getFieldI32(sfWasmReturnCode) == 6,
+                        std::to_string(txMeta->getFieldI32(sfWasmReturnCode)));
+
+                env.close();
+                BEAST_EXPECT(env.ownerCount(alice) == 0);
+            }
+        }
+
+        {
+            // FinishFunction + FinishAfter
+            Env env(*this, features);
+            // create escrow
+            env.fund(XRP(5000), alice, carol);
+            auto const seq = env.seq(alice);
+            BEAST_EXPECT(env.ownerCount(alice) == 0);
+            auto const ts = env.now() + 97s;
+            env(escrowCreate,
+                escrow::finish_function(wasmHex),
+                escrow::finish_time(ts),
+                escrow::cancel_time(env.now() + 1000s),
+                fee(createFee));
+            env.close();
+
+            if (BEAST_EXPECT(env.ownerCount(alice) == 2))
+            {
+                env.require(balance(alice, XRP(4000) - createFee));
+                env.require(balance(carol, XRP(5000)));
+
+                // finish time hasn't passed, function fails
+                env(escrow::finish(carol, alice, seq),
+                    escrow::comp_allowance(allowance),
+                    fee(finishFee + 1),
+                    ter(tecNO_PERMISSION));
+                env.close();
+                // finish time hasn't passed, function succeeds
+                for (; env.now() < ts; env.close())
+                    env(escrow::finish(carol, alice, seq),
+                        escrow::comp_allowance(allowance),
+                        fee(finishFee + 2),
+                        ter(tecNO_PERMISSION));
+
+                env(escrow::finish(carol, alice, seq),
+                    escrow::comp_allowance(allowance),
+                    fee(finishFee + 1),
+                    ter(tesSUCCESS));
+
+                auto const txMeta = env.meta();
+                if (BEAST_EXPECT(txMeta->isFieldPresent(sfGasUsed)))
+                    BEAST_EXPECT(txMeta->getFieldU32(sfGasUsed) == allowance);
+                if (BEAST_EXPECT(txMeta->isFieldPresent(sfWasmReturnCode)))
+                    BEAST_EXPECTS(
+                        txMeta->getFieldI32(sfWasmReturnCode) == 13,
+                        std::to_string(txMeta->getFieldI32(sfWasmReturnCode)));
+
+                BEAST_EXPECT(env.ownerCount(alice) == 0);
+            }
+        }
+
+        {
+            // FinishFunction + FinishAfter #2
+            Env env(*this, features);
+            // create escrow
+            env.fund(XRP(5000), alice, carol);
+            auto const seq = env.seq(alice);
+            BEAST_EXPECT(env.ownerCount(alice) == 0);
+            env(escrowCreate,
+                escrow::finish_function(wasmHex),
+                escrow::finish_time(env.now() + 2s),
+                escrow::cancel_time(env.now() + 100s),
+                fee(createFee));
+            // Don't close the ledger here
+
+            if (BEAST_EXPECT(env.ownerCount(alice) == 2))
+            {
+                env.require(balance(alice, XRP(4000) - createFee));
+                env.require(balance(carol, XRP(5000)));
+
+                // finish time hasn't passed, function fails
+                env(escrow::finish(carol, alice, seq),
+                    escrow::comp_allowance(allowance),
+                    fee(finishFee),
+                    ter(tecNO_PERMISSION));
+                env.close();
+
+                // finish time has passed, function fails
+                env(escrow::finish(carol, alice, seq),
+                    escrow::comp_allowance(allowance),
+                    fee(finishFee),
+                    ter(tecWASM_REJECTED));
+                if (BEAST_EXPECT(env.meta()->isFieldPresent(sfGasUsed)))
+                    BEAST_EXPECTS(
+                        env.meta()->getFieldU32(sfGasUsed) == allowance,
+                        std::to_string(env.meta()->getFieldU32(sfGasUsed)));
+                env.close();
+                // finish time has passed, function succeeds, tx succeeds
+                env(escrow::finish(carol, alice, seq),
+                    escrow::comp_allowance(allowance),
+                    fee(finishFee),
+                    ter(tesSUCCESS));
+
+                auto const txMeta = env.meta();
+                if (BEAST_EXPECT(txMeta->isFieldPresent(sfGasUsed)))
+                    BEAST_EXPECT(txMeta->getFieldU32(sfGasUsed) == allowance);
+                if (BEAST_EXPECT(txMeta->isFieldPresent(sfWasmReturnCode)))
+                    BEAST_EXPECTS(
+                        txMeta->getFieldI32(sfWasmReturnCode) == 6,
+                        std::to_string(txMeta->getFieldI32(sfWasmReturnCode)));
+
+                env.close();
+                BEAST_EXPECT(env.ownerCount(alice) == 0);
+            }
+        }
+    }
+
+    void
+    testUpdateDataOnFailure(FeatureBitset features)
+    {
+        testcase("Update escrow data on failure");
+
+        using namespace jtx;
+        using namespace std::chrono;
+
+        // wasm that always fails
+        static auto const wasmHex = updateDataWasmHex;
+
+        Account const alice{"alice"};
+        Account const carol{"carol"};
+
+        Env env(*this, features);
+        // create escrow
+        env.fund(XRP(5000), alice);
+        auto const seq = env.seq(alice);
+        BEAST_EXPECT(env.ownerCount(alice) == 0);
+        auto escrowCreate = escrow::create(alice, alice, XRP(1000));
+        XRPAmount txnFees =
+            env.current()->fees().base * 10 + wasmHex.size() / 2 * 5;
+        env(escrowCreate,
+            escrow::finish_function(wasmHex),
+            escrow::finish_time(env.now() + 2s),
+            escrow::cancel_time(env.now() + 100s),
+            fee(txnFees));
+        env.close();
+        env.close();
+        env.close();
+
+        if (BEAST_EXPECT(
+                env.ownerCount(alice) == (1 + wasmHex.size() / 2 / 500)))
+        {
+            env.require(balance(alice, XRP(4000) - txnFees));
+
+            auto const allowance = 1014;
+            XRPAmount const finishFee = env.current()->fees().base +
+                (allowance * env.current()->fees().gasPrice) /
+                    MICRO_DROPS_PER_DROP +
+                1;
+
+            // FinishAfter time hasn't passed
+            env(escrow::finish(alice, alice, seq),
+                escrow::comp_allowance(allowance),
+                fee(finishFee),
+                ter(tecWASM_REJECTED));
+
+            auto const txMeta = env.meta();
+            if (BEAST_EXPECT(txMeta && txMeta->isFieldPresent(sfGasUsed)))
+                BEAST_EXPECTS(
+                    txMeta->getFieldU32(sfGasUsed) == allowance,
+                    std::to_string(txMeta->getFieldU32(sfGasUsed)));
+            if (BEAST_EXPECT(txMeta->isFieldPresent(sfWasmReturnCode)))
+                BEAST_EXPECTS(
+                    txMeta->getFieldI32(sfWasmReturnCode) == -256,
+                    std::to_string(txMeta->getFieldI32(sfWasmReturnCode)));
+
+            auto const sle = env.le(keylet::escrow(alice, seq));
+            if (BEAST_EXPECT(sle && sle->isFieldPresent(sfData)))
+                BEAST_EXPECTS(
+                    checkVL(sle, sfData, "Data"),
+                    strHex(sle->getFieldVL(sfData)));
+        }
+    }
+
+    void
+    testAllHostFunctions(FeatureBitset features)
+    {
+        testcase("Test all host functions");
+
+        using namespace jtx;
+        using namespace std::chrono;
+
+        // TODO: create wasm module for all host functions
+        static auto wasmHex = allHostFunctionsWasmHex;
+
+        Account const alice{"alice"};
+        Account const carol{"carol"};
+
+        {
+            Env env(*this, features);
+            // create escrow
+            env.fund(XRP(5000), alice, carol);
+            auto const seq = env.seq(alice);
+            BEAST_EXPECT(env.ownerCount(alice) == 0);
+            auto escrowCreate = escrow::create(alice, carol, XRP(1000));
+            XRPAmount txnFees =
+                env.current()->fees().base * 10 + wasmHex.size() / 2 * 5;
+            env(escrowCreate,
+                escrow::finish_function(wasmHex),
+                escrow::finish_time(env.now() + 11s),
+                escrow::cancel_time(env.now() + 100s),
+                escrow::data("1000000000"),  // 1000 XRP in drops
+                fee(txnFees));
+            env.close();
+
+            if (BEAST_EXPECT(
+                    env.ownerCount(alice) == (1 + wasmHex.size() / 2 / 500)))
+            {
+                env.require(balance(alice, XRP(4000) - txnFees));
+                env.require(balance(carol, XRP(5000)));
+
+                auto const allowance = 1'000'000;
+                XRPAmount const finishFee = env.current()->fees().base +
+                    (allowance * env.current()->fees().gasPrice) /
+                        MICRO_DROPS_PER_DROP +
+                    1;
+
+                // FinishAfter time hasn't passed
+                env(escrow::finish(carol, alice, seq),
+                    escrow::comp_allowance(allowance),
+                    fee(finishFee),
+                    ter(tecNO_PERMISSION));
+                env.close();
+                env.close();
+                env.close();
+
+                // reduce the destination balance
+                env(pay(carol, alice, XRP(4500)));
+                env.close();
+                env.close();
+
+                env(escrow::finish(alice, alice, seq),
+                    escrow::comp_allowance(allowance),
+                    fee(finishFee),
+                    ter(tesSUCCESS));
+
+                auto const txMeta = env.meta();
+                if (BEAST_EXPECT(txMeta && txMeta->isFieldPresent(sfGasUsed)))
+                    BEAST_EXPECTS(
+                        txMeta->getFieldU32(sfGasUsed) == 38'554,
+                        std::to_string(txMeta->getFieldU32(sfGasUsed)));
+                if (BEAST_EXPECT(txMeta->isFieldPresent(sfWasmReturnCode)))
+                    BEAST_EXPECT(txMeta->getFieldI32(sfWasmReturnCode) == 1);
+
+                env.close();
+                BEAST_EXPECT(env.ownerCount(alice) == 0);
+            }
+        }
+    }
+
+    void
+    testKeyletHostFunctions(FeatureBitset features)
+    {
+        testcase("Test all keylet host functions");
+
+        using namespace jtx;
+        using namespace std::chrono;
+
+        // TODO: create wasm module for all host functions
+        static auto wasmHex = allKeyletsWasmHex;
+
+        Account const alice{"alice"};
+        Account const carol{"carol"};
+
+        {
+            Env env{*this};
+            env.fund(XRP(10000), alice, carol);
+
+            BEAST_EXPECT(env.seq(alice) == 4);
+            BEAST_EXPECT(env.ownerCount(alice) == 0);
+
+            // base objects that need to be created first
+            auto const tokenId =
+                token::getNextID(env, alice, 0, tfTransferable);
+            env(token::mint(alice, 0u), txflags(tfTransferable));
+            env(trust(alice, carol["USD"](1'000'000)));
+            env.close();
+            BEAST_EXPECT(env.seq(alice) == 6);
+            BEAST_EXPECT(env.ownerCount(alice) == 2);
+
+            // set up a bunch of objects to check their keylets
+            AMM amm(env, carol, XRP(10), carol["USD"](1000));
+            env(check::create(alice, carol, XRP(100)));
+            env(credentials::create(alice, alice, "termsandconditions"));
+            env(delegate::set(alice, carol, {"TrustSet"}));
+            env(deposit::auth(alice, carol));
+            env(did::set(alice), did::data("alice_did"));
+            env(escrow::create(alice, carol, XRP(100)),
+                escrow::finish_time(env.now() + 100s));
+            MPTTester mptTester{env, alice, {.fund = false}};
+            mptTester.create();
+            mptTester.authorize({.account = carol});
+            env(token::createOffer(carol, tokenId, XRP(100)),
+                token::owner(alice));
+            env(offer(alice, carol["GBP"](0.1), XRP(100)));
+            env(paychan::create(alice, carol, XRP(1000), 100s, alice.pk()));
+            pdomain::Credentials credentials{{alice, "first credential"}};
+            env(pdomain::setTx(alice, credentials));
+            env(signers(alice, 1, {{carol, 1}}));
+            env(ticket::create(alice, 1));
+            Vault vault{env};
+            auto [tx, _keylet] =
+                vault.create({.owner = alice, .asset = xrpIssue()});
+            env(tx);
+            env.close();
+
+            BEAST_EXPECTS(
+                env.ownerCount(alice) == 17,
+                std::to_string(env.ownerCount(alice)));
+            if (BEAST_EXPECTS(
+                    env.seq(alice) == 20, std::to_string(env.seq(alice))))
+            {
+                auto const seq = env.seq(alice);
+                XRPAmount txnFees =
+                    env.current()->fees().base * 10 + wasmHex.size() / 2 * 5;
+                env(escrow::create(alice, carol, XRP(1000)),
+                    escrow::finish_function(wasmHex),
+                    escrow::finish_time(env.now() + 2s),
+                    escrow::cancel_time(env.now() + 100s),
+                    fee(txnFees));
+                env.close();
+                env.close();
+                env.close();
+
+                auto const allowance = 138'485;
+                auto const finishFee = env.current()->fees().base +
+                    (allowance * env.current()->fees().gasPrice) /
+                        MICRO_DROPS_PER_DROP +
+                    1;
+                env(escrow::finish(carol, alice, seq),
+                    escrow::comp_allowance(allowance),
+                    fee(finishFee));
+                env.close();
+
+                auto const txMeta = env.meta();
+                if (BEAST_EXPECT(txMeta && txMeta->isFieldPresent(sfGasUsed)))
+                {
+                    auto const gasUsed = txMeta->getFieldU32(sfGasUsed);
+                    BEAST_EXPECTS(
+                        gasUsed == allowance, std::to_string(gasUsed));
+                }
+                BEAST_EXPECTS(
+                    env.ownerCount(alice) == 17,
+                    std::to_string(env.ownerCount(alice)));
+            }
+        }
+    }
+
+    void
+    testWithFeats(FeatureBitset features)
+    {
+        testCreateFinishFunctionPreflight(features);
+        testFinishWasmFailures(features);
+        testFinishFunction(features);
+        testUpdateDataOnFailure(features);
+
+        // TODO: Update module with new host functions
+        testAllHostFunctions(features);
+        testKeyletHostFunctions(features);
+    }
+
+public:
+    void
+    run() override
+    {
+        using namespace test::jtx;
+        FeatureBitset const all{testable_amendments()};
+        testWithFeats(all);
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(EscrowSmart, app, ripple);
+
+}  // namespace test
+}  // namespace ripple
@@ -1507,7 +1507,7 @@ struct Escrow_test : public beast::unit_test::suite
        Account const alice{"alice"};
        Account const bob{"bob"};
        Account const carol{"carol"};
-        Account const dillon{"dillon "};
+        Account const dillon{"dillon"};
        Account const zelda{"zelda"};

        char const credType[] = "abcde";
@@ -1674,6 +1674,8 @@ public:
        FeatureBitset const all{testable_amendments()};
        testWithFeats(all);
        testWithFeats(all - featureTokenEscrow);
+        testWithFeats(all - featureSmartEscrow);
+        testWithFeats(all - featureTokenEscrow - featureSmartEscrow);
        testTags(all - fixIncludeKeyletFields);
    }
 };
@@ -24,13 +24,17 @@ struct FeeSettingsFields
    std::optional<XRPAmount> baseFeeDrops = std::nullopt;
    std::optional<XRPAmount> reserveBaseDrops = std::nullopt;
    std::optional<XRPAmount> reserveIncrementDrops = std::nullopt;
+    std::optional<std::uint32_t> extensionComputeLimit = std::nullopt;
+    std::optional<std::uint32_t> extensionSizeLimit = std::nullopt;
+    std::optional<std::uint32_t> gasPrice = std::nullopt;
 };

 STTx
 createFeeTx(
    Rules const& rules,
    std::uint32_t seq,
-    FeeSettingsFields const& fields)
+    FeeSettingsFields const& fields,
+    bool forceAllFields = false)
 {
    auto fill = [&](auto& obj) {
        obj.setAccountID(sfAccount, AccountID());
@@ -64,6 +68,17 @@ createFeeTx(
                sfReferenceFeeUnits,
                fields.referenceFeeUnits ? *fields.referenceFeeUnits : 0);
        }
+        if (rules.enabled(featureSmartEscrow) || forceAllFields)
+        {
+            obj.setFieldU32(
+                sfExtensionComputeLimit,
+                fields.extensionComputeLimit ? *fields.extensionComputeLimit
+                                             : 0);
+            obj.setFieldU32(
+                sfExtensionSizeLimit,
+                fields.extensionSizeLimit ? *fields.extensionSizeLimit : 0);
+            obj.setFieldU32(sfGasPrice, fields.gasPrice ? *fields.gasPrice : 0);
+        }
    };
    return STTx(ttFEE, fill);
 }
@@ -112,6 +127,12 @@ createInvalidFeeTx(
                obj.setFieldU32(sfReserveIncrement, 50000);
                obj.setFieldU32(sfReferenceFeeUnits, 10);
            }
+            if (rules.enabled(featureSmartEscrow))
+            {
+                obj.setFieldU32(sfExtensionComputeLimit, 100 + uniqueValue);
+                obj.setFieldU32(sfExtensionSizeLimit, 200 + uniqueValue);
+                obj.setFieldU32(sfGasPrice, 300 + uniqueValue);
+            }
        }
        // If missingRequiredFields is true, we don't add the required fields
        // (default behavior)
@@ -119,12 +140,12 @@ createInvalidFeeTx(
    return STTx(ttFEE, fill);
 }

-bool
+TER
 applyFeeAndTestResult(jtx::Env& env, OpenView& view, STTx const& tx)
 {
    auto const res =
        apply(env.app(), view, tx, ApplyFlags::tapNONE, env.journal);
-    return res.ter == tesSUCCESS;
+    return res.ter;
 }

 bool
@@ -180,6 +201,25 @@ verifyFeeObject(
        if (!checkEquality(sfReferenceFeeUnits, expected.referenceFeeUnits))
            return false;
    }
+    if (rules.enabled(featureSmartEscrow))
+    {
+        if (!checkEquality(
+                sfExtensionComputeLimit,
+                expected.extensionComputeLimit.value_or(0)))
+            return false;
+        if (!checkEquality(
+                sfExtensionSizeLimit, expected.extensionSizeLimit.value_or(0)))
+            return false;
+        if (!checkEquality(sfGasPrice, expected.gasPrice.value_or(0)))
+            return false;
+    }
+    else
+    {
+        if (feeObject->isFieldPresent(sfExtensionComputeLimit) ||
+            feeObject->isFieldPresent(sfExtensionSizeLimit) ||
+            feeObject->isFieldPresent(sfGasPrice))
+            return false;
+    }

    return true;
 }
@@ -202,6 +242,7 @@ class FeeVote_test : public beast::unit_test::suite
    void
    testSetup()
    {
+        testcase("FeeVote setup");
        FeeSetup const defaultSetup;
        {
            // defaults
@@ -210,36 +251,62 @@ class FeeVote_test : public beast::unit_test::suite
            BEAST_EXPECT(setup.reference_fee == defaultSetup.reference_fee);
            BEAST_EXPECT(setup.account_reserve == defaultSetup.account_reserve);
            BEAST_EXPECT(setup.owner_reserve == defaultSetup.owner_reserve);
+            BEAST_EXPECT(
+                setup.extension_compute_limit ==
+                defaultSetup.extension_compute_limit);
+            BEAST_EXPECT(
+                setup.extension_size_limit ==
+                defaultSetup.extension_size_limit);
+            BEAST_EXPECT(setup.gas_price == defaultSetup.gas_price);
        }
        {
            Section config;
            config.append(
                {"reference_fee = 50",
                 "account_reserve = 1234567",
-                 "owner_reserve = 1234"});
+                 "owner_reserve = 1234",
+                 "extension_compute_limit = 100",
+                 "extension_size_limit = 200",
+                 " gas_price = 300"});
            auto setup = setup_FeeVote(config);
            BEAST_EXPECT(setup.reference_fee == 50);
            BEAST_EXPECT(setup.account_reserve == 1234567);
            BEAST_EXPECT(setup.owner_reserve == 1234);
+            BEAST_EXPECT(setup.extension_compute_limit == 100);
+            BEAST_EXPECT(setup.extension_size_limit == 200);
+            BEAST_EXPECT(setup.gas_price == 300);
        }
        {
            Section config;
            config.append(
                {"reference_fee = blah",
                 "account_reserve = yada",
-                 "owner_reserve = foo"});
+                 "owner_reserve = foo",
+                 "extension_compute_limit = bar",
+                 "extension_size_limit = baz",
+                 "gas_price = qux"});
            // Illegal values are ignored, and the defaults left unchanged
            auto setup = setup_FeeVote(config);
            BEAST_EXPECT(setup.reference_fee == defaultSetup.reference_fee);
            BEAST_EXPECT(setup.account_reserve == defaultSetup.account_reserve);
            BEAST_EXPECT(setup.owner_reserve == defaultSetup.owner_reserve);
+            BEAST_EXPECT(
+                setup.extension_compute_limit ==
+                defaultSetup.extension_compute_limit);
+            BEAST_EXPECT(
+                setup.extension_size_limit ==
+                defaultSetup.extension_size_limit);
+            BEAST_EXPECT(setup.gas_price == defaultSetup.gas_price);
        }
        {
            Section config;
            config.append(
                {"reference_fee = -50",
                 "account_reserve = -1234567",
-                 "owner_reserve = -1234"});
+                 "owner_reserve = -1234",
+                 "extension_compute_limit = -100",
+                 "extension_size_limit = -200",
+                 "gas_price = -300"});
            // Illegal values are ignored, and the defaults left unchanged
            auto setup = setup_FeeVote(config);
            BEAST_EXPECT(setup.reference_fee == defaultSetup.reference_fee);
@@ -247,6 +314,12 @@ class FeeVote_test : public beast::unit_test::suite
                setup.account_reserve == static_cast<std::uint32_t>(-1234567));
            BEAST_EXPECT(
                setup.owner_reserve == static_cast<std::uint32_t>(-1234));
+            BEAST_EXPECT(
+                setup.extension_compute_limit ==
+                static_cast<std::uint32_t>(-100));
+            BEAST_EXPECT(
+                setup.extension_size_limit == static_cast<std::uint32_t>(-200));
+            BEAST_EXPECT(setup.gas_price == static_cast<std::uint32_t>(-300));
        }
        {
            auto const big64 = std::to_string(
@@ -257,12 +330,22 @@ class FeeVote_test : public beast::unit_test::suite
            config.append(
                {"reference_fee = " + big64,
                 "account_reserve = " + big64,
-                 "owner_reserve = " + big64});
+                 "owner_reserve = " + big64,
+                 "extension_compute_limit = " + big64,
+                 "extension_size_limit = " + big64,
+                 "gas_price = " + big64});
            // Illegal values are ignored, and the defaults left unchanged
            auto setup = setup_FeeVote(config);
            BEAST_EXPECT(setup.reference_fee == defaultSetup.reference_fee);
            BEAST_EXPECT(setup.account_reserve == defaultSetup.account_reserve);
            BEAST_EXPECT(setup.owner_reserve == defaultSetup.owner_reserve);
+            BEAST_EXPECT(
+                setup.extension_compute_limit ==
+                defaultSetup.extension_compute_limit);
+            BEAST_EXPECT(
+                setup.extension_size_limit ==
+                defaultSetup.extension_size_limit);
+            BEAST_EXPECT(setup.gas_price == defaultSetup.gas_price);
        }
    }

@@ -273,7 +356,10 @@ class FeeVote_test : public beast::unit_test::suite

        // Test with XRPFees disabled (legacy format)
        {
-            jtx::Env env(*this, jtx::testable_amendments() - featureXRPFees);
+            jtx::Env env(
+                *this,
+                jtx::testable_amendments() - featureXRPFees -
+                    featureSmartEscrow);
            auto ledger = std::make_shared<Ledger>(
                create_genesis,
                env.app().config(),
@@ -294,7 +380,8 @@ class FeeVote_test : public beast::unit_test::suite
            auto feeTx = createFeeTx(ledger->rules(), ledger->seq(), fields);

            OpenView accum(ledger.get());
-            BEAST_EXPECT(applyFeeAndTestResult(env, accum, feeTx));
+            BEAST_EXPECT(
+                isTesSuccess(applyFeeAndTestResult(env, accum, feeTx)));
            accum.apply(*ledger);

            // Verify fee object was created/updated correctly
@@ -303,7 +390,8 @@ class FeeVote_test : public beast::unit_test::suite

        // Test with XRPFees enabled (new format)
        {
-            jtx::Env env(*this, jtx::testable_amendments() | featureXRPFees);
+            jtx::Env env(
+                *this, jtx::testable_amendments() - featureSmartEscrow);
            auto ledger = std::make_shared<Ledger>(
                create_genesis,
                env.app().config(),
@@ -322,12 +410,76 @@ class FeeVote_test : public beast::unit_test::suite
            auto feeTx = createFeeTx(ledger->rules(), ledger->seq(), fields);

            OpenView accum(ledger.get());
-            BEAST_EXPECT(applyFeeAndTestResult(env, accum, feeTx));
+            BEAST_EXPECT(
+                isTesSuccess(applyFeeAndTestResult(env, accum, feeTx)));
            accum.apply(*ledger);

            // Verify fee object was created/updated correctly
            BEAST_EXPECT(verifyFeeObject(ledger, ledger->rules(), fields));
        }
+
+        // Test with both XRPFees and SmartEscrow enabled
+        {
+            jtx::Env env(*this, jtx::testable_amendments());
+            auto ledger = std::make_shared<Ledger>(
+                create_genesis,
+                env.app().config(),
+                std::vector<uint256>{},
+                env.app().getNodeFamily());
+
+            // Create the next ledger to apply transaction to
+            ledger = std::make_shared<Ledger>(
+                *ledger, env.app().timeKeeper().closeTime());
+
+            FeeSettingsFields fields{
+                .baseFeeDrops = XRPAmount{10},
+                .reserveBaseDrops = XRPAmount{200000},
+                .reserveIncrementDrops = XRPAmount{50000},
+                .extensionComputeLimit = 100,
+                .extensionSizeLimit = 200,
+                .gasPrice = 300};
+            // Test successful fee transaction with new fields
+            auto feeTx = createFeeTx(ledger->rules(), ledger->seq(), fields);
+
+            OpenView accum(ledger.get());
+            BEAST_EXPECT(
+                isTesSuccess(applyFeeAndTestResult(env, accum, feeTx)));
+            accum.apply(*ledger);
+
+            // Verify fee object was created/updated correctly
+            BEAST_EXPECT(verifyFeeObject(ledger, ledger->rules(), fields));
+        }
+
+        // Test that the Smart Escrow fields are rejected if the
+        // feature is disabled
+        {
+            jtx::Env env(
+                *this, jtx::testable_amendments() - featureSmartEscrow);
+            auto ledger = std::make_shared<Ledger>(
+                create_genesis,
+                env.app().config(),
+                std::vector<uint256>{},
+                env.app().getNodeFamily());
+
+            // Create the next ledger to apply transaction to
+            ledger = std::make_shared<Ledger>(
+                *ledger, env.app().timeKeeper().closeTime());
+
+            FeeSettingsFields fields{
+                .baseFeeDrops = XRPAmount{10},
+                .reserveBaseDrops = XRPAmount{200000},
+                .reserveIncrementDrops = XRPAmount{50000},
+                .extensionComputeLimit = 100,
+                .extensionSizeLimit = 200,
+                .gasPrice = 300};
+            // Test successful fee transaction with new fields
+            auto feeTx =
+                createFeeTx(ledger->rules(), ledger->seq(), fields, true);
+
+            OpenView accum(ledger.get());
+            BEAST_EXPECT(
+                !isTesSuccess(applyFeeAndTestResult(env, accum, feeTx)));
+        }
    }

    void
@@ -336,7 +488,10 @@ class FeeVote_test : public beast::unit_test::suite
        testcase("Fee Transaction Validation");

        {
-            jtx::Env env(*this, jtx::testable_amendments() - featureXRPFees);
+            jtx::Env env(
+                *this,
+                jtx::testable_amendments() - featureXRPFees -
+                    featureSmartEscrow);
            auto ledger = std::make_shared<Ledger>(
                create_genesis,
                env.app().config(),
@@ -351,16 +506,19 @@ class FeeVote_test : public beast::unit_test::suite
            auto invalidTx = createInvalidFeeTx(
                ledger->rules(), ledger->seq(), true, false, 1);
            OpenView accum(ledger.get());
-            BEAST_EXPECT(!applyFeeAndTestResult(env, accum, invalidTx));
+            BEAST_EXPECT(
+                !isTesSuccess(applyFeeAndTestResult(env, accum, invalidTx)));

            // Test transaction with new format fields when XRPFees is disabled
            auto disallowedTx = createInvalidFeeTx(
                ledger->rules(), ledger->seq(), false, true, 2);
-            BEAST_EXPECT(!applyFeeAndTestResult(env, accum, disallowedTx));
+            BEAST_EXPECT(
+                !isTesSuccess(applyFeeAndTestResult(env, accum, disallowedTx)));
        }

        {
-            jtx::Env env(*this, jtx::testable_amendments() | featureXRPFees);
+            jtx::Env env(
+                *this, jtx::testable_amendments() - featureSmartEscrow);
            auto ledger = std::make_shared<Ledger>(
                create_genesis,
                env.app().config(),
@@ -375,12 +533,43 @@ class FeeVote_test : public beast::unit_test::suite
            auto invalidTx = createInvalidFeeTx(
                ledger->rules(), ledger->seq(), true, false, 3);
            OpenView accum(ledger.get());
-            BEAST_EXPECT(!applyFeeAndTestResult(env, accum, invalidTx));
+            BEAST_EXPECT(
+                !isTesSuccess(applyFeeAndTestResult(env, accum, invalidTx)));

            // Test transaction with legacy fields when XRPFees is enabled
            auto disallowedTx = createInvalidFeeTx(
                ledger->rules(), ledger->seq(), false, true, 4);
-            BEAST_EXPECT(!applyFeeAndTestResult(env, accum, disallowedTx));
+            BEAST_EXPECT(
+                !isTesSuccess(applyFeeAndTestResult(env, accum, disallowedTx)));
+        }
+
+        {
+            jtx::Env env(
+                *this,
+                jtx::testable_amendments() | featureXRPFees |
+                    featureSmartEscrow);
+            auto ledger = std::make_shared<Ledger>(
+                create_genesis,
+                env.app().config(),
+                std::vector<uint256>{},
+                env.app().getNodeFamily());
+
+            // Create the next ledger to apply transaction to
+            ledger = std::make_shared<Ledger>(
+                *ledger, env.app().timeKeeper().closeTime());
+
+            // Test transaction with missing required new fields
+            auto invalidTx = createInvalidFeeTx(
+                ledger->rules(), ledger->seq(), true, false, 5);
+            OpenView accum(ledger.get());
+            BEAST_EXPECT(
+                !isTesSuccess(applyFeeAndTestResult(env, accum, invalidTx)));
+
+            // Test transaction with legacy fields when XRPFees is enabled
+            auto disallowedTx = createInvalidFeeTx(
+                ledger->rules(), ledger->seq(), false, true, 6);
+            BEAST_EXPECT(
+                !isTesSuccess(applyFeeAndTestResult(env, accum, disallowedTx)));
        }
    }

@@ -389,7 +578,7 @@ class FeeVote_test : public beast::unit_test::suite
    {
        testcase("Pseudo Transaction Properties");

-        jtx::Env env(*this, jtx::testable_amendments());
+        jtx::Env env(*this, jtx::testable_amendments() - featureSmartEscrow);
        auto ledger = std::make_shared<Ledger>(
            create_genesis,
            env.app().config(),
@@ -419,7 +608,8 @@ class FeeVote_test : public beast::unit_test::suite
        // But can be applied to a closed ledger
        {
            OpenView closedAccum(ledger.get());
-            BEAST_EXPECT(applyFeeAndTestResult(env, closedAccum, feeTx));
+            BEAST_EXPECT(
+                isTesSuccess(applyFeeAndTestResult(env, closedAccum, feeTx)));
        }
    }

@@ -428,7 +618,7 @@ class FeeVote_test : public beast::unit_test::suite
    {
        testcase("Multiple Fee Updates");

-        jtx::Env env(*this, jtx::testable_amendments() | featureXRPFees);
+        jtx::Env env(*this, jtx::testable_amendments() - featureSmartEscrow);
        auto ledger = std::make_shared<Ledger>(
            create_genesis,
            env.app().config(),
@@ -446,7 +636,8 @@ class FeeVote_test : public beast::unit_test::suite

        {
            OpenView accum(ledger.get());
-            BEAST_EXPECT(applyFeeAndTestResult(env, accum, feeTx1));
+            BEAST_EXPECT(
+                isTesSuccess(applyFeeAndTestResult(env, accum, feeTx1)));
            accum.apply(*ledger);
        }

@@ -464,7 +655,8 @@ class FeeVote_test : public beast::unit_test::suite

        {
            OpenView accum(ledger.get());
-            BEAST_EXPECT(applyFeeAndTestResult(env, accum, feeTx2));
+            BEAST_EXPECT(
+                isTesSuccess(applyFeeAndTestResult(env, accum, feeTx2)));
            accum.apply(*ledger);
        }

@@ -477,7 +669,7 @@ class FeeVote_test : public beast::unit_test::suite
    {
        testcase("Wrong Ledger Sequence");

-        jtx::Env env(*this, jtx::testable_amendments() | featureXRPFees);
+        jtx::Env env(*this, jtx::testable_amendments() - featureSmartEscrow);
        auto ledger = std::make_shared<Ledger>(
            create_genesis,
            env.app().config(),
@@ -500,7 +692,7 @@ class FeeVote_test : public beast::unit_test::suite
        // The transaction should still succeed as long as other fields are
        // valid
        // The ledger sequence field is only used for informational purposes
-        BEAST_EXPECT(applyFeeAndTestResult(env, accum, feeTx));
+        BEAST_EXPECT(isTesSuccess(applyFeeAndTestResult(env, accum, feeTx)));
    }

    void
@@ -508,7 +700,7 @@ class FeeVote_test : public beast::unit_test::suite
    {
        testcase("Partial Field Updates");

-        jtx::Env env(*this, jtx::testable_amendments() | featureXRPFees);
+        jtx::Env env(*this, jtx::testable_amendments() - featureSmartEscrow);
        auto ledger = std::make_shared<Ledger>(
            create_genesis,
            env.app().config(),
@@ -526,7 +718,8 @@ class FeeVote_test : public beast::unit_test::suite

        {
            OpenView accum(ledger.get());
-            BEAST_EXPECT(applyFeeAndTestResult(env, accum, feeTx1));
+            BEAST_EXPECT(
+                isTesSuccess(applyFeeAndTestResult(env, accum, feeTx1)));
            accum.apply(*ledger);
        }

@@ -543,7 +736,8 @@ class FeeVote_test : public beast::unit_test::suite

        {
            OpenView accum(ledger.get());
-            BEAST_EXPECT(applyFeeAndTestResult(env, accum, feeTx2));
+            BEAST_EXPECT(
+                isTesSuccess(applyFeeAndTestResult(env, accum, feeTx2)));
            accum.apply(*ledger);
        }

@@ -556,7 +750,7 @@ class FeeVote_test : public beast::unit_test::suite
    {
        testcase("Single Invalid Transaction");

-        jtx::Env env(*this, jtx::testable_amendments() | featureXRPFees);
+        jtx::Env env(*this, jtx::testable_amendments() - featureSmartEscrow);
        auto ledger = std::make_shared<Ledger>(
            create_genesis,
            env.app().config(),
@@ -579,7 +773,8 @@ class FeeVote_test : public beast::unit_test::suite
        });

        OpenView accum(ledger.get());
-        BEAST_EXPECT(!applyFeeAndTestResult(env, accum, invalidTx));
+        BEAST_EXPECT(
+            !isTesSuccess(applyFeeAndTestResult(env, accum, invalidTx)));
    }

    void
@@ -596,7 +791,7 @@ class FeeVote_test : public beast::unit_test::suite

        // Test with XRPFees enabled
        {
-            Env env(*this, testable_amendments() | featureXRPFees);
+            Env env(*this, testable_amendments() - featureSmartEscrow);
            auto feeVote = make_FeeVote(setup, env.app().journal("FeeVote"));

            auto ledger = std::make_shared<Ledger>(
@@ -631,7 +826,9 @@ class FeeVote_test : public beast::unit_test::suite

        // Test with XRPFees disabled (legacy format)
        {
-            Env env(*this, testable_amendments() - featureXRPFees);
+            Env env(
+                *this,
+                testable_amendments() - featureXRPFees - featureSmartEscrow);
            auto feeVote = make_FeeVote(setup, env.app().journal("FeeVote"));

            auto ledger = std::make_shared<Ledger>(
@@ -674,7 +871,7 @@ class FeeVote_test : public beast::unit_test::suite
        setup.account_reserve = 1234567;
        setup.owner_reserve = 7654321;

-        Env env(*this, testable_amendments() | featureXRPFees);
+        Env env(*this, testable_amendments() - featureSmartEscrow);

        // establish what the current fees are
        BEAST_EXPECT(
@@ -764,6 +961,128 @@ class FeeVote_test : public beast::unit_test::suite
            XRPAmount{setup.owner_reserve});
    }

+    void
+    testDoVotingSmartEscrow()
+    {
+        testcase("doVoting with Smart Escrow");
+
+        using namespace jtx;
+
+        FeeSetup setup;
+        setup.reference_fee = 42;
+        setup.account_reserve = 1234567;
+        setup.owner_reserve = 7654321;
+        setup.extension_compute_limit = 100;
+        setup.extension_size_limit = 200;
+        setup.gas_price = 300;
+
+        Env env(
+            *this, testable_amendments() | featureXRPFees | featureSmartEscrow);
+
+        // establish what the current fees are
+        BEAST_EXPECT(
+            env.current()->fees().base == XRPAmount{UNIT_TEST_REFERENCE_FEE});
+        BEAST_EXPECT(env.current()->fees().reserve == XRPAmount{200'000'000});
+        BEAST_EXPECT(env.current()->fees().increment == XRPAmount{50'000'000});
+        BEAST_EXPECT(env.current()->fees().extensionComputeLimit == 0);
+        BEAST_EXPECT(env.current()->fees().extensionSizeLimit == 0);
+        BEAST_EXPECT(env.current()->fees().gasPrice == 0);
+
+        auto feeVote = make_FeeVote(setup, env.app().journal("FeeVote"));
+        auto ledger = std::make_shared<Ledger>(
+            create_genesis,
+            env.app().config(),
+            std::vector<uint256>{},
+            env.app().getNodeFamily());
+
+        // doVoting requires a flag ledger (every 256th ledger)
+        // We need to create a ledger at sequence 256 to make it a flag
+        // ledger
+        for (int i = 0; i < 256 - 1; ++i)
+        {
+            ledger = std::make_shared<Ledger>(
+                *ledger, env.app().timeKeeper().closeTime());
+        }
+        BEAST_EXPECT(ledger->isFlagLedger());
+
+        // Create some mock validations with fee votes
+        std::vector<std::shared_ptr<STValidation>> validations;
+
+        for (int i = 0; i < 5; i++)
+        {
+            auto sec = randomSecretKey();
+            auto pub = derivePublicKey(KeyType::secp256k1, sec);
+
+            auto val = std::make_shared<STValidation>(
+                env.app().timeKeeper().now(),
+                pub,
+                sec,
+                calcNodeID(pub),
+                [&](STValidation& v) {
+                    v.setFieldU32(sfLedgerSequence, ledger->seq());
+                    // Vote for different fees than current
+                    v.setFieldAmount(
+                        sfBaseFeeDrops, XRPAmount{setup.reference_fee});
+                    v.setFieldAmount(
+                        sfReserveBaseDrops, XRPAmount{setup.account_reserve});
+                    v.setFieldAmount(
+                        sfReserveIncrementDrops,
+                        XRPAmount{setup.owner_reserve});
+                    v.setFieldU32(
+                        sfExtensionComputeLimit, setup.extension_compute_limit);
+                    v.setFieldU32(
+                        sfExtensionSizeLimit, setup.extension_size_limit);
+                    v.setFieldU32(sfGasPrice, setup.gas_price);
+                });
+            if (i % 2)
+                val->setTrusted();
+            validations.push_back(val);
+        }
+
+        auto txSet = std::make_shared<SHAMap>(
+            SHAMapType::TRANSACTION, env.app().getNodeFamily());
+
+        // This should not throw since we have a flag ledger
+        feeVote->doVoting(ledger, validations, txSet);
+
+        auto const txs = getTxs(txSet);
+        BEAST_EXPECT(txs.size() == 1);
+        auto const& feeTx = txs[0];
+
+        BEAST_EXPECT(feeTx.getTxnType() == ttFEE);
+
+        BEAST_EXPECT(feeTx.getAccountID(sfAccount) == AccountID());
+        BEAST_EXPECT(feeTx.getFieldU32(sfLedgerSequence) == ledger->seq() + 1);
+
+        BEAST_EXPECT(feeTx.isFieldPresent(sfBaseFeeDrops));
+        BEAST_EXPECT(feeTx.isFieldPresent(sfReserveBaseDrops));
+        BEAST_EXPECT(feeTx.isFieldPresent(sfReserveIncrementDrops));
+
+        // The legacy fields should NOT be present
+        BEAST_EXPECT(!feeTx.isFieldPresent(sfBaseFee));
+        BEAST_EXPECT(!feeTx.isFieldPresent(sfReserveBase));
+        BEAST_EXPECT(!feeTx.isFieldPresent(sfReserveIncrement));
+        BEAST_EXPECT(!feeTx.isFieldPresent(sfReferenceFeeUnits));
+
+        // Check the values
+        BEAST_EXPECT(
+            feeTx.getFieldAmount(sfBaseFeeDrops) ==
+            XRPAmount{setup.reference_fee});
+        BEAST_EXPECT(
+            feeTx.getFieldAmount(sfReserveBaseDrops) ==
+            XRPAmount{setup.account_reserve});
+        BEAST_EXPECT(
+            feeTx.getFieldAmount(sfReserveIncrementDrops) ==
+            XRPAmount{setup.owner_reserve});
+        BEAST_EXPECT(
+            feeTx.getFieldU32(sfExtensionComputeLimit) ==
+            setup.extension_compute_limit);
+        BEAST_EXPECT(
+            feeTx.getFieldU32(sfExtensionSizeLimit) ==
+            setup.extension_size_limit);
+        BEAST_EXPECT(feeTx.getFieldU32(sfGasPrice) == setup.gas_price);
+    }
+
    void
    run() override
    {
@@ -777,6 +1096,7 @@ class FeeVote_test : public beast::unit_test::suite
        testSingleInvalidTransaction();
        testDoValidation();
        testDoVoting();
+        testDoVotingSmartEscrow();
    }
 };

@@ -38,14 +38,14 @@ public:

            auto const jtx = env.jt(ticket::create(alice, 1), seq(1), fee(10));

-            auto transacionId = jtx.stx->getTransactionID();
+            auto transactionId = jtx.stx->getTransactionID();
            env.app().getHashRouter().setFlags(
-                transacionId, HashRouterFlags::HELD);
+                transactionId, HashRouterFlags::HELD);

            env(jtx, json(jss::Sequence, 1), ter(terNO_ACCOUNT));

            env.app().getHashRouter().setFlags(
-                transacionId, HashRouterFlags::BAD);
+                transactionId, HashRouterFlags::BAD);

            env.close();
        }
@@ -33,6 +33,12 @@ struct PseudoTx_test : public beast::unit_test::suite
                obj[sfReserveIncrement] = 0;
                obj[sfReferenceFeeUnits] = 0;
            }
+            if (rules.enabled(featureSmartEscrow))
+            {
+                obj[sfExtensionComputeLimit] = 0;
+                obj[sfExtensionSizeLimit] = 0;
+                obj[sfGasPrice] = 0;
+            }
        }));

        res.emplace_back(STTx(ttAMENDMENT, [&](auto& obj) {
@@ -101,7 +107,9 @@ struct PseudoTx_test : public beast::unit_test::suite
        FeatureBitset const all{testable_amendments()};
        FeatureBitset const xrpFees{featureXRPFees};

+        testPrevented(all - featureXRPFees - featureSmartEscrow);
        testPrevented(all - featureXRPFees);
+        testPrevented(all - featureSmartEscrow);
        testPrevented(all);
        testAllowed();
    }
@@ -0,0 +1,746 @@
+#ifdef _DEBUG
+// #define DEBUG_OUTPUT 1
+#endif
+
+#include <test/app/TestHostFunctions.h>
+
+#include <xrpld/app/wasm/HostFuncWrapper.h>
+
+namespace ripple {
+namespace test {
+
+bool
+testGetDataIncrement();
+
+using Add_proto = int32_t(int32_t, int32_t);
+static wasm_trap_t*
+Add(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results)
+{
+    int32_t Val1 = params->data[0].of.i32;
+    int32_t Val2 = params->data[1].of.i32;
+    // printf("Host function \"Add\": %d + %d\n", Val1, Val2);
+    results->data[0] = WASM_I32_VAL(Val1 + Val2);
+    return nullptr;
+}
+
+struct Wasm_test : public beast::unit_test::suite
+{
+    void
+    testGetDataHelperFunctions()
+    {
+        testcase("getData helper functions");
+        BEAST_EXPECT(testGetDataIncrement());
+    }
+
+    void
+    testWasmLib()
+    {
+        testcase("wasmtime lib test");
+        // clang-format off
+        /* The WASM module buffer. */
+        Bytes const wasm = {/* WASM header */
+                          0x00, 0x61, 0x73, 0x6D, 0x01, 0x00, 0x00, 0x00,
+                          /* Type section */
+                          0x01, 0x07, 0x01,
+                          /* function type {i32, i32} -> {i32} */
+                          0x60, 0x02, 0x7F, 0x7F, 0x01, 0x7F,
+                          /* Import section */
+                          0x02, 0x13, 0x01,
+                          /* module name: "extern" */
+                          0x06, 0x65, 0x78, 0x74, 0x65, 0x72, 0x6E,
+                          /* extern name: "func-add" */
+                          0x08, 0x66, 0x75, 0x6E, 0x63, 0x2D, 0x61, 0x64, 0x64,
+                          /* import desc: func 0 */
+                          0x00, 0x00,
+                          /* Function section */
+                          0x03, 0x02, 0x01, 0x00,
+                          /* Export section */
+                          0x07, 0x0A, 0x01,
+                          /* export name: "addTwo" */
+                          0x06, 0x61, 0x64, 0x64, 0x54, 0x77, 0x6F,
+                          /* export desc: func 0 */
+                          0x00, 0x01,
+                          /* Code section */
+                          0x0A, 0x0A, 0x01,
+                          /* code body */
+                          0x08, 0x00, 0x20, 0x00, 0x20, 0x01, 0x10, 0x00, 0x0B};
+        // clang-format on
+        auto& vm = WasmEngine::instance();
+
+        ImportVec imports;
+        WasmImpFunc<Add_proto>(
+            imports, "func-add", reinterpret_cast<void*>(&Add));
+
+        auto re = vm.run(wasm, "addTwo", wasmParams(1234, 5678), imports);
+
+        // if (res) printf("invokeAdd get the result: %d\n", res.value());
+
+        if (BEAST_EXPECT(re.has_value()))
+        {
+            BEAST_EXPECTS(re->result == 6'912, std::to_string(re->result));
+            BEAST_EXPECTS(re->cost == 3, std::to_string(re->cost));
+        }
+    }
+
+    void
+    testBadWasm()
+    {
+        testcase("bad wasm test");
+
+        using namespace test::jtx;
+
+        Env env{*this};
+        HostFunctions hfs(env.journal);
+
+        {
+            auto wasmHex = "00000000";
+            auto wasmStr = boost::algorithm::unhex(std::string(wasmHex));
+            std::vector<uint8_t> wasm(wasmStr.begin(), wasmStr.end());
+            std::string funcName("mock_escrow");
+
+            auto re = runEscrowWasm(wasm, hfs, funcName, {}, 15);
+            BEAST_EXPECT(!re);
+        }
+
+        {
+            auto wasmHex = "00112233445566778899AA";
+            auto wasmStr = boost::algorithm::unhex(std::string(wasmHex));
+            std::vector<uint8_t> wasm(wasmStr.begin(), wasmStr.end());
+            std::string funcName("mock_escrow");
+
+            auto const re = preflightEscrowWasm(wasm, hfs, funcName);
+            BEAST_EXPECT(!isTesSuccess(re));
+        }
+
+        {
+            // FinishFunction wrong function name
+            // pub fn bad() -> bool {
+            //     unsafe { host_lib::getLedgerSqn() >= 5 }
+            // }
+            auto const badWasmHex =
+                "0061736d010000000105016000017f02190108686f73745f6c69620c6765"
+                "744c656467657253716e00000302010005030100100611027f00418080c0"
+                "000b7f00418080c0000b072b04066d656d6f727902000362616400010a5f"
+                "5f646174615f656e6403000b5f5f686561705f6261736503010a09010700"
+                "100041044a0b004d0970726f64756365727302086c616e67756167650104"
+                "52757374000c70726f6365737365642d6279010572757374631d312e3835"
+                "2e31202834656231363132353020323032352d30332d31352900490f7461"
+                "726765745f6665617475726573042b0f6d757461626c652d676c6f62616c"
+                "732b087369676e2d6578742b0f7265666572656e63652d74797065732b0a"
+                "6d756c746976616c7565";
+            auto wasmStr = boost::algorithm::unhex(std::string(badWasmHex));
+            std::vector<uint8_t> wasm(wasmStr.begin(), wasmStr.end());
+
+            auto const re =
+                preflightEscrowWasm(wasm, hfs, ESCROW_FUNCTION_NAME);
+            BEAST_EXPECT(!isTesSuccess(re));
+        }
+    }
+
+    void
+    testWasmLedgerSqn()
+    {
+        testcase("Wasm get ledger sequence");
+
+        auto wasmStr = boost::algorithm::unhex(ledgerSqnWasmHex);
+        Bytes wasm(wasmStr.begin(), wasmStr.end());
+
+        using namespace test::jtx;
+
+        Env env{*this};
+        TestLedgerDataProvider hf(env);
+
+        ImportVec imports;
+        WASM_IMPORT_FUNC2(imports, getLedgerSqn, "get_ledger_sqn", &hf, 33);
+        auto& engine = WasmEngine::instance();
+
+        auto re = engine.run(
+            wasm,
+            ESCROW_FUNCTION_NAME,
+            {},
+            imports,
+            &hf,
+            1'000'000,
+            env.journal);
+
+        if (BEAST_EXPECT(re.has_value()))
+        {
+            BEAST_EXPECTS(re->result == 0, std::to_string(re->result));
+            BEAST_EXPECTS(re->cost == 38, std::to_string(re->cost));
+        }
+
+        env.close();
+        env.close();
+
+        // empty module - run the same instance
+        re = engine.run(
+            {}, ESCROW_FUNCTION_NAME, {}, imports, &hf, 1'000'000, env.journal);
+
+        if (BEAST_EXPECT(re.has_value()))
+        {
+            BEAST_EXPECTS(re->result == 5, std::to_string(re->result));
+            BEAST_EXPECTS(re->cost == 76, std::to_string(re->cost));
+        }
+    }
+
+    void
+    testWasmFib()
+    {
+        testcase("Wasm fibo");
+
+        auto const ws = boost::algorithm::unhex(fibWasmHex);
+        Bytes const wasm(ws.begin(), ws.end());
+        auto& engine = WasmEngine::instance();
+
+        auto const re = engine.run(wasm, "fib", wasmParams(10));
+
+        if (BEAST_EXPECT(re.has_value()))
+        {
+            BEAST_EXPECTS(re->result == 55, std::to_string(re->result));
+            BEAST_EXPECTS(re->cost == 696, std::to_string(re->cost));
+        }
+    }
+
+    void
+    testWasmSha()
+    {
+        testcase("Wasm sha");
+
+        auto const ws = boost::algorithm::unhex(sha512PureWasmHex);
+        Bytes const wasm(ws.begin(), ws.end());
+        auto& engine = WasmEngine::instance();
+
+        auto const re =
+            engine.run(wasm, "sha512_process", wasmParams(sha512PureWasmHex));
+
+        if (BEAST_EXPECT(re.has_value()))
+        {
+            BEAST_EXPECTS(re->result == 34'432, std::to_string(re->result));
+            BEAST_EXPECTS(re->cost == 145'573, std::to_string(re->cost));
+        }
+    }
+
+    void
+    testWasmB58()
+    {
+        testcase("Wasm base58");
+        auto const ws = boost::algorithm::unhex(b58WasmHex);
+        Bytes const wasm(ws.begin(), ws.end());
+        auto& engine = WasmEngine::instance();
+
+        Bytes outb;
+        outb.resize(1024);
+
+        auto const minsz = std::min(
+            static_cast<std::uint32_t>(512),
+            static_cast<std::uint32_t>(b58WasmHex.size()));
+        auto const s = std::string_view(b58WasmHex.c_str(), minsz);
+
+        auto const re = engine.run(wasm, "b58enco", wasmParams(outb, s));
+
+        if (BEAST_EXPECT(re.has_value()))
+        {
+            BEAST_EXPECTS(re->result == 700, std::to_string(re->result));
+            BEAST_EXPECTS(re->cost == 2'701'528, std::to_string(re->cost));
+        }
+    }
+
+    void
+    testHFCost()
+    {
+        testcase("wasm test host functions cost");
+
+        using namespace test::jtx;
+
+        Env env(*this);
+        {
+            std::string const wasmHex = allHostFunctionsWasmHex;
+            std::string const wasmStr = boost::algorithm::unhex(wasmHex);
+            std::vector<uint8_t> const wasm(wasmStr.begin(), wasmStr.end());
+
+            auto& engine = WasmEngine::instance();
+
+            TestHostFunctions hfs(env, 0);
+            ImportVec imp = createWasmImport(hfs);
+            for (auto& i : imp)
+                i.second.gas = 0;
+
+            auto re = engine.run(
+                wasm,
+                ESCROW_FUNCTION_NAME,
+                {},
+                imp,
+                &hfs,
+                1'000'000,
+                env.journal);
+
+            if (BEAST_EXPECT(re.has_value()))
+            {
+                BEAST_EXPECTS(re->result == 1, std::to_string(re->result));
+                BEAST_EXPECTS(re->cost == 842, std::to_string(re->cost));
+            }
+
+            env.close();
+        }
+
+        env.close();
+        env.close();
+        env.close();
+        env.close();
+        env.close();
+
+        {
+            std::string const wasmHex = allHostFunctionsWasmHex;
+            std::string const wasmStr = boost::algorithm::unhex(wasmHex);
+            std::vector<uint8_t> const wasm(wasmStr.begin(), wasmStr.end());
+
+            auto& engine = WasmEngine::instance();
+
+            TestHostFunctions hfs(env, 0);
+            ImportVec const imp = createWasmImport(hfs);
+
+            auto re = engine.run(
+                wasm,
+                ESCROW_FUNCTION_NAME,
+                {},
+                imp,
+                &hfs,
+                1'000'000,
+                env.journal);
+
+            if (BEAST_EXPECT(re.has_value()))
+            {
+                BEAST_EXPECTS(re->result == 1, std::to_string(re->result));
+                BEAST_EXPECTS(re->cost == 40'102, std::to_string(re->cost));
+            }
+
+            env.close();
+        }
+
+        // not enough gas
+        {
+            std::string const wasmHex = allHostFunctionsWasmHex;
+            std::string const wasmStr = boost::algorithm::unhex(wasmHex);
+            std::vector<uint8_t> const wasm(wasmStr.begin(), wasmStr.end());
+
+            auto& engine = WasmEngine::instance();
+
+            TestHostFunctions hfs(env, 0);
+            ImportVec const imp = createWasmImport(hfs);
+
+            auto re = engine.run(
+                wasm, ESCROW_FUNCTION_NAME, {}, imp, &hfs, 200, env.journal);
+
+            if (BEAST_EXPECT(!re))
+            {
+                BEAST_EXPECTS(
+                    re.error() == tecFAILED_PROCESSING,
+                    std::to_string(TERtoInt(re.error())));
+            }
+
+            env.close();
+        }
+    }
+
+    void
+    testEscrowWasmDN()
+    {
+        testcase("escrow wasm devnet test");
+
+        std::string const wasmStr =
+            boost::algorithm::unhex(allHostFunctionsWasmHex);
+        std::vector<uint8_t> wasm(wasmStr.begin(), wasmStr.end());
+
+        using namespace test::jtx;
+        Env env{*this};
+        {
+            TestHostFunctions nfs(env, 0);
+            auto re =
+                runEscrowWasm(wasm, nfs, ESCROW_FUNCTION_NAME, {}, 100'000);
+            if (BEAST_EXPECT(re.has_value()))
+            {
+                BEAST_EXPECTS(re->result == 1, std::to_string(re->result));
+                BEAST_EXPECTS(re->cost == 40'102, std::to_string(re->cost));
+            }
+        }
+
+        {
+            // max<int64_t>() gas
+            TestHostFunctions nfs(env, 0);
+            auto re = runEscrowWasm(wasm, nfs, ESCROW_FUNCTION_NAME, {}, -1);
+            if (BEAST_EXPECT(re.has_value()))
+            {
+                BEAST_EXPECTS(re->result == 1, std::to_string(re->result));
+                BEAST_EXPECTS(re->cost == 40'102, std::to_string(re->cost));
+            }
+        }
+
+        {  // fail because trying to access nonexistent field
+            struct BadTestHostFunctions : public TestHostFunctions
+            {
+                explicit BadTestHostFunctions(Env& env) : TestHostFunctions(env)
+                {
+                }
+                Expected<Bytes, HostFunctionError>
+                getTxField(SField const& fname) override
+                {
+                    return Unexpected(HostFunctionError::FIELD_NOT_FOUND);
+                }
+            };
+            BadTestHostFunctions nfs(env);
+            auto re =
+                runEscrowWasm(wasm, nfs, ESCROW_FUNCTION_NAME, {}, 100'000);
+            if (BEAST_EXPECT(re.has_value()))
+            {
+                BEAST_EXPECTS(re->result == -201, std::to_string(re->result));
+                BEAST_EXPECTS(re->cost == 5'012, std::to_string(re->cost));
+            }
+        }
+
+        {  // fail because trying to allocate more than MAX_PAGES memory
+            struct BadTestHostFunctions : public TestHostFunctions
+            {
+                explicit BadTestHostFunctions(Env& env) : TestHostFunctions(env)
+                {
+                }
+                Expected<Bytes, HostFunctionError>
+                getTxField(SField const& fname) override
+                {
+                    return Bytes((128 + 1) * 64 * 1024, 1);
+                }
+            };
+            BadTestHostFunctions nfs(env);
+            auto re =
+                runEscrowWasm(wasm, nfs, ESCROW_FUNCTION_NAME, {}, 100'000);
+            if (BEAST_EXPECT(re.has_value()))
+            {
+                BEAST_EXPECTS(re->result == -201, std::to_string(re->result));
+                BEAST_EXPECTS(re->cost == 5'012, std::to_string(re->cost));
+            }
+        }
+
+        {  // fail because recursion too deep
+
+            auto const wasmStr = boost::algorithm::unhex(deepRecursionHex);
+            std::vector<uint8_t> wasm(wasmStr.begin(), wasmStr.end());
+
+            TestHostFunctionsSink nfs(env);
+            std::string funcName("finish");
+            auto re = runEscrowWasm(wasm, nfs, funcName, {}, 1'000'000'000);
+            BEAST_EXPECT(!re && re.error());
+            // std::cout << "bad case (deep recursion) result " << re.error()
+            //             << std::endl;
+
+            auto const& sink = nfs.getSink();
+            auto countSubstr = [](std::string const& str,
+                                  std::string const& substr) {
+                std::size_t pos = 0;
+                int occurrences = 0;
+                while ((pos = str.find(substr, pos)) != std::string::npos)
+                {
+                    occurrences++;
+                    pos += substr.length();
+                }
+                return occurrences;
+            };
+
+            auto const s = sink.messages().str();
+            BEAST_EXPECT(
+                countSubstr(s, "WASMI Error: failure to call func") == 1);
+            BEAST_EXPECT(countSubstr(s, "exception: <finish> failure") > 0);
+        }
+
+        {
+            // expected import not provided
+            auto wasmStr = boost::algorithm::unhex(ledgerSqnWasmHex);
+            Bytes wasm(wasmStr.begin(), wasmStr.end());
+            TestLedgerDataProvider ledgerDataProvider(env);
+
+            ImportVec imports;
+            WASM_IMPORT_FUNC2(
+                imports, getLedgerSqn, "get_ledger_sqn2", &ledgerDataProvider);
+
+            auto& engine = WasmEngine::instance();
+
+            auto re = engine.run(
+                wasm,
+                ESCROW_FUNCTION_NAME,
+                {},
+                imports,
+                &ledgerDataProvider,
+                1'000'000,
+                env.journal);
+
+            BEAST_EXPECT(!re);
+        }
+
+        {
+            // bad import format
+            auto wasmStr = boost::algorithm::unhex(ledgerSqnWasmHex);
+            Bytes wasm(wasmStr.begin(), wasmStr.end());
+            TestLedgerDataProvider ledgerDataProvider(env);
+
+            ImportVec imports;
+            WASM_IMPORT_FUNC2(
+                imports, getLedgerSqn, "get_ledger_sqn", &ledgerDataProvider);
+            imports[0].first = nullptr;
+
+            auto& engine = WasmEngine::instance();
+
+            auto re = engine.run(
+                wasm,
+                ESCROW_FUNCTION_NAME,
+                {},
+                imports,
+                &ledgerDataProvider,
+                1'000'000,
+                env.journal);
+
+            BEAST_EXPECT(!re);
+        }
+
+        {
+            // bad function name
+            auto wasmStr = boost::algorithm::unhex(ledgerSqnWasmHex);
+            Bytes wasm(wasmStr.begin(), wasmStr.end());
+            TestLedgerDataProvider ledgerDataProvider(env);
+
+            ImportVec imports;
+            WASM_IMPORT_FUNC2(
+                imports, getLedgerSqn, "get_ledger_sqn", &ledgerDataProvider);
+
+            auto& engine = WasmEngine::instance();
+            auto re = engine.run(
+                wasm,
+                "func1",
+                {},
+                imports,
+                &ledgerDataProvider,
+                1'000'000,
+                env.journal);
+
+            BEAST_EXPECT(!re);
+        }
+    }
+
+    void
+    testFloat()
+    {
+        testcase("float point");
+
+        std::string const funcName("finish");
+
+        using namespace test::jtx;
+
+        Env env(*this);
+        {
+            std::string const wasmHex = floatTestsWasmHex;
+            std::string const wasmStr = boost::algorithm::unhex(wasmHex);
+            std::vector<uint8_t> const wasm(wasmStr.begin(), wasmStr.end());
+
+            TestHostFunctions hf(env, 0);
+            auto re = runEscrowWasm(wasm, hf, funcName, {}, 100'000);
+            if (BEAST_EXPECT(re.has_value()))
+            {
+                BEAST_EXPECTS(re->result == 1, std::to_string(re->result));
+                BEAST_EXPECTS(re->cost == 97'356, std::to_string(re->cost));
+            }
+            env.close();
+        }
+
+        {
+            std::string const wasmHex = float0Hex;
+            std::string const wasmStr = boost::algorithm::unhex(wasmHex);
+            std::vector<uint8_t> const wasm(wasmStr.begin(), wasmStr.end());
+
+            TestHostFunctions hf(env, 0);
+            auto re = runEscrowWasm(wasm, hf, funcName, {}, 100'000);
+            if (BEAST_EXPECT(re.has_value()))
+            {
+                BEAST_EXPECTS(re->result == 1, std::to_string(re->result));
+                BEAST_EXPECTS(re->cost == 2'054, std::to_string(re->cost));
+            }
+            env.close();
+        }
+    }
+
+    void
+    perfTest()
+    {
+        testcase("Perf test host functions");
+
+        using namespace jtx;
+        using namespace std::chrono;
+
+        // std::string const funcName("test");
+        auto const& wasmHex = hfPerfTest;
+        std::string const wasmStr = boost::algorithm::unhex(wasmHex);
+        std::vector<uint8_t> const wasm(wasmStr.begin(), wasmStr.end());
+
+        // std::string const credType = "abcde";
+        // std::string const credType2 = "fghijk";
+        // std::string const credType3 = "0123456";
+        // char const uri[] = "uri";
+
+        Account const alan{"alan"};
+        Account const bob{"bob"};
+        Account const issuer{"issuer"};
+
+        {
+            Env env(*this);
+            // Env env(*this, envconfig(), {}, nullptr,
+            // beast::severities::kTrace);
+            env.fund(XRP(5000), alan, bob, issuer);
+            env.close();
+
+            // // create escrow
+            // auto const seq = env.seq(alan);
+            // auto const k = keylet::escrow(alan, seq);
+            // // auto const allowance = 3'600;
+            // auto escrowCreate = escrow::create(alan, bob, XRP(1000));
+            // XRPAmount txnFees = env.current()->fees().base + 1000;
+            // env(escrowCreate,
+            //     escrow::finish_function(wasmHex),
+            //     escrow::finish_time(env.now() + 11s),
+            //     escrow::cancel_time(env.now() + 100s),
+            //     escrow::data("1000000000"),  // 1000 XRP in drops
+            //     memodata("memo1234567"),
+            //     memodata("2memo1234567"),
+            //     fee(txnFees));
+
+            // // create depositPreauth
+            // auto const k = keylet::depositPreauth(
+            //     bob,
+            //     {{issuer.id(), makeSlice(credType)},
+            //      {issuer.id(), makeSlice(credType2)},
+            //      {issuer.id(), makeSlice(credType3)}});
+            // env(deposit::authCredentials(
+            //     bob,
+            //     {{issuer, credType},
+            //      {issuer, credType2},
+            //      {issuer, credType3}}));
+
+            // create nft
+            [[maybe_unused]] uint256 const nft0{
+                token::getNextID(env, alan, 0u)};
+            env(token::mint(alan, 0u));
+            auto const k = keylet::nftoffer(alan, 0);
+            [[maybe_unused]] uint256 const nft1{
+                token::getNextID(env, alan, 0u)};
+
+            env(token::mint(alan, 0u),
+                token::uri(
+                    "https://github.com/XRPLF/XRPL-Standards/discussions/"
+                    "279?id=github.com/XRPLF/XRPL-Standards/discussions/"
+                    "279&ut=github.com/XRPLF/XRPL-Standards/discussions/"
+                    "279&sid=github.com/XRPLF/XRPL-Standards/discussions/"
+                    "279&aot=github.com/XRPLF/XRPL-Standards/disc"));
+            [[maybe_unused]] uint256 const nft2{
+                token::getNextID(env, alan, 0u)};
+            env(token::mint(alan, 0u));
+            env.close();
+
+            PerfHostFunctions nfs(env, k, env.tx());
+
+            auto re = runEscrowWasm(wasm, nfs, ESCROW_FUNCTION_NAME);
+            if (BEAST_EXPECT(re.has_value()))
+            {
+                BEAST_EXPECT(re->result);
+                std::cout << "Res: " << re->result << " cost: " << re->cost
+                          << std::endl;
+            }
+
+            // env(escrow::finish(alan, alan, seq),
+            //     escrow::comp_allowance(allowance),
+            //     fee(txnFees),
+            //     ter(tesSUCCESS));
+
+            env.close();
+        }
+    }
+
+    void
+    testCodecovWasm()
+    {
+        testcase("Codecov wasm test");
+
+        using namespace test::jtx;
+
+        Env env{*this};
+
+        auto const wasmStr = boost::algorithm::unhex(codecovTestsWasmHex);
+        Bytes const wasm(wasmStr.begin(), wasmStr.end());
+        TestHostFunctions hfs(env, 0);
+
+        auto const allowance = 153'534;
+        auto re = runEscrowWasm(wasm, hfs, ESCROW_FUNCTION_NAME, {}, allowance);
+
+        if (BEAST_EXPECT(re.has_value()))
+        {
+            BEAST_EXPECT(re->result);
+            BEAST_EXPECTS(re->cost == allowance, std::to_string(re->cost));
+        }
+    }
+
+    void
+    testDisabledFloat()
+    {
+        testcase("disabled float");
+
+        using namespace test::jtx;
+        Env env{*this};
+
+        auto const wasmStr = boost::algorithm::unhex(disabledFloatHex);
+        Bytes wasm(wasmStr.begin(), wasmStr.end());
+        std::string const funcName("finish");
+        TestHostFunctions hfs(env, 0);
+
+        {
+            // f32 set constant, opcode disabled exception
+            auto const re = runEscrowWasm(wasm, hfs, funcName, {}, 1'000'000);
+            if (BEAST_EXPECT(!re.has_value()))
+            {
+                BEAST_EXPECT(re.error() == tecFAILED_PROCESSING);
+            }
+        }
+
+        {
+            // f32 add, can't create module exception
+            wasm[0x117] = 0x92;
+            auto const re = runEscrowWasm(wasm, hfs, funcName, {}, 1'000'000);
+            if (BEAST_EXPECT(!re.has_value()))
+            {
+                BEAST_EXPECT(re.error() == tecFAILED_PROCESSING);
+            }
+        }
+    }
+
+    void
+    run() override
+    {
+        using namespace test::jtx;
+
+        testGetDataHelperFunctions();
+        testWasmLib();
+        testBadWasm();
+        testWasmLedgerSqn();
+
+        testWasmFib();
+        testWasmSha();
+        testWasmB58();
+
+        testHFCost();
+        testEscrowWasmDN();
+        testFloat();
+
+        testCodecovWasm();
+        testDisabledFloat();
+
+        // perfTest();
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(Wasm, app, ripple);
+
+}  // namespace test
+}  // namespace ripple
@@ -0,0 +1,3 @@
+**/target
+**/debug
+*.wasm
@@ -0,0 +1,171 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "all_host_functions"
+version = "0.1.0"
+dependencies = [
+ "xrpl-wasm-stdlib",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "bs58"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bb6743198531e02858aeaea5398fcc883e71851fcbcb5a2f773e2fb6cb1edf2"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.177"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.103"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.41"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce25767e7b499d1b604768e7cde645d14cc8584231ea6b295e9c9eb22c02e1d1"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da58917d35242480a05c2897064da0a80589a2a0476c9a3f2fdc83b53502e917"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+
+[[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "xrpl-address-macro"
+version = "0.7.1"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git#d27d3e0b4abf3c0215aade729d89053805efe48e"
+dependencies = [
+ "bs58",
+ "quote",
+ "sha2",
+ "syn",
+]
+
+[[package]]
+name = "xrpl-wasm-stdlib"
+version = "0.7.1"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git#d27d3e0b4abf3c0215aade729d89053805efe48e"
+dependencies = [
+ "xrpl-address-macro",
+]
@@ -0,0 +1,21 @@
+[package]
+name = "all_host_functions"
+version = "0.1.0"
+edition = "2024"
+
+# This empty workspace definition keeps this project independent of the parent workspace
+[workspace]
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+xrpl-std = { git = "https://github.com/ripple/xrpl-wasm-stdlib.git", package = "xrpl-wasm-stdlib" }
+
+[profile.dev]
+panic = "abort"
+
+[profile.release]
+panic = "abort"
+opt-level = "z"
+lto = true
@@ -0,0 +1,772 @@
+#![cfg_attr(target_arch = "wasm32", no_std)]
+
+#[cfg(not(target_arch = "wasm32"))]
+extern crate std;
+
+//
+// Host Functions Test
+// Tests 26 host functions (across 7 categories)
+//
+// With craft you can run this test with:
+//   craft test --project host_functions_test --test-case host_functions_test
+//
+// Amount Format Update:
+// - XRP amounts now return as 8-byte serialized rippled objects
+// - IOU and MPT amounts return in variable-length serialized format
+// - Format details: https://xrpl.org/docs/references/protocol/binary-format#amount-fields
+//
+// Error Code Ranges:
+// -100 to -199: Ledger Header Functions (3 functions)
+// -200 to -299: Transaction Data Functions (5 functions)
+// -300 to -399: Current Ledger Object Functions (4 functions)
+// -400 to -499: Any Ledger Object Functions (5 functions)
+// -500 to -599: Keylet Generation Functions (4 functions)
+// -600 to -699: Utility Functions (4 functions)
+// -700 to -799: Data Update Functions (1 function)
+//
+
+use xrpl_std::core::current_tx::escrow_finish::EscrowFinish;
+use xrpl_std::core::current_tx::traits::TransactionCommonFields;
+use xrpl_std::host;
+use xrpl_std::host::trace::{trace, trace_account_buf, trace_data, trace_num, DataRepr};
+use xrpl_std::sfield;
+
+#[unsafe(no_mangle)]
+pub extern "C" fn finish() -> i32 {
+    let _ = trace("=== HOST FUNCTIONS TEST ===");
+    let _ = trace("Testing 26 host functions");
+
+    // Category 1: Ledger Header Data Functions (3 functions)
+    // Error range: -100 to -199
+    match test_ledger_header_functions() {
+        0 => (),
+        err => return err,
+    }
+
+    // Category 2: Transaction Data Functions (5 functions)
+    // Error range: -200 to -299
+    match test_transaction_data_functions() {
+        0 => (),
+        err => return err,
+    }
+
+    // Category 3: Current Ledger Object Functions (4 functions)
+    // Error range: -300 to -399
+    match test_current_ledger_object_functions() {
+        0 => (),
+        err => return err,
+    }
+
+    // Category 4: Any Ledger Object Functions (5 functions)
+    // Error range: -400 to -499
+    match test_any_ledger_object_functions() {
+        0 => (),
+        err => return err,
+    }
+
+    // Category 5: Keylet Generation Functions (4 functions)
+    // Error range: -500 to -599
+    match test_keylet_generation_functions() {
+        0 => (),
+        err => return err,
+    }
+
+    // Category 6: Utility Functions (4 functions)
+    // Error range: -600 to -699
+    match test_utility_functions() {
+        0 => (),
+        err => return err,
+    }
+
+    // Category 7: Data Update Functions (1 function)
+    // Error range: -700 to -799
+    match test_data_update_functions() {
+        0 => (),
+        err => return err,
+    }
+
+    let _ = trace("SUCCESS: All host function tests passed!");
+    1 // Success return code for WASM finish function
+}
+
+/// Test Category 1: Ledger Header Data Functions (3 functions)
+/// - get_ledger_sqn() - Get ledger sequence number
+/// - get_parent_ledger_time() - Get parent ledger timestamp
+/// - get_parent_ledger_hash() - Get parent ledger hash
+fn test_ledger_header_functions() -> i32 {
+    let _ = trace("--- Category 1: Ledger Header Functions ---");
+
+    // Test 1.1: get_ledger_sqn() - should return current ledger sequence number
+    let sqn_result = unsafe { host::get_ledger_sqn() };
+
+    if sqn_result <= 0 {
+        let _ = trace_num("ERROR: get_ledger_sqn failed:", sqn_result as i64);
+        return -101; // Ledger sequence number test failed
+    }
+    let _ = trace_num("Ledger sequence number:", sqn_result as i64);
+
+    // Test 1.2: get_parent_ledger_time() - should return parent ledger timestamp
+    let time_result = unsafe { host::get_parent_ledger_time() };
+
+    if time_result <= 0 {
+        let _ = trace_num("ERROR: get_parent_ledger_time failed:", time_result as i64);
+        return -102; // Parent ledger time test failed
+    }
+    let _ = trace_num("Parent ledger time:", time_result as i64);
+
+    // Test 1.3: get_parent_ledger_hash() - should return parent ledger hash (32 bytes)
+    let mut hash_buffer = [0u8; 32];
+    let hash_result =
+        unsafe { host::get_parent_ledger_hash(hash_buffer.as_mut_ptr(), hash_buffer.len()) };
+
+    if hash_result != 32 {
+        let _ = trace_num(
+            "ERROR: get_parent_ledger_hash wrong length:",
+            hash_result as i64,
+        );
+        return -103; // Parent ledger hash test failed - should be exactly 32 bytes
+    }
+    let _ = trace_data("Parent ledger hash:", &hash_buffer, DataRepr::AsHex);
+
+    let _ = trace("SUCCESS: Ledger header functions");
+    0
+}
+
+/// Test Category 2: Transaction Data Functions (5 functions)
+/// Tests all functions for accessing current transaction data
+fn test_transaction_data_functions() -> i32 {
+    let _ = trace("--- Category 2: Transaction Data Functions ---");
+
+    // Test 2.1: get_tx_field() - Basic transaction field access
+    // Test with Account field (required, 20 bytes)
+    let mut account_buffer = [0u8; 20];
+    let account_len = unsafe {
+        host::get_tx_field(
+            sfield::Account,
+            account_buffer.as_mut_ptr(),
+            account_buffer.len(),
+        )
+    };
+
+    if account_len != 20 {
+        let _ = trace_num(
+            "ERROR: get_tx_field(Account) wrong length:",
+            account_len as i64,
+        );
+        return -201; // Basic transaction field test failed
+    }
+    let _ = trace_account_buf("Transaction Account:", &account_buffer);
+
+    // Test with Fee field (XRP amount - 8 bytes in new serialized format)
+    // New format: XRP amounts are always 8 bytes (positive: value | cPositive flag, negative: just value)
+    let mut fee_buffer = [0u8; 8];
+    let fee_len =
+        unsafe { host::get_tx_field(sfield::Fee, fee_buffer.as_mut_ptr(), fee_buffer.len()) };
+
+    if fee_len != 8 {
+        let _ = trace_num(
+            "ERROR: get_tx_field(Fee) wrong length (expected 8 bytes for XRP):",
+            fee_len as i64,
+        );
+        return -202; // Fee field test failed - XRP amounts should be exactly 8 bytes
+    }
+    let _ = trace_num("Transaction Fee length:", fee_len as i64);
+    let _ = trace_data(
+        "Transaction Fee (serialized XRP amount):",
+        &fee_buffer,
+        DataRepr::AsHex,
+    );
+
+    // Test with Sequence field (required, 4 bytes uint32)
+    let mut seq_buffer = [0u8; 4];
+    let seq_len =
+        unsafe { host::get_tx_field(sfield::Sequence, seq_buffer.as_mut_ptr(), seq_buffer.len()) };
+
+    if seq_len != 4 {
+        let _ = trace_num(
+            "ERROR: get_tx_field(Sequence) wrong length:",
+            seq_len as i64,
+        );
+        return -203; // Sequence field test failed
+    }
+    let _ = trace_data("Transaction Sequence:", &seq_buffer, DataRepr::AsHex);
+
+    // NOTE: get_tx_field2() through get_tx_field6() have been deprecated.
+    // Use get_tx_field() with appropriate parameters for all transaction field access.
+
+    // Test 2.2: get_tx_nested_field() - Nested field access with locator
+    let locator = [0x01, 0x00]; // Simple locator for first element
+    let mut nested_buffer = [0u8; 32];
+    let nested_result = unsafe {
+        host::get_tx_nested_field(
+            locator.as_ptr(),
+            locator.len(),
+            nested_buffer.as_mut_ptr(),
+            nested_buffer.len(),
+        )
+    };
+
+    if nested_result < 0 {
+        let _ = trace_num(
+            "INFO: get_tx_nested_field not applicable:",
+            nested_result as i64,
+        );
+        // Expected - locator may not match transaction structure
+    } else {
+        let _ = trace_num("Nested field length:", nested_result as i64);
+        let _ = trace_data(
+            "Nested field:",
+            &nested_buffer[..nested_result as usize],
+            DataRepr::AsHex,
+        );
+    }
+
+    // Test 2.3: get_tx_array_len() - Get array length
+    let signers_len = unsafe { host::get_tx_array_len(sfield::Signers) };
+    let _ = trace_num("Signers array length:", signers_len as i64);
+
+    let memos_len = unsafe { host::get_tx_array_len(sfield::Memos) };
+    let _ = trace_num("Memos array length:", memos_len as i64);
+
+    // Test 2.4: get_tx_nested_array_len() - Get nested array length with locator
+    let nested_array_len =
+        unsafe { host::get_tx_nested_array_len(locator.as_ptr(), locator.len()) };
+
+    if nested_array_len < 0 {
+        let _ = trace_num(
+            "INFO: get_tx_nested_array_len not applicable:",
+            nested_array_len as i64,
+        );
+    } else {
+        let _ = trace_num("Nested array length:", nested_array_len as i64);
+    }
+
+    let _ = trace("SUCCESS: Transaction data functions");
+    0
+}
+
+/// Test Category 3: Current Ledger Object Functions (4 functions)
+/// Tests functions that access the current ledger object being processed
+fn test_current_ledger_object_functions() -> i32 {
+    let _ = trace("--- Category 3: Current Ledger Object Functions ---");
+
+    // Test 3.1: get_current_ledger_obj_field() - Access field from current ledger object
+    // Test with Balance field (XRP amount - 8 bytes in new serialized format)
+    let mut balance_buffer = [0u8; 8];
+    let balance_result = unsafe {
+        host::get_current_ledger_obj_field(
+            sfield::Balance,
+            balance_buffer.as_mut_ptr(),
+            balance_buffer.len(),
+        )
+    };
+
+    if balance_result <= 0 {
+        let _ = trace_num(
+            "INFO: get_current_ledger_obj_field(Balance) failed (may be expected):",
+            balance_result as i64,
+        );
+        // This might fail if current ledger object doesn't have balance field
+    } else if balance_result == 8 {
+        let _ = trace_num(
+            "Current object balance length (XRP amount):",
+            balance_result as i64,
+        );
+        let _ = trace_data(
+            "Current object balance (serialized XRP amount):",
+            &balance_buffer,
+            DataRepr::AsHex,
+        );
+    } else {
+        let _ = trace_num(
+            "Current object balance length (non-XRP amount):",
+            balance_result as i64,
+        );
+        let _ = trace_data(
+            "Current object balance:",
+            &balance_buffer[..balance_result as usize],
+            DataRepr::AsHex,
+        );
+    }
+
+    // Test with Account field
+    let mut current_account_buffer = [0u8; 20];
+    let current_account_result = unsafe {
+        host::get_current_ledger_obj_field(
+            sfield::Account,
+            current_account_buffer.as_mut_ptr(),
+            current_account_buffer.len(),
+        )
+    };
+
+    if current_account_result <= 0 {
+        let _ = trace_num(
+            "INFO: get_current_ledger_obj_field(Account) failed:",
+            current_account_result as i64,
+        );
+    } else {
+        let _ = trace_account_buf("Current ledger object account:", &current_account_buffer);
+    }
+
+    // Test 3.2: get_current_ledger_obj_nested_field() - Nested field access
+    let locator = [0x01, 0x00]; // Simple locator
+    let mut current_nested_buffer = [0u8; 32];
+    let current_nested_result = unsafe {
+        host::get_current_ledger_obj_nested_field(
+            locator.as_ptr(),
+            locator.len(),
+            current_nested_buffer.as_mut_ptr(),
+            current_nested_buffer.len(),
+        )
+    };
+
+    if current_nested_result < 0 {
+        let _ = trace_num(
+            "INFO: get_current_ledger_obj_nested_field not applicable:",
+            current_nested_result as i64,
+        );
+    } else {
+        let _ = trace_num("Current nested field length:", current_nested_result as i64);
+        let _ = trace_data(
+            "Current nested field:",
+            &current_nested_buffer[..current_nested_result as usize],
+            DataRepr::AsHex,
+        );
+    }
+
+    // Test 3.3: get_current_ledger_obj_array_len() - Array length in current object
+    let current_array_len = unsafe { host::get_current_ledger_obj_array_len(sfield::Signers) };
+    let _ = trace_num(
+        "Current object Signers array length:",
+        current_array_len as i64,
+    );
+
+    // Test 3.4: get_current_ledger_obj_nested_array_len() - Nested array length
+    let current_nested_array_len =
+        unsafe { host::get_current_ledger_obj_nested_array_len(locator.as_ptr(), locator.len()) };
+
+    if current_nested_array_len < 0 {
+        let _ = trace_num(
+            "INFO: get_current_ledger_obj_nested_array_len not applicable:",
+            current_nested_array_len as i64,
+        );
+    } else {
+        let _ = trace_num(
+            "Current nested array length:",
+            current_nested_array_len as i64,
+        );
+    }
+
+    let _ = trace("SUCCESS: Current ledger object functions");
+    0
+}
+
+/// Test Category 4: Any Ledger Object Functions (5 functions)
+/// Tests functions that work with cached ledger objects
+fn test_any_ledger_object_functions() -> i32 {
+    let _ = trace("--- Category 4: Any Ledger Object Functions ---");
+
+    // First we need to cache a ledger object to test the other functions
+    // Get the account from transaction and generate its keylet
+    let escrow_finish = EscrowFinish;
+    let account_id = escrow_finish.get_account().unwrap();
+
+    // Test 4.1: cache_ledger_obj() - Cache a ledger object
+    let mut keylet_buffer = [0u8; 32];
+    let keylet_result = unsafe {
+        host::account_keylet(
+            account_id.0.as_ptr(),
+            account_id.0.len(),
+            keylet_buffer.as_mut_ptr(),
+            keylet_buffer.len(),
+        )
+    };
+
+    if keylet_result != 32 {
+        let _ = trace_num(
+            "ERROR: account_keylet failed for caching test:",
+            keylet_result as i64,
+        );
+        return -401; // Keylet generation failed for caching test
+    }
+
+    let cache_result =
+        unsafe { host::cache_ledger_obj(keylet_buffer.as_ptr(), keylet_result as usize, 0) };
+
+    if cache_result <= 0 {
+        let _ = trace_num(
+            "INFO: cache_ledger_obj failed (expected with test fixtures):",
+            cache_result as i64,
+        );
+        // Test fixtures may not contain the account object - this is expected
+        // We'll test the interface but expect failures
+
+        // Test 4.2-4.5 with invalid slot (should fail gracefully)
+        let mut test_buffer = [0u8; 32];
+
+        // Test get_ledger_obj_field with invalid slot
+        let field_result = unsafe {
+            host::get_ledger_obj_field(
+                1,
+                sfield::Balance,
+                test_buffer.as_mut_ptr(),
+                test_buffer.len(),
+            )
+        };
+        if field_result < 0 {
+            let _ = trace_num(
+                "INFO: get_ledger_obj_field failed as expected (no cached object):",
+                field_result as i64,
+            );
+        }
+
+        // Test get_ledger_obj_nested_field with invalid slot
+        let locator = [0x01, 0x00];
+        let nested_result = unsafe {
+            host::get_ledger_obj_nested_field(
+                1,
+                locator.as_ptr(),
+                locator.len(),
+                test_buffer.as_mut_ptr(),
+                test_buffer.len(),
+            )
+        };
+        if nested_result < 0 {
+            let _ = trace_num(
+                "INFO: get_ledger_obj_nested_field failed as expected:",
+                nested_result as i64,
+            );
+        }
+
+        // Test get_ledger_obj_array_len with invalid slot
+        let array_result = unsafe { host::get_ledger_obj_array_len(1, sfield::Signers) };
+        if array_result < 0 {
+            let _ = trace_num(
+                "INFO: get_ledger_obj_array_len failed as expected:",
+                array_result as i64,
+            );
+        }
+
+        // Test get_ledger_obj_nested_array_len with invalid slot
+        let nested_array_result =
+            unsafe { host::get_ledger_obj_nested_array_len(1, locator.as_ptr(), locator.len()) };
+        if nested_array_result < 0 {
+            let _ = trace_num(
+                "INFO: get_ledger_obj_nested_array_len failed as expected:",
+                nested_array_result as i64,
+            );
+        }
+
+        let _ = trace("SUCCESS: Any ledger object functions (interface tested)");
+        return 0;
+    }
+
+    // If we successfully cached an object, test the access functions
+    let slot = cache_result;
+    let _ = trace_num("Successfully cached object in slot:", slot as i64);
+
+    // Test 4.2: get_ledger_obj_field() - Access field from cached object
+    let mut cached_balance_buffer = [0u8; 8];
+    let cached_balance_result = unsafe {
+        host::get_ledger_obj_field(
+            slot,
+            sfield::Balance,
+            cached_balance_buffer.as_mut_ptr(),
+            cached_balance_buffer.len(),
+        )
+    };
+
+    if cached_balance_result <= 0 {
+        let _ = trace_num(
+            "INFO: get_ledger_obj_field(Balance) failed:",
+            cached_balance_result as i64,
+        );
+    } else if cached_balance_result == 8 {
+        let _ = trace_num(
+            "Cached object balance length (XRP amount):",
+            cached_balance_result as i64,
+        );
+        let _ = trace_data(
+            "Cached object balance (serialized XRP amount):",
+            &cached_balance_buffer,
+            DataRepr::AsHex,
+        );
+    } else {
+        let _ = trace_num(
+            "Cached object balance length (non-XRP amount):",
+            cached_balance_result as i64,
+        );
+        let _ = trace_data(
+            "Cached object balance:",
+            &cached_balance_buffer[..cached_balance_result as usize],
+            DataRepr::AsHex,
+        );
+    }
+
+    // Test 4.3: get_ledger_obj_nested_field() - Nested field from cached object
+    let locator = [0x01, 0x00];
+    let mut cached_nested_buffer = [0u8; 32];
+    let cached_nested_result = unsafe {
+        host::get_ledger_obj_nested_field(
+            slot,
+            locator.as_ptr(),
+            locator.len(),
+            cached_nested_buffer.as_mut_ptr(),
+            cached_nested_buffer.len(),
+        )
+    };
+
+    if cached_nested_result < 0 {
+        let _ = trace_num(
+            "INFO: get_ledger_obj_nested_field not applicable:",
+            cached_nested_result as i64,
+        );
+    } else {
+        let _ = trace_num("Cached nested field length:", cached_nested_result as i64);
+        let _ = trace_data(
+            "Cached nested field:",
+            &cached_nested_buffer[..cached_nested_result as usize],
+            DataRepr::AsHex,
+        );
+    }
+
+    // Test 4.4: get_ledger_obj_array_len() - Array length from cached object
+    let cached_array_len = unsafe { host::get_ledger_obj_array_len(slot, sfield::Signers) };
+    let _ = trace_num(
+        "Cached object Signers array length:",
+        cached_array_len as i64,
+    );
+
+    // Test 4.5: get_ledger_obj_nested_array_len() - Nested array length from cached object
+    let cached_nested_array_len =
+        unsafe { host::get_ledger_obj_nested_array_len(slot, locator.as_ptr(), locator.len()) };
+
+    if cached_nested_array_len < 0 {
+        let _ = trace_num(
+            "INFO: get_ledger_obj_nested_array_len not applicable:",
+            cached_nested_array_len as i64,
+        );
+    } else {
+        let _ = trace_num(
+            "Cached nested array length:",
+            cached_nested_array_len as i64,
+        );
+    }
+
+    let _ = trace("SUCCESS: Any ledger object functions");
+    0
+}
+
+/// Test Category 5: Keylet Generation Functions (4 functions)
+/// Tests keylet generation functions for different ledger entry types
+fn test_keylet_generation_functions() -> i32 {
+    let _ = trace("--- Category 5: Keylet Generation Functions ---");
+
+    let escrow_finish = EscrowFinish;
+    let account_id = escrow_finish.get_account().unwrap();
+
+    // Test 5.1: account_keylet() - Generate keylet for account
+    let mut account_keylet_buffer = [0u8; 32];
+    let account_keylet_result = unsafe {
+        host::account_keylet(
+            account_id.0.as_ptr(),
+            account_id.0.len(),
+            account_keylet_buffer.as_mut_ptr(),
+            account_keylet_buffer.len(),
+        )
+    };
+
+    if account_keylet_result != 32 {
+        let _ = trace_num(
+            "ERROR: account_keylet failed:",
+            account_keylet_result as i64,
+        );
+        return -501; // Account keylet generation failed
+    }
+    let _ = trace_data("Account keylet:", &account_keylet_buffer, DataRepr::AsHex);
+
+    // Test 5.2: credential_keylet() - Generate keylet for credential
+    let mut credential_keylet_buffer = [0u8; 32];
+    let credential_keylet_result = unsafe {
+        host::credential_keylet(
+            account_id.0.as_ptr(), // Subject
+            account_id.0.len(),
+            account_id.0.as_ptr(), // Issuer - same account for test
+            account_id.0.len(),
+            b"TestType".as_ptr(), // Credential type
+            9usize,               // Length of "TestType"
+            credential_keylet_buffer.as_mut_ptr(),
+            credential_keylet_buffer.len(),
+        )
+    };
+
+    if credential_keylet_result <= 0 {
+        let _ = trace_num(
+            "INFO: credential_keylet failed (expected - interface issue):",
+            credential_keylet_result as i64,
+        );
+        // This is expected to fail due to unusual parameter types
+    } else {
+        let _ = trace_data(
+            "Credential keylet:",
+            &credential_keylet_buffer[..credential_keylet_result as usize],
+            DataRepr::AsHex,
+        );
+    }
+
+    // Test 5.3: escrow_keylet() - Generate keylet for escrow
+    let mut escrow_keylet_buffer = [0u8; 32];
+    let escrow_keylet_result = unsafe {
+        host::escrow_keylet(
+            account_id.0.as_ptr(),
+            account_id.0.len(),
+            1000, // Sequence number
+            escrow_keylet_buffer.as_mut_ptr(),
+            escrow_keylet_buffer.len(),
+        )
+    };
+
+    if escrow_keylet_result != 32 {
+        let _ = trace_num("ERROR: escrow_keylet failed:", escrow_keylet_result as i64);
+        return -503; // Escrow keylet generation failed
+    }
+    let _ = trace_data("Escrow keylet:", &escrow_keylet_buffer, DataRepr::AsHex);
+
+    // Test 5.4: oracle_keylet() - Generate keylet for oracle
+    let mut oracle_keylet_buffer = [0u8; 32];
+    let oracle_keylet_result = unsafe {
+        host::oracle_keylet(
+            account_id.0.as_ptr(),
+            account_id.0.len(),
+            42, // Document ID
+            oracle_keylet_buffer.as_mut_ptr(),
+            oracle_keylet_buffer.len(),
+        )
+    };
+
+    if oracle_keylet_result != 32 {
+        let _ = trace_num("ERROR: oracle_keylet failed:", oracle_keylet_result as i64);
+        return -504; // Oracle keylet generation failed
+    }
+    let _ = trace_data("Oracle keylet:", &oracle_keylet_buffer, DataRepr::AsHex);
+
+    let _ = trace("SUCCESS: Keylet generation functions");
+    0
+}
+
+/// Test Category 6: Utility Functions (4 functions)
+/// Tests utility functions for hashing, NFT access, and tracing
+fn test_utility_functions() -> i32 {
+    let _ = trace("--- Category 6: Utility Functions ---");
+
+    // Test 6.1: compute_sha512_half() - SHA512 hash computation (first 32 bytes)
+    let test_data = b"Hello, XRPL WASM world!";
+    let mut hash_output = [0u8; 32];
+    let hash_result = unsafe {
+        host::compute_sha512_half(
+            test_data.as_ptr(),
+            test_data.len(),
+            hash_output.as_mut_ptr(),
+            hash_output.len(),
+        )
+    };
+
+    if hash_result != 32 {
+        let _ = trace_num("ERROR: compute_sha512_half failed:", hash_result as i64);
+        return -601; // SHA512 half computation failed
+    }
+    let _ = trace_data("Input data:", test_data, DataRepr::AsHex);
+    let _ = trace_data("SHA512 half hash:", &hash_output, DataRepr::AsHex);
+
+    // Test 6.2: get_nft() - NFT data retrieval
+    let escrow_finish = EscrowFinish;
+    let account_id = escrow_finish.get_account().unwrap();
+    let nft_id = [0u8; 32]; // Dummy NFT ID for testing
+    let mut nft_buffer = [0u8; 256];
+    let nft_result = unsafe {
+        host::get_nft(
+            account_id.0.as_ptr(),
+            account_id.0.len(),
+            nft_id.as_ptr(),
+            nft_id.len(),
+            nft_buffer.as_mut_ptr(),
+            nft_buffer.len(),
+        )
+    };
+
+    if nft_result <= 0 {
+        let _ = trace_num(
+            "INFO: get_nft failed (expected - no such NFT):",
+            nft_result as i64,
+        );
+        // This is expected - test account likely doesn't own the dummy NFT
+    } else {
+        let _ = trace_num("NFT data length:", nft_result as i64);
+        let _ = trace_data(
+            "NFT data:",
+            &nft_buffer[..nft_result as usize],
+            DataRepr::AsHex,
+        );
+    }
+
+    // Test 6.3: trace() - Debug logging with data
+    let trace_message = b"Test trace message";
+    let trace_data_payload = b"payload";
+    let trace_result = unsafe {
+        host::trace(
+            trace_message.as_ptr(),
+            trace_message.len(),
+            trace_data_payload.as_ptr(),
+            trace_data_payload.len(),
+            1, // as_hex = true
+        )
+    };
+
+    if trace_result < 0 {
+        let _ = trace_num("ERROR: trace() failed:", trace_result as i64);
+        return -603; // Trace function failed
+    }
+    let _ = trace_num("Trace function bytes written:", trace_result as i64);
+
+    // Test 6.4: trace_num() - Debug logging with number
+    let test_number = 42i64;
+    let trace_num_result = trace_num("Test number trace", test_number);
+
+    use xrpl_std::host::Result;
+    match trace_num_result {
+        Result::Ok(_) => {
+            let _ = trace_num("Trace_num function succeeded", 0);
+        }
+        Result::Err(_) => {
+            let _ = trace_num("ERROR: trace_num() failed:", -604);
+            return -604; // Trace number function failed
+        }
+    }
+
+    let _ = trace("SUCCESS: Utility functions");
+    0
+}
+
+/// Test Category 7: Data Update Functions (1 function)
+/// Tests the function for modifying the current ledger entry
+fn test_data_update_functions() -> i32 {
+    let _ = trace("--- Category 7: Data Update Functions ---");
+
+    // Test 7.1: update_data() - Update current ledger entry data
+    let update_payload = b"Updated ledger entry data from WASM test";
+
+    let update_result = unsafe { host::update_data(update_payload.as_ptr(), update_payload.len()) };
+
+    if update_result != update_payload.len() as i32 {
+        let _ = trace_num("ERROR: update_data failed:", update_result as i64);
+        return -701; // Data update failed
+    }
+
+    let _ = trace_data(
+        "Successfully updated ledger entry with:",
+        update_payload,
+        DataRepr::AsHex,
+    );
+    let _ = trace("SUCCESS: Data update functions");
+    0
+}
@@ -0,0 +1,171 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "all_keylets"
+version = "0.0.1"
+dependencies = [
+ "xrpl-wasm-stdlib",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "bs58"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bb6743198531e02858aeaea5398fcc883e71851fcbcb5a2f773e2fb6cb1edf2"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.177"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.103"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.41"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce25767e7b499d1b604768e7cde645d14cc8584231ea6b295e9c9eb22c02e1d1"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da58917d35242480a05c2897064da0a80589a2a0476c9a3f2fdc83b53502e917"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+
+[[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "xrpl-address-macro"
+version = "0.7.1"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git#d27d3e0b4abf3c0215aade729d89053805efe48e"
+dependencies = [
+ "bs58",
+ "quote",
+ "sha2",
+ "syn",
+]
+
+[[package]]
+name = "xrpl-wasm-stdlib"
+version = "0.7.1"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git#d27d3e0b4abf3c0215aade729d89053805efe48e"
+dependencies = [
+ "xrpl-address-macro",
+]
@@ -0,0 +1,21 @@
+[package]
+edition = "2024"
+name = "all_keylets"
+version = "0.0.1"
+
+# This empty workspace definition keeps this project independent of the parent workspace
+[workspace]
+
+[lib]
+crate-type = ["cdylib"]
+
+[profile.release]
+lto = true
+opt-level = 's'
+panic = "abort"
+
+[dependencies]
+xrpl-std = { git = "https://github.com/ripple/xrpl-wasm-stdlib.git", package = "xrpl-wasm-stdlib" }
+
+[profile.dev]
+panic = "abort"
@@ -0,0 +1,181 @@
+#![cfg_attr(target_arch = "wasm32", no_std)]
+
+#[cfg(not(target_arch = "wasm32"))]
+extern crate std;
+
+use crate::host::{Error, Result, Result::Err, Result::Ok};
+use xrpl_std::core::ledger_objects::current_escrow::get_current_escrow;
+use xrpl_std::core::ledger_objects::current_escrow::CurrentEscrow;
+use xrpl_std::core::ledger_objects::ledger_object;
+use xrpl_std::core::ledger_objects::traits::CurrentEscrowFields;
+use xrpl_std::core::types::account_id::AccountID;
+use xrpl_std::core::types::currency::Currency;
+use xrpl_std::core::types::issue::{IouIssue, Issue, XrpIssue};
+use xrpl_std::core::types::keylets;
+use xrpl_std::core::types::mpt_id::MptId;
+use xrpl_std::core::types::uint::Hash256;
+use xrpl_std::host;
+use xrpl_std::host::trace::{trace, trace_account, trace_data, trace_num, DataRepr};
+use xrpl_std::sfield;
+
+#[unsafe(no_mangle)]
+pub fn object_exists(
+    keylet_result: Result<keylets::KeyletBytes>,
+    keylet_type: &str,
+    field: i32,
+) -> Result<bool> {
+    match keylet_result {
+        Ok(keylet) => {
+            let _ = trace_data(keylet_type, &keylet, DataRepr::AsHex);
+
+            let slot = unsafe { host::cache_ledger_obj(keylet.as_ptr(), keylet.len(), 0) };
+            if slot <= 0 {
+                let _ = trace_num("Error: ", slot.into());
+                return Err(Error::from_code(slot));
+            }
+            if field == 0 {
+                let new_field = sfield::PreviousTxnID;
+                let _ = trace_num("Getting field: ", new_field.into());
+                match ledger_object::get_field::<Hash256>(slot, new_field) {
+                    Ok(data) => {
+                        let _ = trace_data("Field data: ", &data.0, DataRepr::AsHex);
+                    }
+                    Err(result_code) => {
+                        let _ = trace_num("Error getting field: ", result_code.into());
+                        return Err(result_code);
+                    }
+                }
+            } else {
+                let _ = trace_num("Getting field: ", field.into());
+                match ledger_object::get_field::<AccountID>(slot, field) {
+                    Ok(data) => {
+                        let _ = trace_data("Field data: ", &data.0, DataRepr::AsHex);
+                    }
+                    Err(result_code) => {
+                        let _ = trace_num("Error getting field: ", result_code.into());
+                        return Err(result_code);
+                    }
+                }
+            }
+
+            Ok(true)
+        }
+        Err(error) => {
+            let _ = trace_num("Error getting keylet: ", error.into());
+            Err(error)
+        }
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn finish() -> i32 {
+    let _ = trace("$$$$$ STARTING WASM EXECUTION $$$$$");
+
+    let escrow: CurrentEscrow = get_current_escrow();
+
+    let account = escrow.get_account().unwrap_or_panic();
+    let _ = trace_account("Account:", &account);
+
+    let destination = escrow.get_destination().unwrap_or_panic();
+    let _ = trace_account("Destination:", &destination);
+
+    let mut seq = 5;
+
+    macro_rules! check_object_exists {
+        ($keylet:expr, $type:expr, $field:expr) => {
+            match object_exists($keylet, $type, $field) {
+                Ok(_exists) => {
+                    // false isn't returned
+                    let _ = trace(concat!(
+                        $type,
+                        " object exists, proceeding with escrow finish."
+                    ));
+                }
+                Err(error) => {
+                    let _ = trace_num("Current seq value:", seq.try_into().unwrap());
+                    return error.code();
+                }
+            }
+        };
+    }
+
+    let account_keylet = keylets::account_keylet(&account);
+    check_object_exists!(account_keylet, "Account", sfield::Account);
+
+    let currency_code: &[u8; 3] = b"USD";
+    let currency: Currency = Currency::from(*currency_code);
+    let line_keylet = keylets::line_keylet(&account, &destination, &currency);
+    check_object_exists!(line_keylet, "Trustline", sfield::Generic);
+    seq += 1;
+
+    let asset1 = Issue::XRP(XrpIssue {});
+    let asset2 = Issue::IOU(IouIssue::new(destination, currency));
+    check_object_exists!(
+        keylets::amm_keylet(&asset1, &asset2),
+        "AMM",
+        sfield::Account
+    );
+
+    let check_keylet = keylets::check_keylet(&account, seq);
+    check_object_exists!(check_keylet, "Check", sfield::Account);
+    seq += 1;
+
+    let cred_type: &[u8] = b"termsandconditions";
+    let credential_keylet = keylets::credential_keylet(&account, &account, cred_type);
+    check_object_exists!(credential_keylet, "Credential", sfield::Subject);
+    seq += 1;
+
+    let delegate_keylet = keylets::delegate_keylet(&account, &destination);
+    check_object_exists!(delegate_keylet, "Delegate", sfield::Account);
+    seq += 1;
+
+    let deposit_preauth_keylet = keylets::deposit_preauth_keylet(&account, &destination);
+    check_object_exists!(deposit_preauth_keylet, "DepositPreauth", sfield::Account);
+    seq += 1;
+
+    let did_keylet = keylets::did_keylet(&account);
+    check_object_exists!(did_keylet, "DID", sfield::Account);
+    seq += 1;
+
+    let escrow_keylet = keylets::escrow_keylet(&account, seq);
+    check_object_exists!(escrow_keylet, "Escrow", sfield::Account);
+    seq += 1;
+
+    let mpt_issuance_keylet = keylets::mpt_issuance_keylet(&account, seq);
+    let mpt_id = MptId::new(seq.try_into().unwrap(), account);
+    check_object_exists!(mpt_issuance_keylet, "MPTIssuance", sfield::Issuer);
+    seq += 1;
+
+    let mptoken_keylet = keylets::mptoken_keylet(&mpt_id, &destination);
+    check_object_exists!(mptoken_keylet, "MPToken", sfield::Account);
+
+    let nft_offer_keylet = keylets::nft_offer_keylet(&destination, 6);
+    check_object_exists!(nft_offer_keylet, "NFTokenOffer", sfield::Owner);
+
+    let offer_keylet = keylets::offer_keylet(&account, seq);
+    check_object_exists!(offer_keylet, "Offer", sfield::Account);
+    seq += 1;
+
+    let paychan_keylet = keylets::paychan_keylet(&account, &destination, seq);
+    check_object_exists!(paychan_keylet, "PayChannel", sfield::Account);
+    seq += 1;
+
+    let pd_keylet = keylets::permissioned_domain_keylet(&account, seq);
+    check_object_exists!(pd_keylet, "PermissionedDomain", sfield::Owner);
+    seq += 1;
+
+    let signers_keylet = keylets::signers_keylet(&account);
+    check_object_exists!(signers_keylet, "SignerList", sfield::Generic);
+    seq += 1;
+
+    seq += 1; // ticket sequence number is one greater
+    let ticket_keylet = keylets::ticket_keylet(&account, seq);
+    check_object_exists!(ticket_keylet, "Ticket", sfield::Account);
+    seq += 1;
+
+    let vault_keylet = keylets::vault_keylet(&account, seq);
+    check_object_exists!(vault_keylet, "Vault", sfield::Account);
+    // seq += 1;
+
+    1 // All keylets exist, finish the escrow.
+}
@@ -0,0 +1,73 @@
+#include <stdint.h>
+
+static char const b58digits_ordered[] =
+    "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+
+uint8_t e_data[32 * 1024];
+
+void*
+allocate(int sz)
+{
+    static int idx = 0;
+    if (idx >= 32)
+        return 0;
+    if (sz > 1024)
+        return 0;
+    return &e_data[idx++ << 10];
+}
+
+void
+deallocate(void* p)
+{
+}
+
+extern int32_t
+b58enco(char* b58, int32_t b58sz, void const* data, int32_t binsz)
+{
+    uint8_t const* bin = data;
+    int32_t carry;
+    int32_t i, j, high, zcount = 0;
+    int32_t size;
+
+    while (zcount < binsz && !bin[zcount])
+        ++zcount;
+
+    size = (binsz - zcount) * 138 / 100 + 1;
+    uint8_t* buf = allocate(size);
+    if (!buf)
+        return 0;
+    // memset(buf, 0, size);
+    for (i = 0; i < size; ++i)
+        buf[i] = 0;
+
+    for (i = zcount, high = size - 1; i < binsz; ++i, high = j)
+    {
+        for (carry = bin[i], j = size - 1; (j > high) || carry; --j)
+        {
+            carry += 256 * buf[j];
+            buf[j] = carry % 58;
+            carry /= 58;
+            if (!j)
+                break;
+        }
+    }
+
+    for (j = 0; j < size && !buf[j]; ++j)
+        ;
+
+    if (b58sz <= zcount + size - j)
+        return 0;
+
+    if (zcount)
+    {
+        // memset(b58, '1', zcount);
+        for (i = 0; i < zcount; ++i)
+            b58[i] = '1';
+    }
+
+    for (i = zcount; j < size; ++i, ++j)
+        b58[i] = b58digits_ordered[buf[j]];
+    b58[i] = '\0';
+
+    return i + 1;
+}
@@ -0,0 +1,171 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "bs58"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "codecov_tests"
+version = "0.0.1"
+dependencies = [
+ "xrpl-wasm-stdlib",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bb6743198531e02858aeaea5398fcc883e71851fcbcb5a2f773e2fb6cb1edf2"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.177"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.103"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.41"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce25767e7b499d1b604768e7cde645d14cc8584231ea6b295e9c9eb22c02e1d1"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da58917d35242480a05c2897064da0a80589a2a0476c9a3f2fdc83b53502e917"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+
+[[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "xrpl-address-macro"
+version = "0.7.1"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git#d27d3e0b4abf3c0215aade729d89053805efe48e"
+dependencies = [
+ "bs58",
+ "quote",
+ "sha2",
+ "syn",
+]
+
+[[package]]
+name = "xrpl-wasm-stdlib"
+version = "0.7.1"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git#d27d3e0b4abf3c0215aade729d89053805efe48e"
+dependencies = [
+ "xrpl-address-macro",
+]
@@ -0,0 +1,18 @@
+[package]
+edition = "2024"
+name = "codecov_tests"
+version = "0.0.1"
+
+# This empty workspace definition keeps this project independent of the parent workspace
+[workspace]
+
+[lib]
+crate-type = ["cdylib"]
+
+[profile.release]
+lto = true
+opt-level = 's'
+panic = "abort"
+
+[dependencies]
+xrpl-std = { git = "https://github.com/ripple/xrpl-wasm-stdlib.git", package = "xrpl-wasm-stdlib" }
@@ -0,0 +1,47 @@
+//TODO add docs after discussing the interface
+//Note that Craft currently does not honor the rounding modes
+#[allow(unused)]
+pub const FLOAT_ROUNDING_MODES_TO_NEAREST: i32 = 0;
+#[allow(unused)]
+pub const FLOAT_ROUNDING_MODES_TOWARDS_ZERO: i32 = 1;
+#[allow(unused)]
+pub const FLOAT_ROUNDING_MODES_DOWNWARD: i32 = 2;
+#[allow(unused)]
+pub const FLOAT_ROUNDING_MODES_UPWARD: i32 = 3;
+
+// pub enum RippledRoundingModes{
+//     ToNearest = 0,
+//     TowardsZero = 1,
+//     DOWNWARD = 2,
+//     UPWARD = 3
+// }
+
+#[allow(unused)]
+#[link(wasm_import_module = "host_lib")]
+unsafe extern "C" {
+    pub fn get_parent_ledger_hash(out_buff_ptr: i32, out_buff_len: i32) -> i32;
+
+    pub fn cache_ledger_obj(keylet_ptr: i32, keylet_len: i32, cache_num: i32) -> i32;
+
+    pub fn get_tx_nested_array_len(locator_ptr: i32, locator_len: i32) -> i32;
+
+    pub fn account_keylet(
+        account_ptr: i32,
+        account_len: i32,
+        out_buff_ptr: *mut u8,
+        out_buff_len: usize,
+    ) -> i32;
+
+    pub fn line_keylet(
+        account1_ptr: *const u8,
+        account1_len: usize,
+        account2_ptr: *const u8,
+        account2_len: usize,
+        currency_ptr: i32,
+        currency_len: i32,
+        out_buff_ptr: *mut u8,
+        out_buff_len: usize,
+    ) -> i32;
+
+    pub fn trace_num(msg_read_ptr: i32, msg_read_len: i32, number: i64) -> i32;
+}
@@ -0,0 +1,134 @@
+import os
+import sys
+import subprocess
+import re
+
+OPT = "-Oz"
+
+
+def update_fixture(project_name, wasm):
+    fixture_name = (
+        re.sub(r"_([a-z])", lambda m: m.group(1).upper(), project_name) + "WasmHex"
+    )
+    print(f"Updating fixture: {fixture_name}")
+
+    cpp_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "fixtures.cpp"))
+    h_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "fixtures.h"))
+    with open(cpp_path, "r", encoding="utf8") as f:
+        cpp_content = f.read()
+
+    pattern = rf'extern std::string const {fixture_name} =[ \n]+"[^;]*;'
+    if re.search(pattern, cpp_content, flags=re.MULTILINE):
+        updated_cpp_content = re.sub(
+            pattern,
+            f'extern std::string const {fixture_name} = "{wasm}";',
+            cpp_content,
+            flags=re.MULTILINE,
+        )
+    else:
+        with open(h_path, "r", encoding="utf8") as f:
+            h_content = f.read()
+        updated_h_content = (
+            h_content.rstrip() + f"\n\n extern std::string const {fixture_name};\n"
+        )
+        with open(h_path, "w", encoding="utf8") as f:
+            f.write(updated_h_content)
+        updated_cpp_content = (
+            cpp_content.rstrip()
+            + f'\n\nextern std::string const {fixture_name} = "{wasm}";\n'
+        )
+
+    with open(cpp_path, "w", encoding="utf8") as f:
+        f.write(updated_cpp_content)
+
+
+def process_rust(project_name):
+    project_path = os.path.abspath(
+        os.path.join(os.path.dirname(__file__), project_name)
+    )
+    wasm_location = f"target/wasm32v1-none/release/{project_name}.wasm"
+    build_cmd = (
+        f"(cd {project_path} "
+        f"&& cargo build --target wasm32v1-none --release "
+        f"&& wasm-opt {wasm_location} {OPT} -o {wasm_location}"
+        ")"
+    )
+    try:
+        result = subprocess.run(
+            build_cmd, shell=True, check=True, capture_output=True, text=True
+        )
+        print(f"stdout: {result.stdout}")
+        if result.stderr:
+            print(f"stderr: {result.stderr}")
+        print(f"WASM file for {project_name} has been built and optimized.")
+    except subprocess.CalledProcessError as e:
+        print(f"exec error: {e}")
+        sys.exit(1)
+
+    src_path = os.path.abspath(
+        os.path.join(
+            os.path.dirname(__file__),
+            f"{project_name}/target/wasm32v1-none/release/{project_name}.wasm",
+        )
+    )
+    with open(src_path, "rb") as f:
+        data = f.read()
+    wasm = data.hex()
+    update_fixture(project_name, wasm)
+
+
+def process_c(project_name):
+    project_path = os.path.abspath(
+        os.path.join(os.path.dirname(__file__), f"{project_name}.c")
+    )
+    wasm_path = os.path.abspath(
+        os.path.join(os.path.dirname(__file__), f"{project_name}.wasm")
+    )
+    build_cmd = (
+        f"$CC --sysroot=$SYSROOT "
+        f"-O3 -ffast-math --target=wasm32 -fno-exceptions -fno-threadsafe-statics -fvisibility=default -Wl,--export-all -Wl,--no-entry -Wl,--allow-undefined -DNDEBUG --no-standard-libraries -fno-builtin-memset "
+        f"-o {wasm_path} {project_path}"
+        f"&& wasm-opt {wasm_path} {OPT} -o {wasm_path}"
+    )
+    try:
+        result = subprocess.run(
+            build_cmd, shell=True, check=True, capture_output=True, text=True
+        )
+        print(f"stdout: {result.stdout}")
+        if result.stderr:
+            print(f"stderr: {result.stderr}")
+        print(
+            f"WASM file for {project_name} has been built with WASI support using clang."
+        )
+    except subprocess.CalledProcessError as e:
+        print(f"exec error: {e}")
+        sys.exit(1)
+
+    with open(wasm_path, "rb") as f:
+        data = f.read()
+    wasm = data.hex()
+    update_fixture(project_name, wasm)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 2:
+        print("Usage: python copyFixtures.py [<project_name>]")
+        sys.exit(1)
+    if len(sys.argv) == 2:
+        if os.path.isdir(os.path.join(os.path.dirname(__file__), sys.argv[1])):
+            process_rust(sys.argv[1])
+        else:
+            process_c(sys.argv[1])
+        print("Fixture has been processed.")
+    else:
+        dirs = [
+            d
+            for d in os.listdir(os.path.dirname(__file__))
+            if os.path.isdir(os.path.join(os.path.dirname(__file__), d))
+        ]
+        c_files = [f for f in os.listdir(os.path.dirname(__file__)) if f.endswith(".c")]
+        for d in dirs:
+            process_rust(d)
+        for c in c_files:
+            process_c(c[:-2])
+        print("All fixtures have been processed.")
@@ -0,0 +1,34 @@
+(module
+  (type (;0;) (func))
+  (type (;1;) (func (result i32)))
+  (func (;0;) (type 0))
+  (func (;1;) (type 1) (result i32)
+    f32.const -2048
+    f32.const 2050
+    f32.sub
+    drop
+    i32.const 1)
+  (memory (;0;) 2)
+  (global (;0;) i32 (i32.const 1024))
+  (global (;1;) i32 (i32.const 1024))
+  (global (;2;) i32 (i32.const 2048))
+  (global (;3;) i32 (i32.const 2048))
+  (global (;4;) i32 (i32.const 67584))
+  (global (;5;) i32 (i32.const 1024))
+  (global (;6;) i32 (i32.const 67584))
+  (global (;7;) i32 (i32.const 131072))
+  (global (;8;) i32 (i32.const 0))
+  (global (;9;) i32 (i32.const 1))
+  (export "memory" (memory 0))
+  (export "__wasm_call_ctors" (func 0))
+  (export "finish" (func 1))
+  (export "buf" (global 0))
+  (export "__dso_handle" (global 1))
+  (export "__data_end" (global 2))
+  (export "__stack_low" (global 3))
+  (export "__stack_high" (global 4))
+  (export "__global_base" (global 5))
+  (export "__heap_base" (global 6))
+  (export "__heap_end" (global 7))
+  (export "__memory_base" (global 8))
+  (export "__table_base" (global 9)))
@@ -0,0 +1,12 @@
+// typedef long long mint;
+typedef int mint;
+
+mint
+fib(mint n)
+{
+    if (!n)
+        return 0;
+    if (n <= 2)
+        return 1;
+    return fib(n - 1) + fib(n - 2);
+}
@@ -0,0 +1,31 @@
+#pragma once
+
+// TODO: consider moving these to separate files (and figure out the build)
+
+#include <string>
+
+extern std::string const ledgerSqnWasmHex;
+
+extern std::string const allHostFunctionsWasmHex;
+
+extern std::string const deepRecursionHex;
+
+extern std::string const fibWasmHex;
+
+extern std::string const b58WasmHex;
+
+extern std::string const sha512PureWasmHex;
+
+extern std::string const hfPerfTest;
+
+extern std::string const allKeyletsWasmHex;
+
+extern std::string const codecovTestsWasmHex;
+
+extern std::string const floatTestsWasmHex;
+
+extern std::string const float0Hex;
+
+extern std::string const disabledFloatHex;
+
+extern std::string const updateDataWasmHex;
@@ -0,0 +1,171 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "bs58"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "float_tests"
+version = "0.0.1"
+dependencies = [
+ "xrpl-wasm-stdlib",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bb6743198531e02858aeaea5398fcc883e71851fcbcb5a2f773e2fb6cb1edf2"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.177"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.103"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.41"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce25767e7b499d1b604768e7cde645d14cc8584231ea6b295e9c9eb22c02e1d1"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da58917d35242480a05c2897064da0a80589a2a0476c9a3f2fdc83b53502e917"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+
+[[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "xrpl-address-macro"
+version = "0.7.1"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git#d27d3e0b4abf3c0215aade729d89053805efe48e"
+dependencies = [
+ "bs58",
+ "quote",
+ "sha2",
+ "syn",
+]
+
+[[package]]
+name = "xrpl-wasm-stdlib"
+version = "0.7.1"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git#d27d3e0b4abf3c0215aade729d89053805efe48e"
+dependencies = [
+ "xrpl-address-macro",
+]
@@ -0,0 +1,21 @@
+[package]
+name = "float_tests"
+version = "0.0.1"
+edition = "2024"
+
+# This empty workspace definition keeps this project independent of the parent workspace
+[workspace]
+
+[lib]
+crate-type = ["cdylib"]
+
+[profile.release]
+lto = true
+opt-level = 's'
+panic = "abort"
+
+[dependencies]
+xrpl-std = { git = "https://github.com/ripple/xrpl-wasm-stdlib.git", package = "xrpl-wasm-stdlib" }
+
+[profile.dev]
+panic = "abort"
@@ -0,0 +1,461 @@
+#![allow(unused_imports)]
+#![allow(unused_variables)]
+#![cfg_attr(target_arch = "wasm32", no_std)]
+
+#[cfg(not(target_arch = "wasm32"))]
+extern crate std;
+
+use xrpl_std::core::locator::Locator;
+use xrpl_std::core::types::opaque_float::{FLOAT_NEGATIVE_ONE, FLOAT_ONE};
+use xrpl_std::decode_hex_32;
+use xrpl_std::host::trace::DataRepr::AsHex;
+use xrpl_std::host::trace::{trace, trace_data, trace_float, trace_num, DataRepr};
+use xrpl_std::host::{
+    cache_ledger_obj, float_add, float_compare, float_divide, float_from_int, float_from_uint,
+    float_log, float_multiply, float_pow, float_root, float_set, float_subtract,
+    get_ledger_obj_array_len, get_ledger_obj_field, get_ledger_obj_nested_field,
+    trace_opaque_float, FLOAT_ROUNDING_MODES_TO_NEAREST,
+};
+use xrpl_std::sfield;
+use xrpl_std::sfield::{
+    Account, AccountTxnID, Balance, Domain, EmailHash, Flags, LedgerEntryType, MessageKey,
+    OwnerCount, PreviousTxnID, PreviousTxnLgrSeq, RegularKey, Sequence, TicketCount, TransferRate,
+};
+
+fn test_float_from_wasm() {
+    let _ = trace("\n$$$ test_float_from_wasm $$$");
+
+    let mut f: [u8; 8] = [0u8; 8];
+    if 8 == unsafe { float_from_int(12300, f.as_mut_ptr(), 8, FLOAT_ROUNDING_MODES_TO_NEAREST) } {
+        let _ = trace_float("  float from i64 12300:", &f);
+        let _ = trace_data("  float from i64 12300 as HEX:", &f, AsHex);
+    } else {
+        let _ = trace("  float from i64 12300: failed");
+    }
+
+    let u64_value: u64 = 12300;
+    if 8 == unsafe {
+        float_from_uint(
+            &u64_value as *const u64 as *const u8,
+            8,
+            f.as_mut_ptr(),
+            8,
+            FLOAT_ROUNDING_MODES_TO_NEAREST,
+        )
+    } {
+        let _ = trace_float("  float from u64 12300:", &f);
+    } else {
+        let _ = trace("  float from u64 12300: failed");
+    }
+
+    if 8 == unsafe { float_set(2, 123, f.as_mut_ptr(), 8, FLOAT_ROUNDING_MODES_TO_NEAREST) } {
+        let _ = trace_float("  float from exp 2, mantissa 123:", &f);
+    } else {
+        let _ = trace("  float from exp 2, mantissa 3: failed");
+    }
+
+    let _ = trace_float("  float from const 1:", &FLOAT_ONE);
+    let _ = trace_float("  float from const -1:", &FLOAT_NEGATIVE_ONE);
+}
+
+fn test_float_compare() {
+    let _ = trace("\n$$$ test_float_compare $$$");
+
+    let mut f1: [u8; 8] = [0u8; 8];
+    if 8 != unsafe { float_from_int(1, f1.as_mut_ptr(), 8, FLOAT_ROUNDING_MODES_TO_NEAREST) } {
+        let _ = trace("  float from 1: failed");
+    } else {
+        let _ = trace_float("  float from 1:", &f1);
+    }
+
+    if 0 == unsafe { float_compare(f1.as_ptr(), 8, FLOAT_ONE.as_ptr(), 8) } {
+        let _ = trace("  float from 1 == FLOAT_ONE");
+    } else {
+        let _ = trace("  float from 1 != FLOAT_ONE");
+    }
+
+    if 1 == unsafe { float_compare(f1.as_ptr(), 8, FLOAT_NEGATIVE_ONE.as_ptr(), 8) } {
+        let _ = trace("  float from 1 > FLOAT_NEGATIVE_ONE");
+    } else {
+        let _ = trace("  float from 1 !> FLOAT_NEGATIVE_ONE");
+    }
+
+    if 2 == unsafe { float_compare(FLOAT_NEGATIVE_ONE.as_ptr(), 8, f1.as_ptr(), 8) } {
+        let _ = trace("  FLOAT_NEGATIVE_ONE < float from 1");
+    } else {
+        let _ = trace("  FLOAT_NEGATIVE_ONE !< float from 1");
+    }
+}
+
+fn test_float_add_subtract() {
+    let _ = trace("\n$$$ test_float_add_subtract $$$");
+
+    let mut f_compute: [u8; 8] = FLOAT_ONE;
+    for i in 0..9 {
+        unsafe {
+            float_add(
+                f_compute.as_ptr(),
+                8,
+                FLOAT_ONE.as_ptr(),
+                8,
+                f_compute.as_mut_ptr(),
+                8,
+                FLOAT_ROUNDING_MODES_TO_NEAREST,
+            )
+        };
+        // let _ = trace_float("  float:", &f_compute);
+    }
+    let mut f10: [u8; 8] = [0u8; 8];
+    if 8 != unsafe { float_from_int(10, f10.as_mut_ptr(), 8, FLOAT_ROUNDING_MODES_TO_NEAREST) } {
+        // let _ = trace("  float from 10: failed");
+    }
+    if 0 == unsafe { float_compare(f10.as_ptr(), 8, f_compute.as_ptr(), 8) } {
+        let _ = trace("  repeated add: good");
+    } else {
+        let _ = trace("  repeated add: bad");
+    }
+
+    for i in 0..11 {
+        unsafe {
+            float_subtract(
+                f_compute.as_ptr(),
+                8,
+                FLOAT_ONE.as_ptr(),
+                8,
+                f_compute.as_mut_ptr(),
+                8,
+                FLOAT_ROUNDING_MODES_TO_NEAREST,
+            )
+        };
+    }
+    if 0 == unsafe { float_compare(f_compute.as_ptr(), 8, FLOAT_NEGATIVE_ONE.as_ptr(), 8) } {
+        let _ = trace("  repeated subtract: good");
+    } else {
+        let _ = trace("  repeated subtract: bad");
+    }
+}
+
+fn test_float_multiply_divide() {
+    let _ = trace("\n$$$ test_float_multiply_divide $$$");
+
+    let mut f10: [u8; 8] = [0u8; 8];
+    unsafe { float_from_int(10, f10.as_mut_ptr(), 8, FLOAT_ROUNDING_MODES_TO_NEAREST) };
+    let mut f_compute: [u8; 8] = FLOAT_ONE;
+    for i in 0..6 {
+        unsafe {
+            float_multiply(
+                f_compute.as_ptr(),
+                8,
+                f10.as_ptr(),
+                8,
+                f_compute.as_mut_ptr(),
+                8,
+                FLOAT_ROUNDING_MODES_TO_NEAREST,
+            )
+        };
+        // let _ = trace_float("  float:", &f_compute);
+    }
+    let mut f1000000: [u8; 8] = [0u8; 8];
+    unsafe {
+        float_from_int(
+            1000000,
+            f1000000.as_mut_ptr(),
+            8,
+            FLOAT_ROUNDING_MODES_TO_NEAREST,
+        )
+    };
+
+    if 0 == unsafe { float_compare(f1000000.as_ptr(), 8, f_compute.as_ptr(), 8) } {
+        let _ = trace("  repeated multiply: good");
+    } else {
+        let _ = trace("  repeated multiply: bad");
+    }
+
+    for i in 0..7 {
+        unsafe {
+            float_divide(
+                f_compute.as_ptr(),
+                8,
+                f10.as_ptr(),
+                8,
+                f_compute.as_mut_ptr(),
+                8,
+                FLOAT_ROUNDING_MODES_TO_NEAREST,
+            )
+        };
+    }
+    let mut f01: [u8; 8] = [0u8; 8];
+    unsafe { float_set(-1, 1, f01.as_mut_ptr(), 8, FLOAT_ROUNDING_MODES_TO_NEAREST) };
+
+    if 0 == unsafe { float_compare(f_compute.as_ptr(), 8, f01.as_ptr(), 8) } {
+        let _ = trace("  repeated divide: good");
+    } else {
+        let _ = trace("  repeated divide: bad");
+    }
+}
+
+fn test_float_pow() {
+    let _ = trace("\n$$$ test_float_pow $$$");
+
+    let mut f_compute: [u8; 8] = [0u8; 8];
+    unsafe {
+        float_pow(
+            FLOAT_ONE.as_ptr(),
+            8,
+            3,
+            f_compute.as_mut_ptr(),
+            8,
+            FLOAT_ROUNDING_MODES_TO_NEAREST,
+        )
+    };
+    let _ = trace_float("  float cube of 1:", &f_compute);
+
+    unsafe {
+        float_pow(
+            FLOAT_NEGATIVE_ONE.as_ptr(),
+            8,
+            6,
+            f_compute.as_mut_ptr(),
+            8,
+            FLOAT_ROUNDING_MODES_TO_NEAREST,
+        )
+    };
+    let _ = trace_float("  float 6th power of -1:", &f_compute);
+
+    let mut f9: [u8; 8] = [0u8; 8];
+    unsafe { float_from_int(9, f9.as_mut_ptr(), 8, FLOAT_ROUNDING_MODES_TO_NEAREST) };
+    unsafe {
+        float_pow(
+            f9.as_ptr(),
+            8,
+            2,
+            f_compute.as_mut_ptr(),
+            8,
+            FLOAT_ROUNDING_MODES_TO_NEAREST,
+        )
+    };
+    let _ = trace_float("  float square of 9:", &f_compute);
+
+    unsafe {
+        float_pow(
+            f9.as_ptr(),
+            8,
+            0,
+            f_compute.as_mut_ptr(),
+            8,
+            FLOAT_ROUNDING_MODES_TO_NEAREST,
+        )
+    };
+    let _ = trace_float("  float 0th power of 9:", &f_compute);
+
+    let mut f0: [u8; 8] = [0u8; 8];
+    unsafe { float_from_int(0, f0.as_mut_ptr(), 8, FLOAT_ROUNDING_MODES_TO_NEAREST) };
+    unsafe {
+        float_pow(
+            f0.as_ptr(),
+            8,
+            2,
+            f_compute.as_mut_ptr(),
+            8,
+            FLOAT_ROUNDING_MODES_TO_NEAREST,
+        )
+    };
+    let _ = trace_float("  float square of 0:", &f_compute);
+
+    let r = unsafe {
+        float_pow(
+            f0.as_ptr(),
+            8,
+            0,
+            f_compute.as_mut_ptr(),
+            8,
+            FLOAT_ROUNDING_MODES_TO_NEAREST,
+        )
+    };
+    let _ = trace_num(
+        "  float 0th power of 0 (expecting INVALID_PARAMS error):",
+        r as i64,
+    );
+}
+
+fn test_float_root() {
+    let _ = trace("\n$$$ test_float_root $$$");
+
+    let mut f9: [u8; 8] = [0u8; 8];
+    unsafe { float_from_int(9, f9.as_mut_ptr(), 8, FLOAT_ROUNDING_MODES_TO_NEAREST) };
+    let mut f_compute: [u8; 8] = [0u8; 8];
+    unsafe {
+        float_root(
+            f9.as_ptr(),
+            8,
+            2,
+            f_compute.as_mut_ptr(),
+            8,
+            FLOAT_ROUNDING_MODES_TO_NEAREST,
+        )
+    };
+    let _ = trace_float("  float sqrt of 9:", &f_compute);
+    unsafe {
+        float_root(
+            f9.as_ptr(),
+            8,
+            3,
+            f_compute.as_mut_ptr(),
+            8,
+            FLOAT_ROUNDING_MODES_TO_NEAREST,
+        )
+    };
+    let _ = trace_float("  float cbrt of 9:", &f_compute);
+
+    let mut f1000000: [u8; 8] = [0u8; 8];
+    unsafe {
+        float_from_int(
+            1000000,
+            f1000000.as_mut_ptr(),
+            8,
+            FLOAT_ROUNDING_MODES_TO_NEAREST,
+        )
+    };
+    unsafe {
+        float_root(
+            f1000000.as_ptr(),
+            8,
+            3,
+            f_compute.as_mut_ptr(),
+            8,
+            FLOAT_ROUNDING_MODES_TO_NEAREST,
+        )
+    };
+    let _ = trace_float("  float cbrt of 1000000:", &f_compute);
+    unsafe {
+        float_root(
+            f1000000.as_ptr(),
+            8,
+            6,
+            f_compute.as_mut_ptr(),
+            8,
+            FLOAT_ROUNDING_MODES_TO_NEAREST,
+        )
+    };
+    let _ = trace_float("  float 6th root of 1000000:", &f_compute);
+}
+
+fn test_float_log() {
+    let _ = trace("\n$$$ test_float_log $$$");
+
+    let mut f1000000: [u8; 8] = [0u8; 8];
+    unsafe {
+        float_from_int(
+            1000000,
+            f1000000.as_mut_ptr(),
+            8,
+            FLOAT_ROUNDING_MODES_TO_NEAREST,
+        )
+    };
+    let mut f_compute: [u8; 8] = [0u8; 8];
+    unsafe {
+        float_log(
+            f1000000.as_ptr(),
+            8,
+            f_compute.as_mut_ptr(),
+            8,
+            FLOAT_ROUNDING_MODES_TO_NEAREST,
+        )
+    };
+    let _ = trace_float("  log_10 of 1000000:", &f_compute);
+}
+
+fn test_float_negate() {
+    let _ = trace("\n$$$ test_float_negate $$$");
+
+    let mut f_compute: [u8; 8] = [0u8; 8];
+    unsafe {
+        float_multiply(
+            FLOAT_ONE.as_ptr(),
+            8,
+            FLOAT_NEGATIVE_ONE.as_ptr(),
+            8,
+            f_compute.as_mut_ptr(),
+            8,
+            FLOAT_ROUNDING_MODES_TO_NEAREST,
+        )
+    };
+    // let _ = trace_float("  float:", &f_compute);
+    if 0 == unsafe { float_compare(FLOAT_NEGATIVE_ONE.as_ptr(), 8, f_compute.as_ptr(), 8) } {
+        let _ = trace("  negate const 1: good");
+    } else {
+        let _ = trace("  negate const 1: bad");
+    }
+
+    unsafe {
+        float_multiply(
+            FLOAT_NEGATIVE_ONE.as_ptr(),
+            8,
+            FLOAT_NEGATIVE_ONE.as_ptr(),
+            8,
+            f_compute.as_mut_ptr(),
+            8,
+            FLOAT_ROUNDING_MODES_TO_NEAREST,
+        )
+    };
+    // let _ = trace_float("  float:", &f_compute);
+    if 0 == unsafe { float_compare(FLOAT_ONE.as_ptr(), 8, f_compute.as_ptr(), 8) } {
+        let _ = trace("  negate const -1: good");
+    } else {
+        let _ = trace("  negate const -1: bad");
+    }
+}
+
+fn test_float_invert() {
+    let _ = trace("\n$$$ test_float_invert $$$");
+
+    let mut f_compute: [u8; 8] = [0u8; 8];
+    let mut f10: [u8; 8] = [0u8; 8];
+    unsafe { float_from_int(10, f10.as_mut_ptr(), 8, FLOAT_ROUNDING_MODES_TO_NEAREST) };
+    unsafe {
+        float_divide(
+            FLOAT_ONE.as_ptr(),
+            8,
+            f10.as_ptr(),
+            8,
+            f_compute.as_mut_ptr(),
+            8,
+            FLOAT_ROUNDING_MODES_TO_NEAREST,
+        )
+    };
+    let _ = trace_float("  invert a float from 10:", &f_compute);
+    unsafe {
+        float_divide(
+            FLOAT_ONE.as_ptr(),
+            8,
+            f_compute.as_ptr(),
+            8,
+            f_compute.as_mut_ptr(),
+            8,
+            FLOAT_ROUNDING_MODES_TO_NEAREST,
+        )
+    };
+    let _ = trace_float("  invert again:", &f_compute);
+
+    // if f10's value is 7, then invert twice won't match the original value
+    if 0 == unsafe { float_compare(f10.as_ptr(), 8, f_compute.as_ptr(), 8) } {
+        let _ = trace("  invert twice: good");
+    } else {
+        let _ = trace("  invert twice: bad");
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn finish() -> i32 {
+    test_float_from_wasm();
+    test_float_compare();
+    test_float_add_subtract();
+    test_float_multiply_divide();
+    test_float_pow();
+    test_float_root();
+    test_float_log();
+    test_float_negate();
+    test_float_invert();
+
+    1
+}
@@ -0,0 +1,27 @@
+#include <stdint.h>
+
+int32_t
+get_ledger_sqn();
+// int32_t trace(uint8_t const*, int32_t, uint8_t const*, int32_t, int32_t);
+// int32_t trace_num(uint8_t const*, int32_t, int64_t);
+
+// uint8_t buf[1024];
+
+// char const test_res[] = "sqn: ";
+// char const test_name[] = "TEST get_ledger_sqn";
+
+int
+finish()
+{
+    // trace((uint8_t const *)test_name, sizeof(test_name) - 1, 0, 0, 0);
+
+    // memset(buf, 0, sizeof(buf));
+    // for(int i = 0; i < sizeof(buf); ++i) buf[i] = 0;
+
+    int x = get_ledger_sqn();
+    // if (x >= 0)
+    //     x = *((int32_t*)buf);
+    // trace_num((uint8_t const *)test`_res, sizeof(test_res) - 1, x);
+
+    return x < 0 ? x : (x >= 5 ? x : 0);
+}
@@ -0,0 +1,145 @@
+#include <stdint.h>
+#include <stdlib.h>
+
+static uint64_t const K512[] = {
+    0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f,
+    0xe9b5dba58189dbbc, 0x3956c25bf348b538, 0x59f111f1b605d019,
+    0x923f82a4af194f9b, 0xab1c5ed5da6d8118, 0xd807aa98a3030242,
+    0x12835b0145706fbe, 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2,
+    0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235,
+    0xc19bf174cf692694, 0xe49b69c19ef14ad2, 0xefbe4786384f25e3,
+    0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65, 0x2de92c6f592b0275,
+    0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5,
+    0x983e5152ee66dfab, 0xa831c66d2db43210, 0xb00327c898fb213f,
+    0xbf597fc7beef0ee4, 0xc6e00bf33da88fc2, 0xd5a79147930aa725,
+    0x06ca6351e003826f, 0x142929670a0e6e70, 0x27b70a8546d22ffc,
+    0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed, 0x53380d139d95b3df,
+    0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6,
+    0x92722c851482353b, 0xa2bfe8a14cf10364, 0xa81a664bbc423001,
+    0xc24b8b70d0f89791, 0xc76c51a30654be30, 0xd192e819d6ef5218,
+    0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8,
+    0x19a4c116b8d2d0c8, 0x1e376c085141ab53, 0x2748774cdf8eeb99,
+    0x34b0bcb5e19b48a8, 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb,
+    0x5b9cca4f7763e373, 0x682e6ff3d6b2b8a3, 0x748f82ee5defb2fc,
+    0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec,
+    0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915,
+    0xc67178f2e372532b, 0xca273eceea26619c, 0xd186b8c721c0c207,
+    0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178, 0x06f067aa72176fba,
+    0x0a637dc5a2c898a6, 0x113f9804bef90dae, 0x1b710b35131c471b,
+    0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc,
+    0x431d67c49c100d4c, 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a,
+    0x5fcb6fab3ad6faec, 0x6c44198c4a475817};
+
+#define ROTATE(x, y) (((x) >> (y)) | ((x) << (64 - (y))))
+#define Sigma0(x) (ROTATE((x), 28) ^ ROTATE((x), 34) ^ ROTATE((x), 39))
+#define Sigma1(x) (ROTATE((x), 14) ^ ROTATE((x), 18) ^ ROTATE((x), 41))
+#define sigma0(x) (ROTATE((x), 1) ^ ROTATE((x), 8) ^ ((x) >> 7))
+#define sigma1(x) (ROTATE((x), 19) ^ ROTATE((x), 61) ^ ((x) >> 6))
+
+#define Ch(x, y, z) (((x) & (y)) ^ ((~(x)) & (z)))
+#define Maj(x, y, z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
+
+static inline uint64_t
+B2U64(uint8_t val, uint8_t sh)
+{
+    return ((uint64_t)val) << sh;
+}
+
+void*
+allocate(int sz)
+{
+    return malloc(sz);
+}
+void
+deallocate(void* p)
+{
+    free(p);
+}
+
+uint8_t e_data[32 * 1024];
+
+uint8_t*
+sha512_process(uint8_t const* data, int32_t length)
+{
+    static uint64_t state[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+
+    uint64_t a, b, c, d, e, f, g, h, s0, s1, T1, T2;
+    uint64_t X[16];
+
+    uint64_t blocks = length / 128;
+    while (blocks--)
+    {
+        a = state[0];
+        b = state[1];
+        c = state[2];
+        d = state[3];
+        e = state[4];
+        f = state[5];
+        g = state[6];
+        h = state[7];
+
+        unsigned i;
+        for (i = 0; i < 16; i++)
+        {
+            X[i] = B2U64(data[0], 56) | B2U64(data[1], 48) |
+                B2U64(data[2], 40) | B2U64(data[3], 32) | B2U64(data[4], 24) |
+                B2U64(data[5], 16) | B2U64(data[6], 8) | B2U64(data[7], 0);
+            data += 8;
+
+            T1 = h;
+            T1 += Sigma1(e);
+            T1 += Ch(e, f, g);
+            T1 += K512[i];
+            T1 += X[i];
+
+            T2 = Sigma0(a);
+            T2 += Maj(a, b, c);
+
+            h = g;
+            g = f;
+            f = e;
+            e = d + T1;
+            d = c;
+            c = b;
+            b = a;
+            a = T1 + T2;
+        }
+
+        for (i = 16; i < 80; i++)
+        {
+            s0 = X[(i + 1) & 0x0f];
+            s0 = sigma0(s0);
+            s1 = X[(i + 14) & 0x0f];
+            s1 = sigma1(s1);
+
+            T1 = X[i & 0xf] += s0 + s1 + X[(i + 9) & 0xf];
+            T1 += h + Sigma1(e) + Ch(e, f, g) + K512[i];
+            T2 = Sigma0(a) + Maj(a, b, c);
+
+            h = g;
+            g = f;
+            f = e;
+            e = d + T1;
+            d = c;
+            c = b;
+            b = a;
+            a = T1 + T2;
+        }
+
+        state[0] += a;
+        state[1] += b;
+        state[2] += c;
+        state[3] += d;
+        state[4] += e;
+        state[5] += f;
+        state[6] += g;
+        state[7] += h;
+    }
+
+    return (uint8_t*)(state);
+}
+
+// int main ()
+//{
+//	return 0;
+// }
@@ -0,0 +1,13 @@
+#include <stdint.h>
+
+int32_t
+update_data(uint8_t const*, int32_t);
+
+int
+finish()
+{
+    uint8_t buf[] = "Data";
+    update_data(buf, sizeof(buf) - 1);
+
+    return -256;
+}
@@ -0,0 +1,29 @@
+(module
+  ;; Define a Mutable Global Variable to act as our counter.
+  ;; We initialize it to 1,000,000.
+  (global $counter (mut i32) (i32.const 1000000))
+
+  (func $finish (result i32)
+    ;; 1. Check if counter == 0 (Base Case)
+    global.get $counter
+    i32.eqz
+    if
+      ;; If counter is 0, we are done. Return 1.
+      i32.const 1
+      return
+    end
+
+    ;; 2. Decrement the Global Counter
+    global.get $counter
+    i32.const 1
+    i32.sub
+    global.set $counter
+
+    ;; 3. Recursive Step: Call SELF
+    ;; This puts an i32 (1) on the stack when it returns.
+    call $finish
+  )
+
+  ;; Export the only function we have
+  (export "finish" (func $finish))
+)
@@ -85,6 +85,76 @@ auto const condition = JTxFieldWrapper<blobField>(sfCondition);

 auto const fulfillment = JTxFieldWrapper<blobField>(sfFulfillment);

+struct finish_function
+{
+private:
+    std::string value_;
+
+public:
+    explicit finish_function(std::string func) : value_(func)
+    {
+    }
+
+    explicit finish_function(Slice const& func) : value_(strHex(func))
+    {
+    }
+
+    template <size_t N>
+    explicit finish_function(std::array<std::uint8_t, N> const& f)
+        : finish_function(makeSlice(f))
+    {
+    }
+
+    void
+    operator()(Env&, JTx& jt) const
+    {
+        jt.jv[sfFinishFunction.jsonName] = value_;
+    }
+};
+
+struct data
+{
+private:
+    std::string value_;
+
+public:
+    explicit data(std::string func) : value_(func)
+    {
+    }
+
+    explicit data(Slice const& func) : value_(strHex(func))
+    {
+    }
+
+    template <size_t N>
+    explicit data(std::array<std::uint8_t, N> const& f) : data(makeSlice(f))
+    {
+    }
+
+    void
+    operator()(Env&, JTx& jt) const
+    {
+        jt.jv[sfData.jsonName] = value_;
+    }
+};
+
+struct comp_allowance
+{
+private:
+    std::uint32_t value_;
+
+public:
+    explicit comp_allowance(std::uint32_t const& value) : value_(value)
+    {
+    }
+
+    void
+    operator()(Env&, JTx& jt) const
+    {
+        jt.jv[sfComputationAllowance.jsonName] = value_;
+    }
+};
+
 }  // namespace escrow

 }  // namespace jtx
@@ -14,9 +14,14 @@ setupConfigForUnitTests(Config& cfg)
    using namespace jtx;
    // Default fees to old values, so tests don't have to worry about changes in
    // Config.h
+    // NOTE: For new `FEES` fields, you need to wait for the first flag ledger
+    // to close for the values to be activated.
    cfg.FEES.reference_fee = UNIT_TEST_REFERENCE_FEE;
    cfg.FEES.account_reserve = XRP(200).value().xrp().drops();
    cfg.FEES.owner_reserve = XRP(50).value().xrp().drops();
+    cfg.FEES.extension_compute_limit = 1'000'000;
+    cfg.FEES.extension_size_limit = 100'000;
+    cfg.FEES.gas_price = 1'000'000;  // 1 drop = 1,000,000 micro-drops

    // The Beta API (currently v2) is always available to tests
    cfg.BETA_RPC_API = true;
@@ -515,6 +515,22 @@ public:
                if (jv.isMember(jss::reserve_inc) != isFlagLedger)
                    return false;

+                if (env.closed()->rules().enabled(featureSmartEscrow))
+                {
+                    if (jv.isMember(jss::extension_compute) != isFlagLedger)
+                        return false;
+
+                    if (jv.isMember(jss::extension_size) != isFlagLedger)
+                        return false;
+                }
+                else
+                {
+                    if (jv.isMember(jss::extension_compute))
+                        return false;
+
+                    if (jv.isMember(jss::extension_size))
+                        return false;
+                }
                return true;
            };

@@ -1579,7 +1595,8 @@ public:
        testTransactions_APIv1();
        testTransactions_APIv2();
        testManifests();
-        testValidations(all - xrpFees);
+        testValidations(all - featureXRPFees - featureSmartEscrow);
+        testValidations(all - featureSmartEscrow);
        testValidations(all);
        testSubErrors(true);
        testSubErrors(false);
@@ -202,6 +202,15 @@ Ledger::Ledger(
                sle->at(sfReserveIncrement) = *f;
            sle->at(sfReferenceFeeUnits) = Config::FEE_UNITS_DEPRECATED;
        }
+        if (std::find(
+                amendments.begin(), amendments.end(), featureSmartEscrow) !=
+            amendments.end())
+        {
+            sle->at(sfExtensionComputeLimit) =
+                config.FEES.extension_compute_limit;
+            sle->at(sfExtensionSizeLimit) = config.FEES.extension_size_limit;
+            sle->at(sfGasPrice) = config.FEES.gas_price;
+        }
        rawInsert(sle);
    }

@@ -595,6 +604,7 @@ Ledger::setup()
        {
            bool oldFees = false;
            bool newFees = false;
+            bool extensionFees = false;
            {
                auto const baseFee = sle->at(~sfBaseFee);
                auto const reserveBase = sle->at(~sfReserveBase);
@@ -612,6 +622,7 @@ Ledger::setup()
                auto const reserveBaseXRP = sle->at(~sfReserveBaseDrops);
                auto const reserveIncrementXRP =
                    sle->at(~sfReserveIncrementDrops);
+
                auto assign = [&ret](
                                  XRPAmount& dest,
                                  std::optional<STAmount> const& src) {
@@ -628,12 +639,35 @@ Ledger::setup()
                assign(fees_.increment, reserveIncrementXRP);
                newFees = baseFeeXRP || reserveBaseXRP || reserveIncrementXRP;
            }
+            {
+                auto const extensionComputeLimit =
+                    sle->at(~sfExtensionComputeLimit);
+                auto const extensionSizeLimit = sle->at(~sfExtensionSizeLimit);
+                auto const gasPrice = sle->at(~sfGasPrice);
+
+                auto assign = [](std::uint32_t& dest,
+                                 std::optional<std::uint32_t> const& src) {
+                    if (src)
+                    {
+                        dest = src.value();
+                    }
+                };
+                assign(fees_.extensionComputeLimit, extensionComputeLimit);
+                assign(fees_.extensionSizeLimit, extensionSizeLimit);
+                assign(fees_.gasPrice, gasPrice);
+                extensionFees =
+                    extensionComputeLimit || extensionSizeLimit || gasPrice;
+            }
            if (oldFees && newFees)
                // Should be all of one or the other, but not both
                ret = false;
            if (!rules_.enabled(featureXRPFees) && newFees)
                // Can't populate the new fees before the amendment is enabled
                ret = false;
+            if (!rules_.enabled(featureSmartEscrow) && extensionFees)
+                // Can't populate the extension fees before the amendment is
+                // enabled
+                ret = false;
        }
    }
    catch (SHAMapMissingNode const&)
@@ -652,15 +686,23 @@ Ledger::setup()
 void
 Ledger::defaultFees(Config const& config)
 {
-    XRPL_ASSERT(
-        fees_.base == 0 && fees_.reserve == 0 && fees_.increment == 0,
-        "ripple::Ledger::defaultFees : zero fees");
+    assert(
+        fees_.base == 0 && fees_.reserve == 0 && fees_.increment == 0 &&
+        fees_.extensionComputeLimit == 0 && fees_.extensionSizeLimit == 0 &&
+        fees_.gasPrice == 0);
    if (fees_.base == 0)
        fees_.base = config.FEES.reference_fee;
    if (fees_.reserve == 0)
        fees_.reserve = config.FEES.account_reserve;
    if (fees_.increment == 0)
        fees_.increment = config.FEES.owner_reserve;
+
+    if (fees_.extensionComputeLimit == 0)
+        fees_.extensionComputeLimit = config.FEES.extension_compute_limit;
+    if (fees_.extensionSizeLimit == 0)
+        fees_.extensionSizeLimit = config.FEES.extension_size_limit;
+    if (fees_.gasPrice == 0)
+        fees_.gasPrice = config.FEES.gas_price;
 }

 std::shared_ptr<SLE>
@@ -9,10 +9,10 @@ namespace ripple {

 namespace detail {

+template <typename value_type>
 class VotableValue
 {
 private:
-    using value_type = XRPAmount;
    value_type const current_;  // The current setting
    value_type const target_;   // The setting we want
    std::map<value_type, int> voteMap_;
@@ -47,8 +47,9 @@ public:
    getVotes() const;
 };

-auto
-VotableValue::getVotes() const -> std::pair<value_type, bool>
+template <typename value_type>
+std::pair<value_type, bool>
+VotableValue<value_type>::getVotes() const
 {
    value_type ourVote = current_;
    int weight = 0;
@@ -171,6 +172,33 @@ FeeVoteImpl::doValidation(
            "reserve increment",
            sfReserveIncrement);
    }
+    if (rules.enabled(featureSmartEscrow))
+    {
+        auto vote = [&v, this](
+                        auto const current,
+                        std::uint32_t target,
+                        char const* name,
+                        auto const& sfield) {
+            if (current != target)
+            {
+                JLOG(journal_.info())
+                    << "Voting for " << name << " of " << target;
+
+                v[sfield] = target;
+            }
+        };
+        vote(
+            lastFees.extensionComputeLimit,
+            target_.extension_compute_limit,
+            "extension compute limit",
+            sfExtensionComputeLimit);
+        vote(
+            lastFees.extensionSizeLimit,
+            target_.extension_size_limit,
+            "extension size limit",
+            sfExtensionSizeLimit);
+        vote(lastFees.gasPrice, target_.gas_price, "gas price", sfGasPrice);
+    }
 }

 void
@@ -193,11 +221,22 @@ FeeVoteImpl::doVoting(
    detail::VotableValue incReserveVote(
        lastClosedLedger->fees().increment, target_.owner_reserve);

+    detail::VotableValue extensionComputeVote(
+        lastClosedLedger->fees().extensionComputeLimit,
+        target_.extension_compute_limit);
+
+    detail::VotableValue extensionSizeVote(
+        lastClosedLedger->fees().extensionSizeLimit,
+        target_.extension_size_limit);
+
+    detail::VotableValue gasPriceVote(
+        lastClosedLedger->fees().gasPrice, target_.gas_price);
+
    auto const& rules = lastClosedLedger->rules();
    if (rules.enabled(featureXRPFees))
    {
        auto doVote = [](std::shared_ptr<STValidation> const& val,
-                         detail::VotableValue& value,
+                         detail::VotableValue<XRPAmount>& value,
                         SF_AMOUNT const& xrpField) {
            if (auto const field = ~val->at(~xrpField);
                field && field->native())
@@ -226,7 +265,7 @@ FeeVoteImpl::doVoting(
    else
    {
        auto doVote = [](std::shared_ptr<STValidation> const& val,
-                         detail::VotableValue& value,
+                         detail::VotableValue<XRPAmount>& value,
                         auto const& valueField) {
            if (auto const field = val->at(~valueField))
            {
@@ -257,6 +296,30 @@ FeeVoteImpl::doVoting(
            doVote(val, incReserveVote, sfReserveIncrement);
        }
    }
+    if (rules.enabled(featureSmartEscrow))
+    {
+        auto doVote = [](std::shared_ptr<STValidation> const& val,
+                         detail::VotableValue<std::uint32_t>& value,
+                         SF_UINT32 const& extensionField) {
+            if (auto const field = ~val->at(~extensionField); field)
+            {
+                value.addVote(field.value());
+            }
+            else
+            {
+                value.noVote();
+            }
+        };
+
+        for (auto const& val : set)
+        {
+            if (!val->isTrusted())
+                continue;
+            doVote(val, extensionComputeVote, sfExtensionComputeLimit);
+            doVote(val, extensionSizeVote, sfExtensionSizeLimit);
+            doVote(val, gasPriceVote, sfGasPrice);
+        }
+    }

    // choose our positions
    // TODO: Use structured binding once LLVM 16 is the minimum supported
@@ -265,11 +328,15 @@ FeeVoteImpl::doVoting(
    auto const baseFee = baseFeeVote.getVotes();
    auto const baseReserve = baseReserveVote.getVotes();
    auto const incReserve = incReserveVote.getVotes();
+    auto const extensionCompute = extensionComputeVote.getVotes();
+    auto const extensionSize = extensionSizeVote.getVotes();
+    auto const gasPrice = gasPriceVote.getVotes();

    auto const seq = lastClosedLedger->info().seq + 1;

    // add transactions to our position
-    if (baseFee.second || baseReserve.second || incReserve.second)
+    if (baseFee.second || baseReserve.second || incReserve.second ||
+        extensionCompute.second || extensionSize.second || gasPrice.second)
    {
        JLOG(journal_.warn())
            << "We are voting for a fee change: " << baseFee.first << "/"
@@ -297,6 +364,12 @@ FeeVoteImpl::doVoting(
                        incReserveVote.current());
                obj[sfReferenceFeeUnits] = Config::FEE_UNITS_DEPRECATED;
            }
+            if (rules.enabled(featureSmartEscrow))
+            {
+                obj[sfExtensionComputeLimit] = extensionCompute.first;
+                obj[sfExtensionSizeLimit] = extensionSize.first;
+                obj[sfGasPrice] = gasPrice.first;
+            }
        });

        uint256 txID = feeTx.getTransactionID();
@@ -2465,6 +2465,18 @@ NetworkOPsImp::pubValidation(std::shared_ptr<STValidation> const& val)
            reserveIncXRP && reserveIncXRP->native())
            jvObj[jss::reserve_inc] = reserveIncXRP->xrp().jsonClipped();

+        if (auto const extensionComputeLimit =
+                ~val->at(~sfExtensionComputeLimit);
+            extensionComputeLimit)
+            jvObj[jss::extension_compute] = *extensionComputeLimit;
+
+        if (auto const extensionSizeLimit = ~val->at(~sfExtensionSizeLimit);
+            extensionSizeLimit)
+            jvObj[jss::extension_size] = *extensionSizeLimit;
+
+        if (auto const gasPrice = ~val->at(~sfGasPrice); gasPrice)
+            jvObj[jss::gas_price] = *gasPrice;
+
        // NOTE Use MultiApiJson to publish two slightly different JSON objects
        // for consumers supporting different API versions
        MultiApiJson multiObj{jvObj};
@@ -2914,11 +2926,20 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters)
        l[jss::seq] = Json::UInt(lpClosed->info().seq);
        l[jss::hash] = to_string(lpClosed->info().hash);

+        bool const smartEscrowEnabled =
+            lpClosed->rules().enabled(featureSmartEscrow);
        if (!human)
        {
            l[jss::base_fee] = baseFee.jsonClipped();
            l[jss::reserve_base] = lpClosed->fees().reserve.jsonClipped();
            l[jss::reserve_inc] = lpClosed->fees().increment.jsonClipped();
+            if (smartEscrowEnabled)
+            {
+                l[jss::extension_compute] =
+                    lpClosed->fees().extensionComputeLimit;
+                l[jss::extension_size] = lpClosed->fees().extensionSizeLimit;
+                l[jss::gas_price] = lpClosed->fees().gasPrice;
+            }
            l[jss::close_time] = Json::Value::UInt(
                lpClosed->info().closeTime.time_since_epoch().count());
        }
@@ -2927,6 +2948,13 @@ NetworkOPsImp::getServerInfo(bool human, bool admin, bool counters)
            l[jss::base_fee_xrp] = baseFee.decimalXRP();
            l[jss::reserve_base_xrp] = lpClosed->fees().reserve.decimalXRP();
            l[jss::reserve_inc_xrp] = lpClosed->fees().increment.decimalXRP();
+            if (smartEscrowEnabled)
+            {
+                l[jss::extension_compute] =
+                    lpClosed->fees().extensionComputeLimit;
+                l[jss::extension_size] = lpClosed->fees().extensionSizeLimit;
+                l[jss::gas_price] = lpClosed->fees().gasPrice;
+            }

            if (auto const closeOffset = app_.timeKeeper().closeOffset();
                std::abs(closeOffset.count()) >= 60)
@@ -3120,6 +3148,14 @@ NetworkOPsImp::pubLedger(std::shared_ptr<ReadView const> const& lpAccepted)
            jvObj[jss::reserve_base] = lpAccepted->fees().reserve.jsonClipped();
            jvObj[jss::reserve_inc] =
                lpAccepted->fees().increment.jsonClipped();
+            if (lpAccepted->rules().enabled(featureSmartEscrow))
+            {
+                jvObj[jss::extension_compute] =
+                    lpAccepted->fees().extensionComputeLimit;
+                jvObj[jss::extension_size] =
+                    lpAccepted->fees().extensionSizeLimit;
+                jvObj[jss::gas_price] = lpAccepted->fees().gasPrice;
+            }

            jvObj[jss::txn_count] = Json::UInt(alpAccepted->size());

@@ -3490,8 +3526,8 @@ NetworkOPsImp::pubAccountTransaction(
    }

    JLOG(m_journal.trace())
-        << "pubAccountTransaction: "
-        << "proposed=" << iProposed << ", accepted=" << iAccepted;
+        << "pubAccountTransaction: " << "proposed=" << iProposed
+        << ", accepted=" << iAccepted;

    if (!notify.empty() || !accountHistoryNotify.empty())
    {
@@ -4192,12 +4228,19 @@ NetworkOPsImp::subLedger(InfoSub::ref isrListener, Json::Value& jvResult)
        jvResult[jss::ledger_hash] = to_string(lpClosed->info().hash);
        jvResult[jss::ledger_time] = Json::Value::UInt(
            lpClosed->info().closeTime.time_since_epoch().count());
+        jvResult[jss::network_id] = app_.config().NETWORK_ID;
        if (!lpClosed->rules().enabled(featureXRPFees))
            jvResult[jss::fee_ref] = Config::FEE_UNITS_DEPRECATED;
        jvResult[jss::fee_base] = lpClosed->fees().base.jsonClipped();
        jvResult[jss::reserve_base] = lpClosed->fees().reserve.jsonClipped();
        jvResult[jss::reserve_inc] = lpClosed->fees().increment.jsonClipped();
-        jvResult[jss::network_id] = app_.config().NETWORK_ID;
+        if (lpClosed->rules().enabled(featureSmartEscrow))
+        {
+            jvResult[jss::extension_compute] =
+                lpClosed->fees().extensionComputeLimit;
+            jvResult[jss::extension_size] = lpClosed->fees().extensionSizeLimit;
+            jvResult[jss::gas_price] = lpClosed->fees().gasPrice;
+        }
    }

    if ((mMode >= OperatingMode::SYNCING) && !isNeedNetworkLedger())
@@ -40,6 +40,11 @@ ApplyContext::discard()
 std::optional<TxMeta>
 ApplyContext::apply(TER ter)
 {
+    if (wasmReturnCode_.has_value())
+    {
+        view_->setWasmReturnCode(*wasmReturnCode_);
+    }
+    view_->setGasUsed(gasUsed_);
    return view_->apply(
        base_, tx, ter, parentBatchId_, flags_ & tapDRY_RUN, journal);
 }
@@ -87,6 +87,20 @@ public:
        view_->deliver(amount);
    }

+    /** Sets the gas used in the metadata */
+    void
+    setGasUsed(std::uint32_t const gasUsed)
+    {
+        gasUsed_ = gasUsed;
+    }
+
+    /** Sets the gas used in the metadata */
+    void
+    setWasmReturnCode(std::int32_t const wasmReturnCode)
+    {
+        wasmReturnCode_ = wasmReturnCode;
+    }
+
    /** Discard changes and start fresh. */
    void
    discard();
@@ -138,6 +152,8 @@ private:

    // The ID of the batch transaction we are executing under, if seated.
    std::optional<uint256 const> parentBatchId_;
+    std::optional<std::uint32_t> gasUsed_;
+    std::optional<std::int32_t> wasmReturnCode_;
 };

 }  // namespace ripple
@@ -109,6 +109,20 @@ Change::preclaim(PreclaimContext const& ctx)
                    ctx.tx.isFieldPresent(sfReserveIncrementDrops))
                    return temDISABLED;
            }
+            if (ctx.view.rules().enabled(featureSmartEscrow))
+            {
+                if (!ctx.tx.isFieldPresent(sfExtensionComputeLimit) ||
+                    !ctx.tx.isFieldPresent(sfExtensionSizeLimit) ||
+                    !ctx.tx.isFieldPresent(sfGasPrice))
+                    return temMALFORMED;
+            }
+            else
+            {
+                if (ctx.tx.isFieldPresent(sfExtensionComputeLimit) ||
+                    ctx.tx.isFieldPresent(sfExtensionSizeLimit) ||
+                    ctx.tx.isFieldPresent(sfGasPrice))
+                    return temDISABLED;
+            }
            return tesSUCCESS;
        case ttAMENDMENT:
        case ttUNL_MODIFY:
@@ -273,6 +287,12 @@ Change::applyFee()
        set(feeObject, ctx_.tx, sfReserveBase);
        set(feeObject, ctx_.tx, sfReserveIncrement);
    }
+    if (view().rules().enabled(featureSmartEscrow))
+    {
+        set(feeObject, ctx_.tx, sfExtensionComputeLimit);
+        set(feeObject, ctx_.tx, sfExtensionSizeLimit);
+        set(feeObject, ctx_.tx, sfGasPrice);
+    }

    view().update(feeObject);

@@ -1,6 +1,8 @@
 #include <xrpld/app/misc/HashRouter.h>
 #include <xrpld/app/tx/detail/Escrow.h>
 #include <xrpld/app/tx/detail/MPTokenAuthorize.h>
+#include <xrpld/app/wasm/HostFuncImpl.h>
+#include <xrpld/app/wasm/WasmVM.h>
 #include <xrpld/conditions/Condition.h>
 #include <xrpld/conditions/Fulfillment.h>

@@ -99,6 +101,30 @@ escrowCreatePreflightHelper<MPTIssue>(PreflightContext const& ctx)
    return tesSUCCESS;
 }

+XRPAmount
+EscrowCreate::calculateBaseFee(ReadView const& view, STTx const& tx)
+{
+    XRPAmount txnFees{Transactor::calculateBaseFee(view, tx)};
+    if (tx.isFieldPresent(sfFinishFunction))
+    {
+        // 10 base fees for the transaction (1 is in
+        // `Transactor::calculateBaseFee`), plus 5 drops per byte
+        txnFees += 9 * view.fees().base + 5 * tx[sfFinishFunction].size();
+    }
+    return txnFees;
+}
+
+bool
+EscrowCreate::checkExtraFeatures(PreflightContext const& ctx)
+{
+    if ((ctx.tx.isFieldPresent(sfFinishFunction) ||
+         ctx.tx.isFieldPresent(sfData)) &&
+        !ctx.rules.enabled(featureSmartEscrow))
+        return false;
+
+    return true;
+}
+
 NotTEC
 EscrowCreate::preflight(PreflightContext const& ctx)
 {
@@ -132,12 +158,21 @@ EscrowCreate::preflight(PreflightContext const& ctx)
        ctx.tx[sfCancelAfter] <= ctx.tx[sfFinishAfter])
        return temBAD_EXPIRATION;

+    if (ctx.tx.isFieldPresent(sfFinishFunction) &&
+        !ctx.tx.isFieldPresent(sfCancelAfter))
+        return temBAD_EXPIRATION;
+
    // In the absence of a FinishAfter, the escrow can be finished
    // immediately, which can be confusing. When creating an escrow,
    // we want to ensure that either a FinishAfter time is explicitly
    // specified or a completion condition is attached.
-    if (!ctx.tx[~sfFinishAfter] && !ctx.tx[~sfCondition])
+    if (!ctx.tx[~sfFinishAfter] && !ctx.tx[~sfCondition] &&
+        !ctx.tx[~sfFinishFunction])
+    {
+        JLOG(ctx.j.debug()) << "Must have at least one of FinishAfter, "
+                               "Condition, or FinishFunction.";
        return temMALFORMED;
+    }

    if (auto const cb = ctx.tx[~sfCondition])
    {
@@ -155,6 +190,42 @@ EscrowCreate::preflight(PreflightContext const& ctx)
        }
    }

+    if (ctx.tx.isFieldPresent(sfData))
+    {
+        if (!ctx.tx.isFieldPresent(sfFinishFunction))
+        {
+            JLOG(ctx.j.debug())
+                << "EscrowCreate with Data requires FinishFunction";
+            return temMALFORMED;
+        }
+        auto const data = ctx.tx.getFieldVL(sfData);
+        if (data.size() > maxWasmDataLength)
+        {
+            JLOG(ctx.j.debug()) << "EscrowCreate.Data bad size " << data.size();
+            return temMALFORMED;
+        }
+    }
+
+    if (ctx.tx.isFieldPresent(sfFinishFunction))
+    {
+        auto const code = ctx.tx.getFieldVL(sfFinishFunction);
+        if (code.size() == 0 ||
+            code.size() > ctx.app.config().FEES.extension_size_limit)
+        {
+            JLOG(ctx.j.debug())
+                << "EscrowCreate.FinishFunction bad size " << code.size();
+            return temMALFORMED;
+        }
+
+        HostFunctions mock(ctx.j);
+        auto const re = preflightEscrowWasm(code, mock, ESCROW_FUNCTION_NAME);
+        if (!isTesSuccess(re))
+        {
+            JLOG(ctx.j.debug()) << "EscrowCreate.FinishFunction bad WASM";
+            return re;
+        }
+    }
+
    return tesSUCCESS;
 }

@@ -413,6 +484,17 @@ escrowLockApplyHelper<MPTIssue>(
    return tesSUCCESS;
 }

+template <class T>
+static uint32_t
+calculateAdditionalReserve(T const& finishFunction)
+{
+    if (!finishFunction)
+        return 1;
+    // First 500 bytes included in the normal reserve
+    // Each additional 500 bytes requires an additional reserve
+    return 1 + (finishFunction->size() / 500);
+}
+
 TER
 EscrowCreate::doApply()
 {
@@ -430,9 +512,11 @@ EscrowCreate::doApply()

    // Check reserve and funds availability
    STAmount const amount{ctx_.tx[sfAmount]};
+    auto const reserveToAdd =
+        calculateAdditionalReserve(ctx_.tx[~sfFinishFunction]);

    auto const reserve =
-        ctx_.view().fees().accountReserve((*sle)[sfOwnerCount] + 1);
+        ctx_.view().fees().accountReserve((*sle)[sfOwnerCount] + reserveToAdd);

    if (mSourceBalance < reserve)
        return tecINSUFFICIENT_RESERVE;
@@ -467,6 +551,8 @@ EscrowCreate::doApply()
    (*slep)[~sfCancelAfter] = ctx_.tx[~sfCancelAfter];
    (*slep)[~sfFinishAfter] = ctx_.tx[~sfFinishAfter];
    (*slep)[~sfDestinationTag] = ctx_.tx[~sfDestinationTag];
+    (*slep)[~sfFinishFunction] = ctx_.tx[~sfFinishFunction];
+    (*slep)[~sfData] = ctx_.tx[~sfData];

    if (ctx_.view().rules().enabled(fixIncludeKeyletFields))
    {
@@ -536,7 +622,7 @@ EscrowCreate::doApply()
    }

    // increment owner count
-    adjustOwnerCount(ctx_.view(), sle, 1, ctx_.journal);
+    adjustOwnerCount(ctx_.view(), sle, reserveToAdd, ctx_.journal);
    ctx_.view().update(sle);
    return tesSUCCESS;
 }
@@ -564,8 +650,16 @@ checkCondition(Slice f, Slice c)
 bool
 EscrowFinish::checkExtraFeatures(PreflightContext const& ctx)
 {
-    return !ctx.tx.isFieldPresent(sfCredentialIDs) ||
-        ctx.rules.enabled(featureCredentials);
+    if (ctx.tx.isFieldPresent(sfCredentialIDs) &&
+        !ctx.rules.enabled(featureCredentials))
+        return false;
+
+    if (ctx.tx.isFieldPresent(sfComputationAllowance) &&
+        !ctx.rules.enabled(featureSmartEscrow))
+    {
+        return false;
+    }
+    return true;
 }

 NotTEC
@@ -577,7 +671,10 @@ EscrowFinish::preflight(PreflightContext const& ctx)
    // If you specify a condition, then you must also specify
    // a fulfillment.
    if (static_cast<bool>(cb) != static_cast<bool>(fb))
+    {
+        JLOG(ctx.j.debug()) << "Condition != Fulfillment";
        return temMALFORMED;
+    }

    return tesSUCCESS;
 }
@@ -607,6 +704,20 @@ EscrowFinish::preflightSigValidated(PreflightContext const& ctx)
        }
    }

+    if (auto const allowance = ctx.tx[~sfComputationAllowance]; allowance)
+    {
+        if (*allowance == 0)
+        {
+            return temBAD_LIMIT;
+        }
+        if (*allowance > ctx.app.config().FEES.extension_compute_limit)
+        {
+            JLOG(ctx.j.debug())
+                << "ComputationAllowance too large: " << *allowance;
+            return temBAD_LIMIT;
+        }
+    }
+
    if (auto const err = credentials::checkFields(ctx.tx, ctx.j);
        !isTesSuccess(err))
        return err;
@@ -623,7 +734,14 @@ EscrowFinish::calculateBaseFee(ReadView const& view, STTx const& tx)
    {
        extraFee += view.fees().base * (32 + (fb->size() / 16));
    }
-
+    if (auto const allowance = tx[~sfComputationAllowance]; allowance)
+    {
+        // The extra fee is the allowance in drops, rounded up to the nearest
+        // whole drop.
+        // Integer math rounds down by default, so we add 1 to round up.
+        extraFee +=
+            ((*allowance) * view.fees().gasPrice) / MICRO_DROPS_PER_DROP + 1;
+    }
    return Transactor::calculateBaseFee(view, tx) + extraFee;
 }

@@ -703,25 +821,52 @@ EscrowFinish::preclaim(PreclaimContext const& ctx)
            return err;
    }

-    if (ctx.view.rules().enabled(featureTokenEscrow))
+    if (ctx.view.rules().enabled(featureTokenEscrow) ||
+        ctx.view.rules().enabled(featureSmartEscrow))
    {
+        // this check is done in doApply before this amendment is enabled
        auto const k = keylet::escrow(ctx.tx[sfOwner], ctx.tx[sfOfferSequence]);
        auto const slep = ctx.view.read(k);
        if (!slep)
            return tecNO_TARGET;

-        AccountID const dest = (*slep)[sfDestination];
-        STAmount const amount = (*slep)[sfAmount];
-
-        if (!isXRP(amount))
+        if (ctx.view.rules().enabled(featureSmartEscrow))
        {
-            if (auto const ret = std::visit(
-                    [&]<typename T>(T const&) {
-                        return escrowFinishPreclaimHelper<T>(ctx, dest, amount);
-                    },
-                    amount.asset().value());
-                !isTesSuccess(ret))
-                return ret;
+            if (slep->isFieldPresent(sfFinishFunction))
+            {
+                if (!ctx.tx.isFieldPresent(sfComputationAllowance))
+                {
+                    JLOG(ctx.j.debug())
+                        << "FinishFunction requires ComputationAllowance";
+                    return tefWASM_FIELD_NOT_INCLUDED;
+                }
+            }
+            else
+            {
+                if (ctx.tx.isFieldPresent(sfComputationAllowance))
+                {
+                    JLOG(ctx.j.debug()) << "FinishFunction not present, "
+                                           "ComputationAllowance present";
+                    return tefNO_WASM;
+                }
+            }
+        }
+        if (ctx.view.rules().enabled(featureTokenEscrow))
+        {
+            AccountID const dest = (*slep)[sfDestination];
+            STAmount const amount = (*slep)[sfAmount];
+
+            if (!isXRP(amount))
+            {
+                if (auto const ret = std::visit(
+                        [&]<typename T>(T const&) {
+                            return escrowFinishPreclaimHelper<T>(
+                                ctx, dest, amount);
+                        },
+                        amount.asset().value());
+                    !isTesSuccess(ret))
+                    return ret;
+            }
        }
    }
    return tesSUCCESS;
@@ -956,7 +1101,8 @@ EscrowFinish::doApply()
    auto const slep = ctx_.view().peek(k);
    if (!slep)
    {
-        if (ctx_.view().rules().enabled(featureTokenEscrow))
+        if (ctx_.view().rules().enabled(featureTokenEscrow) ||
+            ctx_.view().rules().enabled(featureSmartEscrow))
            return tecINTERNAL;  // LCOV_EXCL_LINE

        return tecNO_TARGET;
@@ -974,6 +1120,20 @@ EscrowFinish::doApply()
    if ((*slep)[~sfCancelAfter] && after(now, (*slep)[sfCancelAfter]))
        return tecNO_PERMISSION;

+    AccountID const destID = (*slep)[sfDestination];
+    auto const sled = ctx_.view().peek(keylet::account(destID));
+    if (ctx_.view().rules().enabled(featureSmartEscrow))
+    {
+        // NOTE: Escrow payments cannot be used to fund accounts.
+        if (!sled)
+            return tecNO_DST;
+
+        if (auto err = verifyDepositPreauth(
+                ctx_.tx, ctx_.view(), account_, destID, sled, ctx_.journal);
+            !isTesSuccess(err))
+            return err;
+    }
+
    // Check cryptocondition fulfillment
    {
        auto const id = ctx_.tx.getTransactionID();
@@ -1023,16 +1183,69 @@ EscrowFinish::doApply()
            return tecCRYPTOCONDITION_ERROR;
    }

-    // NOTE: Escrow payments cannot be used to fund accounts.
-    AccountID const destID = (*slep)[sfDestination];
-    auto const sled = ctx_.view().peek(keylet::account(destID));
-    if (!sled)
-        return tecNO_DST;
+    if (!ctx_.view().rules().enabled(featureSmartEscrow))
+    {
+        // NOTE: Escrow payments cannot be used to fund accounts.
+        if (!sled)
+            return tecNO_DST;

-    if (auto err = verifyDepositPreauth(
-            ctx_.tx, ctx_.view(), account_, destID, sled, ctx_.journal);
-        !isTesSuccess(err))
-        return err;
+        if (auto err = verifyDepositPreauth(
+                ctx_.tx, ctx_.view(), account_, destID, sled, ctx_.journal);
+            !isTesSuccess(err))
+            return err;
+    }
+
+    // Execute custom release function
+    if ((*slep)[~sfFinishFunction])
+    {
+        JLOG(j_.trace())
+            << "The escrow has a finish function, running WASM code...";
+        // WASM execution
+        auto const wasmStr = slep->getFieldVL(sfFinishFunction);
+        std::vector<uint8_t> wasm(wasmStr.begin(), wasmStr.end());
+
+        WasmHostFunctionsImpl ledgerDataProvider(ctx_, k);
+
+        if (!ctx_.tx.isFieldPresent(sfComputationAllowance))
+        {
+            // already checked above, this check is just in case
+            return tecINTERNAL;
+        }
+        std::uint32_t allowance = ctx_.tx[sfComputationAllowance];
+        auto re = runEscrowWasm(
+            wasm, ledgerDataProvider, ESCROW_FUNCTION_NAME, {}, allowance);
+        JLOG(j_.trace()) << "Escrow WASM ran";
+
+        if (auto const& data = ledgerDataProvider.getData(); data.has_value())
+        {
+            slep->setFieldVL(sfData, makeSlice(*data));
+            ctx_.view().update(slep);
+        }
+
+        if (re.has_value())
+        {
+            auto reValue = re.value().result;
+            auto reCost = re.value().cost;
+            JLOG(j_.debug()) << "WASM Success: " + std::to_string(reValue)
+                             << ", cost: " << reCost;
+
+            ctx_.setWasmReturnCode(reValue);
+
+            if (reCost < 0 || reCost > std::numeric_limits<uint32_t>::max())
+                return tecINTERNAL;  // LCOV_EXCL_LINE
+            ctx_.setGasUsed(static_cast<uint32_t>(reCost));
+
+            if (reValue <= 0)
+            {
+                return tecWASM_REJECTED;
+            }
+        }
+        else
+        {
+            JLOG(j_.debug()) << "WASM Failure: " + transHuman(re.error());
+            return re.error();
+        }
+    }

    AccountID const account = (*slep)[sfAccount];

@@ -1110,9 +1323,12 @@ EscrowFinish::doApply()

    ctx_.view().update(sled);

+    auto const reserveToSubtract =
+        calculateAdditionalReserve((*slep)[~sfFinishFunction]);
+
    // Adjust source owner count
    auto const sle = ctx_.view().peek(keylet::account(account));
-    adjustOwnerCount(ctx_.view(), sle, -1, ctx_.journal);
+    adjustOwnerCount(ctx_.view(), sle, -1 * reserveToSubtract, ctx_.journal);
    ctx_.view().update(sle);

    // Remove escrow from ledger
@@ -1312,7 +1528,9 @@ EscrowCancel::doApply()
        }
    }

-    adjustOwnerCount(ctx_.view(), sle, -1, ctx_.journal);
+    auto const reserveToSubtract =
+        calculateAdditionalReserve((*slep)[~sfFinishFunction]);
+    adjustOwnerCount(ctx_.view(), sle, -1 * reserveToSubtract, ctx_.journal);
    ctx_.view().update(sle);

    // Remove escrow from ledger
@@ -14,9 +14,15 @@ public:
    {
    }

+    static bool
+    checkExtraFeatures(PreflightContext const& ctx);
+
    static TxConsequences
    makeTxConsequences(PreflightContext const& ctx);

+    static XRPAmount
+    calculateBaseFee(ReadView const& view, STTx const& tx);
+
    static NotTEC
    preflight(PreflightContext const& ctx);

@@ -1032,6 +1032,22 @@ removeExpiredCredentials(
    }
 }

+static void
+modifyWasmDataFields(
+    ApplyView& view,
+    std::vector<std::pair<uint256, Blob>> const& wasmObjects,
+    beast::Journal viewJ)
+{
+    for (auto const& [index, data] : wasmObjects)
+    {
+        if (auto const sle = view.peek(keylet::escrow(index)))
+        {
+            sle->setFieldVL(sfData, data);
+            view.update(sle);
+        }
+    }
+}
+
 static void
 removeDeletedTrustLines(
    ApplyView& view,
@@ -1190,6 +1206,7 @@ Transactor::operator()()
    else if (
        (result == tecOVERSIZE) || (result == tecKILLED) ||
        (result == tecINCOMPLETE) || (result == tecEXPIRED) ||
+        (result == tecWASM_REJECTED) ||
        (isTecClaimHardFail(result, view().flags())))
    {
        JLOG(j_.trace()) << "reapplying because of " << transToken(result);
@@ -1202,13 +1219,16 @@ Transactor::operator()()
        std::vector<uint256> removedTrustLines;
        std::vector<uint256> expiredNFTokenOffers;
        std::vector<uint256> expiredCredentials;
+        std::vector<std::pair<uint256, Blob>> modifiedWasmObjects;

        bool const doOffers =
            ((result == tecOVERSIZE) || (result == tecKILLED));
        bool const doLines = (result == tecINCOMPLETE);
        bool const doNFTokenOffers = (result == tecEXPIRED);
        bool const doCredentials = (result == tecEXPIRED);
-        if (doOffers || doLines || doNFTokenOffers || doCredentials)
+        bool const doWasmData = (result == tecWASM_REJECTED);
+        if (doOffers || doLines || doNFTokenOffers || doCredentials ||
+            doWasmData)
        {
            ctx_.visit([doOffers,
                        &removedOffers,
@@ -1217,7 +1237,9 @@ Transactor::operator()()
                        doNFTokenOffers,
                        &expiredNFTokenOffers,
                        doCredentials,
-                        &expiredCredentials](
+                        &expiredCredentials,
+                        doWasmData,
+                        &modifiedWasmObjects](
                           uint256 const& index,
                           bool isDelete,
                           std::shared_ptr<SLE const> const& before,
@@ -1252,6 +1274,13 @@ Transactor::operator()()
                        (before->getType() == ltCREDENTIAL))
                        expiredCredentials.push_back(index);
                }
+
+                if (doWasmData && before && after &&
+                    (before->getType() == ltESCROW))
+                {
+                    modifiedWasmObjects.push_back(
+                        std::make_pair(index, after->getFieldVL(sfData)));
+                }
            });
        }

@@ -1281,6 +1310,10 @@ Transactor::operator()()
            removeExpiredCredentials(
                view(), expiredCredentials, ctx_.app.journal("View"));

+        if (result == tecWASM_REJECTED)
+            modifyWasmDataFields(
+                view(), modifiedWasmObjects, ctx_.app.journal("View"));
+
        applied = isTecClaim(result);
    }

@@ -0,0 +1,517 @@
+#pragma once
+
+#include <xrpld/app/wasm/ParamsHelper.h>
+
+#include <xrpl/basics/Expected.h>
+#include <xrpl/basics/Slice.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Asset.h>
+#include <xrpl/protocol/Keylet.h>
+#include <xrpl/protocol/TER.h>
+#include <xrpl/protocol/UintTypes.h>
+
+namespace ripple {
+
+enum class HostFunctionError : int32_t {
+    INTERNAL = -1,
+    FIELD_NOT_FOUND = -2,
+    BUFFER_TOO_SMALL = -3,
+    NO_ARRAY = -4,
+    NOT_LEAF_FIELD = -5,
+    LOCATOR_MALFORMED = -6,
+    SLOT_OUT_RANGE = -7,
+    SLOTS_FULL = -8,
+    EMPTY_SLOT = -9,
+    LEDGER_OBJ_NOT_FOUND = -10,
+    DECODING = -11,
+    DATA_FIELD_TOO_LARGE = -12,
+    POINTER_OUT_OF_BOUNDS = -13,
+    NO_MEM_EXPORTED = -14,
+    INVALID_PARAMS = -15,
+    INVALID_ACCOUNT = -16,
+    INVALID_FIELD = -17,
+    INDEX_OUT_OF_BOUNDS = -18,
+    FLOAT_INPUT_MALFORMED = -19,
+    FLOAT_COMPUTATION_ERROR = -20,
+    NO_RUNTIME = -21,
+    OUT_OF_GAS = -22,
+};
+
+inline int32_t
+HfErrorToInt(HostFunctionError e)
+{
+    return static_cast<int32_t>(e);
+}
+
+std::string
+floatToString(Slice const& data);
+
+Expected<Bytes, HostFunctionError>
+floatFromIntImpl(int64_t x, int32_t mode);
+
+Expected<Bytes, HostFunctionError>
+floatFromUintImpl(uint64_t x, int32_t mode);
+
+Expected<Bytes, HostFunctionError>
+floatSetImpl(int64_t mantissa, int32_t exponent, int32_t mode);
+
+Expected<int32_t, HostFunctionError>
+floatCompareImpl(Slice const& x, Slice const& y);
+
+Expected<Bytes, HostFunctionError>
+floatAddImpl(Slice const& x, Slice const& y, int32_t mode);
+
+Expected<Bytes, HostFunctionError>
+floatSubtractImpl(Slice const& x, Slice const& y, int32_t mode);
+
+Expected<Bytes, HostFunctionError>
+floatMultiplyImpl(Slice const& x, Slice const& y, int32_t mode);
+
+Expected<Bytes, HostFunctionError>
+floatDivideImpl(Slice const& x, Slice const& y, int32_t mode);
+
+Expected<Bytes, HostFunctionError>
+floatRootImpl(Slice const& x, int32_t n, int32_t mode);
+
+Expected<Bytes, HostFunctionError>
+floatPowerImpl(Slice const& x, int32_t n, int32_t mode);
+
+Expected<Bytes, HostFunctionError>
+floatLogImpl(Slice const& x, int32_t mode);
+
+struct HostFunctions
+{
+    beast::Journal j_;
+
+    HostFunctions(
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()})
+        : j_(j)
+    {
+    }
+
+    // LCOV_EXCL_START
+    virtual void
+    setRT(void const*)
+    {
+    }
+
+    virtual void const*
+    getRT() const
+    {
+        return nullptr;
+    }
+
+    std::int64_t
+    getGas()
+    {
+        return -1;
+    }
+
+    void
+    setGas(std::int64_t)
+    {
+        return;
+    }
+
+    beast::Journal
+    getJournal()
+    {
+        return j_;
+    }
+
+    virtual Expected<std::int32_t, HostFunctionError>
+    getLedgerSqn()
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<std::int32_t, HostFunctionError>
+    getParentLedgerTime()
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Hash, HostFunctionError>
+    getParentLedgerHash()
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    getBaseFee()
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    isAmendmentEnabled(uint256 const& amendmentId)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    isAmendmentEnabled(std::string_view const& amendmentName)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    cacheLedgerObj(uint256 const& objId, int32_t cacheIdx)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    getTxField(SField const& fname)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    getCurrentLedgerObjField(SField const& fname)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    getLedgerObjField(int32_t cacheIdx, SField const& fname)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    getTxNestedField(Slice const& locator)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    getCurrentLedgerObjNestedField(Slice const& locator)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    getLedgerObjNestedField(int32_t cacheIdx, Slice const& locator)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    getTxArrayLen(SField const& fname)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    getCurrentLedgerObjArrayLen(SField const& fname)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    getLedgerObjArrayLen(int32_t cacheIdx, SField const& fname)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    getTxNestedArrayLen(Slice const& locator)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    getCurrentLedgerObjNestedArrayLen(Slice const& locator)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    getLedgerObjNestedArrayLen(int32_t cacheIdx, Slice const& locator)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    updateData(Slice const& data)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    checkSignature(
+        Slice const& message,
+        Slice const& signature,
+        Slice const& pubkey)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Hash, HostFunctionError>
+    computeSha512HalfHash(Slice const& data)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    accountKeylet(AccountID const& account)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    ammKeylet(Asset const& issue1, Asset const& issue2)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    checkKeylet(AccountID const& account, std::uint32_t seq)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    credentialKeylet(
+        AccountID const& subject,
+        AccountID const& issuer,
+        Slice const& credentialType)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    didKeylet(AccountID const& account)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    delegateKeylet(AccountID const& account, AccountID const& authorize)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    depositPreauthKeylet(AccountID const& account, AccountID const& authorize)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    escrowKeylet(AccountID const& account, std::uint32_t seq)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    lineKeylet(
+        AccountID const& account1,
+        AccountID const& account2,
+        Currency const& currency)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    mptIssuanceKeylet(AccountID const& issuer, std::uint32_t seq)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    mptokenKeylet(MPTID const& mptid, AccountID const& holder)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    nftOfferKeylet(AccountID const& account, std::uint32_t seq)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    offerKeylet(AccountID const& account, std::uint32_t seq)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    oracleKeylet(AccountID const& account, std::uint32_t docId)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    paychanKeylet(
+        AccountID const& account,
+        AccountID const& destination,
+        std::uint32_t seq)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    permissionedDomainKeylet(AccountID const& account, std::uint32_t seq)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    signersKeylet(AccountID const& account)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    ticketKeylet(AccountID const& account, std::uint32_t seq)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    vaultKeylet(AccountID const& account, std::uint32_t seq)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    getNFT(AccountID const& account, uint256 const& nftId)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    getNFTIssuer(uint256 const& nftId)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<std::uint32_t, HostFunctionError>
+    getNFTTaxon(uint256 const& nftId)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    getNFTFlags(uint256 const& nftId)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    getNFTTransferFee(uint256 const& nftId)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<std::uint32_t, HostFunctionError>
+    getNFTSerial(uint256 const& nftId)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    trace(std::string_view const& msg, Slice const& data, bool asHex)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    traceNum(std::string_view const& msg, int64_t data)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    traceAccount(std::string_view const& msg, AccountID const& account)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    traceFloat(std::string_view const& msg, Slice const& data)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    traceAmount(std::string_view const& msg, STAmount const& amount)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    floatFromInt(int64_t x, int32_t mode)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    floatFromUint(uint64_t x, int32_t mode)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    floatSet(int64_t mantissa, int32_t exponent, int32_t mode)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    floatCompare(Slice const& x, Slice const& y)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    floatAdd(Slice const& x, Slice const& y, int32_t mode)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    floatSubtract(Slice const& x, Slice const& y, int32_t mode)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    floatMultiply(Slice const& x, Slice const& y, int32_t mode)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    floatDivide(Slice const& x, Slice const& y, int32_t mode)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    floatRoot(Slice const& x, int32_t n, int32_t mode)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    floatPower(Slice const& x, int32_t n, int32_t mode)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    floatLog(Slice const& x, int32_t mode)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual ~HostFunctions() = default;
+    // LCOV_EXCL_STOP
+};
+
+}  // namespace ripple
@@ -0,0 +1,274 @@
+#pragma once
+
+#include <xrpld/app/tx/detail/ApplyContext.h>
+#include <xrpld/app/wasm/HostFunc.h>
+
+namespace ripple {
+class WasmHostFunctionsImpl : public HostFunctions
+{
+    ApplyContext& ctx;
+    Keylet leKey;
+    std::shared_ptr<SLE const> currentLedgerObj = nullptr;
+    bool isLedgerObjCached = false;
+
+    static int constexpr MAX_CACHE = 256;
+    std::array<std::shared_ptr<SLE const>, MAX_CACHE> cache;
+    std::optional<Bytes> data_;
+
+    void const* rt_ = nullptr;
+
+    Expected<std::shared_ptr<SLE const>, HostFunctionError>
+    getCurrentLedgerObj()
+    {
+        if (!isLedgerObjCached)
+        {
+            isLedgerObjCached = true;
+            currentLedgerObj = ctx.view().read(leKey);
+        }
+        if (currentLedgerObj)
+            return currentLedgerObj;
+        return Unexpected(HostFunctionError::LEDGER_OBJ_NOT_FOUND);
+    }
+
+    Expected<int32_t, HostFunctionError>
+    normalizeCacheIndex(int32_t cacheIdx)
+    {
+        --cacheIdx;
+        if (cacheIdx < 0 || cacheIdx >= MAX_CACHE)
+            return Unexpected(HostFunctionError::SLOT_OUT_RANGE);
+        if (!cache[cacheIdx])
+            return Unexpected(HostFunctionError::EMPTY_SLOT);
+        return cacheIdx;
+    }
+
+public:
+    WasmHostFunctionsImpl(ApplyContext& ct, Keylet const& leKey)
+        : HostFunctions(ct.journal), ctx(ct), leKey(leKey)
+    {
+    }
+
+    virtual void
+    setRT(void const* rt) override
+    {
+        rt_ = rt;
+    }
+
+    virtual void const*
+    getRT() const override
+    {
+        return rt_;
+    }
+
+    std::optional<Bytes> const&
+    getData() const
+    {
+        return data_;
+    }
+
+    Expected<std::int32_t, HostFunctionError>
+    getLedgerSqn() override;
+
+    Expected<std::int32_t, HostFunctionError>
+    getParentLedgerTime() override;
+
+    Expected<Hash, HostFunctionError>
+    getParentLedgerHash() override;
+
+    Expected<int32_t, HostFunctionError>
+    getBaseFee() override;
+
+    Expected<int32_t, HostFunctionError>
+    isAmendmentEnabled(uint256 const& amendmentId) override;
+
+    Expected<int32_t, HostFunctionError>
+    isAmendmentEnabled(std::string_view const& amendmentName) override;
+
+    Expected<int32_t, HostFunctionError>
+    cacheLedgerObj(uint256 const& objId, int32_t cacheIdx) override;
+
+    Expected<Bytes, HostFunctionError>
+    getTxField(SField const& fname) override;
+
+    Expected<Bytes, HostFunctionError>
+    getCurrentLedgerObjField(SField const& fname) override;
+
+    Expected<Bytes, HostFunctionError>
+    getLedgerObjField(int32_t cacheIdx, SField const& fname) override;
+
+    Expected<Bytes, HostFunctionError>
+    getTxNestedField(Slice const& locator) override;
+
+    Expected<Bytes, HostFunctionError>
+    getCurrentLedgerObjNestedField(Slice const& locator) override;
+
+    Expected<Bytes, HostFunctionError>
+    getLedgerObjNestedField(int32_t cacheIdx, Slice const& locator) override;
+
+    Expected<int32_t, HostFunctionError>
+    getTxArrayLen(SField const& fname) override;
+
+    Expected<int32_t, HostFunctionError>
+    getCurrentLedgerObjArrayLen(SField const& fname) override;
+
+    Expected<int32_t, HostFunctionError>
+    getLedgerObjArrayLen(int32_t cacheIdx, SField const& fname) override;
+
+    Expected<int32_t, HostFunctionError>
+    getTxNestedArrayLen(Slice const& locator) override;
+
+    Expected<int32_t, HostFunctionError>
+    getCurrentLedgerObjNestedArrayLen(Slice const& locator) override;
+
+    Expected<int32_t, HostFunctionError>
+    getLedgerObjNestedArrayLen(int32_t cacheIdx, Slice const& locator) override;
+
+    Expected<int32_t, HostFunctionError>
+    updateData(Slice const& data) override;
+
+    Expected<int32_t, HostFunctionError>
+    checkSignature(
+        Slice const& message,
+        Slice const& signature,
+        Slice const& pubkey) override;
+
+    Expected<Hash, HostFunctionError>
+    computeSha512HalfHash(Slice const& data) override;
+
+    Expected<Bytes, HostFunctionError>
+    accountKeylet(AccountID const& account) override;
+
+    Expected<Bytes, HostFunctionError>
+    ammKeylet(Asset const& issue1, Asset const& issue2) override;
+
+    Expected<Bytes, HostFunctionError>
+    checkKeylet(AccountID const& account, std::uint32_t seq) override;
+
+    Expected<Bytes, HostFunctionError>
+    credentialKeylet(
+        AccountID const& subject,
+        AccountID const& issuer,
+        Slice const& credentialType) override;
+
+    Expected<Bytes, HostFunctionError>
+    didKeylet(AccountID const& account) override;
+
+    Expected<Bytes, HostFunctionError>
+    delegateKeylet(AccountID const& account, AccountID const& authorize)
+        override;
+
+    Expected<Bytes, HostFunctionError>
+    depositPreauthKeylet(AccountID const& account, AccountID const& authorize)
+        override;
+
+    Expected<Bytes, HostFunctionError>
+    escrowKeylet(AccountID const& account, std::uint32_t seq) override;
+
+    Expected<Bytes, HostFunctionError>
+    lineKeylet(
+        AccountID const& account1,
+        AccountID const& account2,
+        Currency const& currency) override;
+
+    Expected<Bytes, HostFunctionError>
+    mptIssuanceKeylet(AccountID const& issuer, std::uint32_t seq) override;
+
+    Expected<Bytes, HostFunctionError>
+    mptokenKeylet(MPTID const& mptid, AccountID const& holder) override;
+
+    Expected<Bytes, HostFunctionError>
+    nftOfferKeylet(AccountID const& account, std::uint32_t seq) override;
+
+    Expected<Bytes, HostFunctionError>
+    offerKeylet(AccountID const& account, std::uint32_t seq) override;
+
+    Expected<Bytes, HostFunctionError>
+    oracleKeylet(AccountID const& account, std::uint32_t docId) override;
+
+    Expected<Bytes, HostFunctionError>
+    paychanKeylet(
+        AccountID const& account,
+        AccountID const& destination,
+        std::uint32_t seq) override;
+
+    Expected<Bytes, HostFunctionError>
+    permissionedDomainKeylet(AccountID const& account, std::uint32_t seq)
+        override;
+
+    Expected<Bytes, HostFunctionError>
+    signersKeylet(AccountID const& account) override;
+
+    Expected<Bytes, HostFunctionError>
+    ticketKeylet(AccountID const& account, std::uint32_t seq) override;
+
+    Expected<Bytes, HostFunctionError>
+    vaultKeylet(AccountID const& account, std::uint32_t seq) override;
+
+    Expected<Bytes, HostFunctionError>
+    getNFT(AccountID const& account, uint256 const& nftId) override;
+
+    Expected<Bytes, HostFunctionError>
+    getNFTIssuer(uint256 const& nftId) override;
+
+    Expected<std::uint32_t, HostFunctionError>
+    getNFTTaxon(uint256 const& nftId) override;
+
+    Expected<int32_t, HostFunctionError>
+    getNFTFlags(uint256 const& nftId) override;
+
+    Expected<int32_t, HostFunctionError>
+    getNFTTransferFee(uint256 const& nftId) override;
+
+    Expected<std::uint32_t, HostFunctionError>
+    getNFTSerial(uint256 const& nftId) override;
+
+    Expected<int32_t, HostFunctionError>
+    trace(std::string_view const& msg, Slice const& data, bool asHex) override;
+
+    Expected<int32_t, HostFunctionError>
+    traceNum(std::string_view const& msg, int64_t data) override;
+
+    Expected<int32_t, HostFunctionError>
+    traceAccount(std::string_view const& msg, AccountID const& account)
+        override;
+
+    Expected<int32_t, HostFunctionError>
+    traceFloat(std::string_view const& msg, Slice const& data) override;
+
+    Expected<int32_t, HostFunctionError>
+    traceAmount(std::string_view const& msg, STAmount const& amount) override;
+
+    Expected<Bytes, HostFunctionError>
+    floatFromInt(int64_t x, int32_t mode) override;
+
+    Expected<Bytes, HostFunctionError>
+    floatFromUint(uint64_t x, int32_t mode) override;
+
+    Expected<Bytes, HostFunctionError>
+    floatSet(int64_t mantissa, int32_t exponent, int32_t mode) override;
+
+    Expected<int32_t, HostFunctionError>
+    floatCompare(Slice const& x, Slice const& y) override;
+
+    Expected<Bytes, HostFunctionError>
+    floatAdd(Slice const& x, Slice const& y, int32_t mode) override;
+
+    Expected<Bytes, HostFunctionError>
+    floatSubtract(Slice const& x, Slice const& y, int32_t mode) override;
+
+    Expected<Bytes, HostFunctionError>
+    floatMultiply(Slice const& x, Slice const& y, int32_t mode) override;
+
+    Expected<Bytes, HostFunctionError>
+    floatDivide(Slice const& x, Slice const& y, int32_t mode) override;
+
+    Expected<Bytes, HostFunctionError>
+    floatRoot(Slice const& x, int32_t n, int32_t mode) override;
+
+    Expected<Bytes, HostFunctionError>
+    floatPower(Slice const& x, int32_t n, int32_t mode) override;
+
+    Expected<Bytes, HostFunctionError>
+    floatLog(Slice const& x, int32_t mode) override;
+};
+
+}  // namespace ripple
@@ -0,0 +1,534 @@
+#pragma once
+
+#include <xrpld/app/wasm/WasmiVM.h>
+
+namespace ripple {
+
+using getLedgerSqn_proto = int32_t();
+wasm_trap_t*
+getLedgerSqn_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using getParentLedgerTime_proto = int32_t();
+wasm_trap_t*
+getParentLedgerTime_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using getParentLedgerHash_proto = int32_t(uint8_t*, int32_t);
+wasm_trap_t*
+getParentLedgerHash_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using getBaseFee_proto = int32_t();
+wasm_trap_t*
+getBaseFee_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using isAmendmentEnabled_proto = int32_t(uint8_t const*, int32_t);
+wasm_trap_t*
+isAmendmentEnabled_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using cacheLedgerObj_proto = int32_t(uint8_t const*, int32_t, int32_t);
+wasm_trap_t*
+cacheLedgerObj_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using getTxField_proto = int32_t(int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+getTxField_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using getCurrentLedgerObjField_proto = int32_t(int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+getCurrentLedgerObjField_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using getLedgerObjField_proto = int32_t(int32_t, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+getLedgerObjField_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using getTxNestedField_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+getTxNestedField_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using getCurrentLedgerObjNestedField_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+getCurrentLedgerObjNestedField_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using getLedgerObjNestedField_proto =
+    int32_t(int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+getLedgerObjNestedField_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using getTxArrayLen_proto = int32_t(int32_t);
+wasm_trap_t*
+getTxArrayLen_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using getCurrentLedgerObjArrayLen_proto = int32_t(int32_t);
+wasm_trap_t*
+getCurrentLedgerObjArrayLen_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using getLedgerObjArrayLen_proto = int32_t(int32_t, int32_t);
+wasm_trap_t*
+getLedgerObjArrayLen_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using getTxNestedArrayLen_proto = int32_t(uint8_t const*, int32_t);
+wasm_trap_t*
+getTxNestedArrayLen_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using getCurrentLedgerObjNestedArrayLen_proto =
+    int32_t(uint8_t const*, int32_t);
+wasm_trap_t*
+getCurrentLedgerObjNestedArrayLen_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using getLedgerObjNestedArrayLen_proto =
+    int32_t(int32_t, uint8_t const*, int32_t);
+wasm_trap_t*
+getLedgerObjNestedArrayLen_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using updateData_proto = int32_t(uint8_t const*, int32_t);
+wasm_trap_t*
+updateData_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using checkSignature_proto = int32_t(
+    uint8_t const*,
+    int32_t,
+    uint8_t const*,
+    int32_t,
+    uint8_t const*,
+    int32_t);
+wasm_trap_t*
+checkSignature_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using computeSha512HalfHash_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+computeSha512HalfHash_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using accountKeylet_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+accountKeylet_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using ammKeylet_proto = int32_t(
+    uint8_t const*,
+    int32_t,
+    uint8_t const*,
+    int32_t,
+    uint8_t*,
+    int32_t);
+wasm_trap_t*
+ammKeylet_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using checkKeylet_proto =
+    int32_t(uint8_t const*, int32_t, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+checkKeylet_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using credentialKeylet_proto = int32_t(
+    uint8_t const*,
+    int32_t,
+    uint8_t const*,
+    int32_t,
+    uint8_t const*,
+    int32_t,
+    uint8_t*,
+    int32_t);
+wasm_trap_t*
+credentialKeylet_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using delegateKeylet_proto = int32_t(
+    uint8_t const*,
+    int32_t,
+    uint8_t const*,
+    int32_t,
+    uint8_t*,
+    int32_t);
+wasm_trap_t*
+delegateKeylet_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using depositPreauthKeylet_proto = int32_t(
+    uint8_t const*,
+    int32_t,
+    uint8_t const*,
+    int32_t,
+    uint8_t*,
+    int32_t);
+wasm_trap_t*
+depositPreauthKeylet_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using didKeylet_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+didKeylet_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using escrowKeylet_proto =
+    int32_t(uint8_t const*, int32_t, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+escrowKeylet_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using lineKeylet_proto = int32_t(
+    uint8_t const*,
+    int32_t,
+    uint8_t const*,
+    int32_t,
+    uint8_t const*,
+    int32_t,
+    uint8_t*,
+    int32_t);
+wasm_trap_t*
+lineKeylet_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using mptIssuanceKeylet_proto =
+    int32_t(uint8_t const*, int32_t, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+mptIssuanceKeylet_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using mptokenKeylet_proto = int32_t(
+    uint8_t const*,
+    int32_t,
+    uint8_t const*,
+    int32_t,
+    uint8_t*,
+    int32_t);
+wasm_trap_t*
+mptokenKeylet_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using nftOfferKeylet_proto =
+    int32_t(uint8_t const*, int32_t, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+nftOfferKeylet_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using offerKeylet_proto =
+    int32_t(uint8_t const*, int32_t, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+offerKeylet_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using oracleKeylet_proto =
+    int32_t(uint8_t const*, int32_t, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+oracleKeylet_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using paychanKeylet_proto = int32_t(
+    uint8_t const*,
+    int32_t,
+    uint8_t const*,
+    int32_t,
+    int32_t,
+    uint8_t*,
+    int32_t);
+wasm_trap_t*
+paychanKeylet_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using permissionedDomainKeylet_proto =
+    int32_t(uint8_t const*, int32_t, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+permissionedDomainKeylet_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using signersKeylet_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+signersKeylet_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using ticketKeylet_proto =
+    int32_t(uint8_t const*, int32_t, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+ticketKeylet_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using vaultKeylet_proto =
+    int32_t(uint8_t const*, int32_t, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+vaultKeylet_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using getNFT_proto = int32_t(
+    uint8_t const*,
+    int32_t,
+    uint8_t const*,
+    int32_t,
+    uint8_t*,
+    int32_t);
+wasm_trap_t*
+getNFT_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using getNFTIssuer_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+getNFTIssuer_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using getNFTTaxon_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+getNFTTaxon_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using getNFTFlags_proto = int32_t(uint8_t const*, int32_t);
+wasm_trap_t*
+getNFTFlags_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using getNFTTransferFee_proto = int32_t(uint8_t const*, int32_t);
+wasm_trap_t*
+getNFTTransferFee_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using getNFTSerial_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+getNFTSerial_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using trace_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, int32_t);
+wasm_trap_t*
+trace_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using traceNum_proto = int32_t(uint8_t const*, int32_t, int64_t);
+wasm_trap_t*
+traceNum_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using traceAccount_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t);
+wasm_trap_t*
+traceAccount_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using traceFloat_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t);
+wasm_trap_t*
+traceFloat_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using traceAmount_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t);
+wasm_trap_t*
+traceAmount_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using floatFromInt_proto = int32_t(int64_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t*
+floatFromInt_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using floatFromUint_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t*
+floatFromUint_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using floatSet_proto = int32_t(int32_t, int64_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t*
+floatSet_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using floatCompare_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t);
+wasm_trap_t*
+floatCompare_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using floatAdd_proto = int32_t(
+    uint8_t const*,
+    int32_t,
+    uint8_t const*,
+    int32_t,
+    uint8_t*,
+    int32_t,
+    int32_t);
+wasm_trap_t*
+floatAdd_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using floatSubtract_proto = int32_t(
+    uint8_t const*,
+    int32_t,
+    uint8_t const*,
+    int32_t,
+    uint8_t*,
+    int32_t,
+    int32_t);
+wasm_trap_t*
+floatSubtract_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using floatMultiply_proto = int32_t(
+    uint8_t const*,
+    int32_t,
+    uint8_t const*,
+    int32_t,
+    uint8_t*,
+    int32_t,
+    int32_t);
+wasm_trap_t*
+floatMultiply_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using floatDivide_proto = int32_t(
+    uint8_t const*,
+    int32_t,
+    uint8_t const*,
+    int32_t,
+    uint8_t*,
+    int32_t,
+    int32_t);
+wasm_trap_t*
+floatDivide_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using floatRoot_proto =
+    int32_t(uint8_t const*, int32_t, int32_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t*
+floatRoot_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using floatPower_proto =
+    int32_t(uint8_t const*, int32_t, int32_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t*
+floatPower_wrap(
+    void* env,
+    wasm_val_vec_t const* params,
+    wasm_val_vec_t* results);
+
+using floatLog_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t*
+floatLog_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+}  // namespace ripple
@@ -0,0 +1,250 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+
+#include <boost/function_types/function_arity.hpp>
+#include <boost/function_types/parameter_types.hpp>
+#include <boost/function_types/result_type.hpp>
+#include <boost/mpl/vector.hpp>
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace bft = boost::function_types;
+
+namespace ripple {
+
+using Bytes = std::vector<std::uint8_t>;
+using Hash = ripple::uint256;
+
+struct wmem
+{
+    std::uint8_t* p = nullptr;
+    std::size_t s = 0;
+};
+
+template <typename T>
+struct WasmResult
+{
+    T result;
+    int64_t cost;
+};
+typedef WasmResult<int32_t> EscrowResult;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+enum WasmTypes { WT_I32, WT_I64, WT_U8V };
+
+struct WasmImportFunc
+{
+    std::string name;
+    std::optional<WasmTypes> result;
+    std::vector<WasmTypes> params;
+    // void* udata = nullptr;
+    // wasm_func_callback_with_env_t
+    void* wrap = nullptr;
+    uint32_t gas = 0;
+};
+
+typedef std::pair<void*, WasmImportFunc> WasmUserData;
+typedef std::vector<WasmUserData> ImportVec;
+
+#define WASM_IMPORT_FUNC(v, f, ...) \
+    WasmImpFunc<f##_proto>(         \
+        v, #f, reinterpret_cast<void*>(&f##_wrap), ##__VA_ARGS__)
+
+#define WASM_IMPORT_FUNC2(v, f, n, ...) \
+    WasmImpFunc<f##_proto>(             \
+        v, n, reinterpret_cast<void*>(&f##_wrap), ##__VA_ARGS__)
+
+template <int N, int C, typename mpl>
+void
+WasmImpArgs(WasmImportFunc& e)
+{
+    if constexpr (N < C)
+    {
+        using at = typename boost::mpl::at_c<mpl, N>::type;
+        if constexpr (std::is_pointer_v<at>)
+            e.params.push_back(WT_I32);
+        else if constexpr (std::is_same_v<at, std::int32_t>)
+            e.params.push_back(WT_I32);
+        else if constexpr (std::is_same_v<at, std::int64_t>)
+            e.params.push_back(WT_I64);
+        else
+            static_assert(std::is_pointer_v<at>, "Unsupported argument type");
+
+        return WasmImpArgs<N + 1, C, mpl>(e);
+    }
+    return;
+}
+
+template <typename rt>
+void
+WasmImpRet(WasmImportFunc& e)
+{
+    if constexpr (std::is_pointer_v<rt>)
+        e.result = WT_I32;
+    else if constexpr (std::is_same_v<rt, std::int32_t>)
+        e.result = WT_I32;
+    else if constexpr (std::is_same_v<rt, std::int64_t>)
+        e.result = WT_I64;
+    else if constexpr (std::is_void_v<rt>)
+        e.result.reset();
+#if (defined(__GNUC__) && (__GNUC__ >= 14)) || \
+    ((defined(__clang_major__)) && (__clang_major__ >= 18))
+    else
+        static_assert(false, "Unsupported return type");
+#endif
+}
+
+template <typename F>
+void
+WasmImpFuncHelper(WasmImportFunc& e)
+{
+    using rt = typename bft::result_type<F>::type;
+    using pt = typename bft::parameter_types<F>::type;
+    // typename boost::mpl::at_c<mpl, N>::type
+
+    WasmImpRet<rt>(e);
+    WasmImpArgs<0, bft::function_arity<F>::value, pt>(e);
+    // WasmImpWrap(e, std::forward<F>(f));
+}
+
+template <typename F>
+void
+WasmImpFunc(
+    ImportVec& v,
+    std::string_view imp_name,
+    void* f_wrap,
+    void* data = nullptr,
+    uint32_t gas = 0)
+{
+    WasmImportFunc e;
+    e.name = imp_name;
+    e.wrap = f_wrap;
+    e.gas = gas;
+    WasmImpFuncHelper<F>(e);
+    v.push_back(std::make_pair(data, std::move(e)));
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct WasmParamVec
+{
+    std::uint8_t const* d = nullptr;
+    std::int32_t sz = 0;
+};
+
+struct WasmParam
+{
+    WasmTypes type = WT_I32;
+    union
+    {
+        std::int32_t i32;
+        std::int64_t i64 = 0;
+        float f32;
+        double f64;
+        WasmParamVec u8v;
+    } of;
+};
+
+template <class... Types>
+inline void
+wasmParamsHlp(std::vector<WasmParam>& v, std::int32_t p, Types&&... args)
+{
+    v.push_back({.type = WT_I32, .of = {.i32 = p}});
+    wasmParamsHlp(v, std::forward<Types>(args)...);
+}
+
+template <class... Types>
+inline void
+wasmParamsHlp(std::vector<WasmParam>& v, std::int64_t p, Types&&... args)
+{
+    v.push_back({.type = WT_I64, .of = {.i64 = p}});
+    wasmParamsHlp(v, std::forward<Types>(args)...);
+}
+
+// We are not supporting float/double for now
+// Leaving this code here so that it is easier to add later if needed
+// template <class... Types>
+// inline void
+// wasmParamsHlp(std::vector<WasmParam>& v, float p, Types&&... args)
+// {
+//     v.push_back({.type = WT_F32, .of = {.f32 = p}});
+//     wasmParamsHlp(v, std::forward<Types>(args)...);
+// }
+
+// template <class... Types>
+// inline void
+// wasmParamsHlp(std::vector<WasmParam>& v, double p, Types&&... args)
+// {
+//     v.push_back({.type = WT_F64, .of = {.f64 = p}});
+//     wasmParamsHlp(v, std::forward<Types>(args)...);
+// }
+
+template <class... Types>
+inline void
+wasmParamsHlp(
+    std::vector<WasmParam>& v,
+    std::uint8_t const* dt,
+    std::int32_t sz,
+    Types&&... args)
+{
+    v.push_back({.type = WT_U8V, .of = {.u8v = {.d = dt, .sz = sz}}});
+    wasmParamsHlp(v, std::forward<Types>(args)...);
+}
+
+template <class... Types>
+inline void
+wasmParamsHlp(std::vector<WasmParam>& v, Bytes const& p, Types&&... args)
+{
+    wasmParamsHlp(
+        v,
+        p.data(),
+        static_cast<std::int32_t>(p.size()),
+        std::forward<Types>(args)...);
+}
+
+template <class... Types>
+inline void
+wasmParamsHlp(
+    std::vector<WasmParam>& v,
+    std::string_view const& p,
+    Types&&... args)
+{
+    wasmParamsHlp(
+        v,
+        reinterpret_cast<std::uint8_t const*>(p.data()),
+        static_cast<std::int32_t>(p.size()),
+        std::forward<Types>(args)...);
+}
+
+template <class... Types>
+inline void
+wasmParamsHlp(std::vector<WasmParam>& v, std::string const& p, Types&&... args)
+{
+    wasmParamsHlp(
+        v,
+        reinterpret_cast<std::uint8_t const*>(p.c_str()),
+        static_cast<std::int32_t>(p.size()),
+        std::forward<Types>(args)...);
+}
+
+inline void
+wasmParamsHlp(std::vector<WasmParam>& v)
+{
+    return;
+}
+
+template <class... Types>
+inline std::vector<WasmParam>
+wasmParams(Types&&... args)
+{
+    std::vector<WasmParam> v;
+    v.reserve(sizeof...(args));
+    wasmParamsHlp(v, std::forward<Types>(args)...);
+    return v;
+}
+
+}  // namespace ripple
@@ -0,0 +1,90 @@
+#pragma once
+
+#include <xrpld/app/wasm/HostFunc.h>
+
+#include <string_view>
+
+namespace ripple {
+
+static std::string_view const W_ENV = "env";
+static std::string_view const W_HOST_LIB = "host_lib";
+static std::string_view const W_MEM = "memory";
+static std::string_view const W_STORE = "store";
+static std::string_view const W_LOAD = "load";
+static std::string_view const W_SIZE = "size";
+static std::string_view const W_ALLOC = "allocate";
+static std::string_view const W_DEALLOC = "deallocate";
+static std::string_view const W_PROC_EXIT = "proc_exit";
+
+static std::string_view const ESCROW_FUNCTION_NAME = "finish";
+
+uint32_t const MAX_PAGES = 128;  // 8MB = 64KB*128
+
+class WasmiEngine;
+
+class WasmEngine
+{
+    std::unique_ptr<WasmiEngine> const impl;
+
+    WasmEngine();
+
+    WasmEngine(WasmEngine const&) = delete;
+    WasmEngine(WasmEngine&&) = delete;
+    WasmEngine&
+    operator=(WasmEngine const&) = delete;
+    WasmEngine&
+    operator=(WasmEngine&&) = delete;
+
+public:
+    ~WasmEngine() = default;
+
+    static WasmEngine&
+    instance();
+
+    Expected<WasmResult<int32_t>, TER>
+    run(Bytes const& wasmCode,
+        std::string_view funcName = {},
+        std::vector<WasmParam> const& params = {},
+        ImportVec const& imports = {},
+        HostFunctions* hfs = nullptr,
+        int64_t gasLimit = -1,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()});
+
+    NotTEC
+    check(
+        Bytes const& wasmCode,
+        std::string_view funcName,
+        std::vector<WasmParam> const& params = {},
+        ImportVec const& imports = {},
+        HostFunctions* hfs = nullptr,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()});
+
+    // Host functions helper functionality
+    void*
+    newTrap(std::string const& txt = std::string());
+
+    beast::Journal
+    getJournal() const;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ImportVec
+createWasmImport(HostFunctions& hfs);
+
+Expected<EscrowResult, TER>
+runEscrowWasm(
+    Bytes const& wasmCode,
+    HostFunctions& hfs,
+    std::string_view funcName = ESCROW_FUNCTION_NAME,
+    std::vector<WasmParam> const& params = {},
+    int64_t gasLimit = -1);
+
+NotTEC
+preflightEscrowWasm(
+    Bytes const& wasmCode,
+    HostFunctions& hfs,
+    std::string_view funcName = ESCROW_FUNCTION_NAME,
+    std::vector<WasmParam> const& params = {});
+
+}  // namespace ripple
@@ -0,0 +1,306 @@
+#pragma once
+
+#include <xrpld/app/wasm/WasmVM.h>
+
+#include <wasm.h>
+#include <wasmi.h>
+
+namespace ripple {
+
+struct WasmiResult
+{
+    wasm_val_vec_t r;
+    bool f;  // failure flag
+
+    WasmiResult(unsigned N = 0) : r{0, nullptr}, f(false)
+    {
+        if (N)
+            wasm_val_vec_new_uninitialized(&r, N);
+    }
+
+    ~WasmiResult()
+    {
+        if (r.size)
+            wasm_val_vec_delete(&r);
+    }
+
+    WasmiResult(WasmiResult const&) = delete;
+    WasmiResult&
+    operator=(WasmiResult const&) = delete;
+
+    WasmiResult(WasmiResult&& o)
+    {
+        *this = std::move(o);
+    }
+
+    WasmiResult&
+    operator=(WasmiResult&& o)
+    {
+        r = o.r;
+        o.r = {0, nullptr};
+        f = o.f;
+        o.f = false;
+        return *this;
+    }
+    // operator wasm_val_vec_t &() {return r;}
+};
+
+using ModulePtr = std::unique_ptr<wasm_module_t, decltype(&wasm_module_delete)>;
+using InstancePtr =
+    std::unique_ptr<wasm_instance_t, decltype(&wasm_instance_delete)>;
+using EnginePtr = std::unique_ptr<wasm_engine_t, decltype(&wasm_engine_delete)>;
+using StorePtr = std::unique_ptr<wasm_store_t, decltype(&wasm_store_delete)>;
+
+using FuncInfo = std::pair<wasm_func_t const*, wasm_functype_t const*>;
+
+struct InstanceWrapper
+{
+    wasm_store_t* store_ = nullptr;
+    wasm_extern_vec_t exports_;
+    InstancePtr instance_;
+    beast::Journal j_ = beast::Journal(beast::Journal::getNullSink());
+
+private:
+    static InstancePtr
+    init(
+        wasm_store_t* s,
+        wasm_module_t* m,
+        wasm_extern_vec_t* expt,
+        wasm_extern_vec_t const& imports,
+        beast::Journal j);
+
+public:
+    InstanceWrapper();
+
+    InstanceWrapper(InstanceWrapper&& o);
+
+    InstanceWrapper&
+    operator=(InstanceWrapper&& o);
+
+    InstanceWrapper(
+        wasm_store_t* s,
+        wasm_module_t* m,
+        wasm_extern_vec_t const& imports,
+        beast::Journal j);
+
+    ~InstanceWrapper();
+
+    operator bool() const;
+
+    FuncInfo
+    getFunc(
+        std::string_view funcName,
+        wasm_exporttype_vec_t const& export_types) const;
+
+    wmem
+    getMem() const;
+
+    std::int64_t
+    getGas() const;
+
+    std::int64_t setGas(std::int64_t) const;
+};
+
+struct ModuleWrapper
+{
+    ModulePtr module_;
+    InstanceWrapper instanceWrap_;
+    wasm_exporttype_vec_t exportTypes_;
+    beast::Journal j_ = beast::Journal(beast::Journal::getNullSink());
+
+private:
+    static ModulePtr
+    init(wasm_store_t* s, Bytes const& wasmBin, beast::Journal j);
+
+public:
+    ModuleWrapper();
+    ModuleWrapper(ModuleWrapper&& o);
+    ModuleWrapper&
+    operator=(ModuleWrapper&& o);
+    ModuleWrapper(
+        wasm_store_t* s,
+        Bytes const& wasmBin,
+        bool instantiate,
+        ImportVec const& imports,
+        beast::Journal j);
+    ~ModuleWrapper();
+
+    operator bool() const;
+
+    FuncInfo
+    getFunc(std::string_view funcName) const;
+    wmem
+    getMem() const;
+
+    InstanceWrapper const&
+    getInstance(int i = 0) const;
+
+    int
+    addInstance(
+        wasm_store_t* s,
+        wasm_extern_vec_t const& imports = WASM_EMPTY_VEC);
+
+    std::int64_t
+    getGas();
+
+private:
+    static void
+    makeImpParams(wasm_valtype_vec_t& v, WasmImportFunc const& imp);
+    static void
+    makeImpReturn(wasm_valtype_vec_t& v, WasmImportFunc const& imp);
+    wasm_extern_vec_t
+    buildImports(wasm_store_t* s, ImportVec const& imports);
+};
+
+class WasmiEngine
+{
+    EnginePtr engine_;
+    StorePtr store_;
+    std::unique_ptr<ModuleWrapper> moduleWrap_;
+    beast::Journal j_ = beast::Journal(beast::Journal::getNullSink());
+
+    std::mutex m_;  // 1 instance mutex
+
+public:
+    WasmiEngine();
+    ~WasmiEngine() = default;
+
+    static EnginePtr
+    init();
+
+    Expected<WasmResult<int32_t>, TER>
+    run(Bytes const& wasmCode,
+        std::string_view funcName,
+        std::vector<WasmParam> const& params,
+        ImportVec const& imports,
+        HostFunctions* hfs,
+        int64_t gas,
+        beast::Journal j);
+
+    NotTEC
+    check(
+        Bytes const& wasmCode,
+        std::string_view funcName,
+        std::vector<WasmParam> const& params,
+        ImportVec const& imports,
+        HostFunctions* hfs,
+        beast::Journal j);
+
+    std::int64_t
+    getGas();
+
+    // Host functions helper functionality
+    wasm_trap_t*
+    newTrap(std::string const& msg);
+
+    beast::Journal
+    getJournal() const;
+
+private:
+    InstanceWrapper const&
+    getRT(int m = 0, int i = 0);
+
+    wmem
+    getMem() const;
+
+    int32_t
+    allocate(int32_t size);
+
+    Expected<WasmResult<int32_t>, TER>
+    runHlp(
+        Bytes const& wasmCode,
+        std::string_view funcName,
+        std::vector<WasmParam> const& params,
+        ImportVec const& imports,
+        HostFunctions* hfs,
+        int64_t gas);
+
+    NotTEC
+    checkHlp(
+        Bytes const& wasmCode,
+        std::string_view funcName,
+        std::vector<WasmParam> const& params,
+        ImportVec const& imports);
+
+    int
+    addModule(
+        Bytes const& wasmCode,
+        bool instantiate,
+        int64_t gas,
+        ImportVec const& imports);
+    void
+    clearModules();
+
+    // int  addInstance();
+
+    int32_t
+    runFunc(std::string_view const funcName, int32_t p);
+
+    int32_t
+    makeModule(
+        Bytes const& wasmCode,
+        wasm_extern_vec_t const& imports = WASM_EMPTY_VEC);
+
+    FuncInfo
+    getFunc(std::string_view funcName);
+
+    std::vector<wasm_val_t>
+    convertParams(std::vector<WasmParam> const& params);
+
+    static int
+    compareParamTypes(
+        wasm_valtype_vec_t const* ftp,
+        std::vector<wasm_val_t> const& p);
+
+    static void
+    add_param(std::vector<wasm_val_t>& in, int32_t p);
+    static void
+    add_param(std::vector<wasm_val_t>& in, int64_t p);
+
+    template <int NR, class... Types>
+    inline WasmiResult
+    call(std::string_view func, Types&&... args);
+
+    template <int NR, class... Types>
+    inline WasmiResult
+    call(FuncInfo const& f, Types&&... args);
+
+    template <int NR, class... Types>
+    inline WasmiResult
+    call(FuncInfo const& f, std::vector<wasm_val_t>& in);
+
+    template <int NR, class... Types>
+    inline WasmiResult
+    call(
+        FuncInfo const& f,
+        std::vector<wasm_val_t>& in,
+        std::int32_t p,
+        Types&&... args);
+
+    template <int NR, class... Types>
+    inline WasmiResult
+    call(
+        FuncInfo const& f,
+        std::vector<wasm_val_t>& in,
+        std::int64_t p,
+        Types&&... args);
+
+    template <int NR, class... Types>
+    inline WasmiResult
+    call(
+        FuncInfo const& f,
+        std::vector<wasm_val_t>& in,
+        uint8_t const* d,
+        std::size_t sz,
+        Types&&... args);
+
+    template <int NR, class... Types>
+    inline WasmiResult
+    call(
+        FuncInfo const& f,
+        std::vector<wasm_val_t>& in,
+        Bytes const& p,
+        Types&&... args);
+};
+
+}  // namespace ripple
@@ -0,0 +1,216 @@
+#ifdef _DEBUG
+// #define DEBUG_OUTPUT 1
+#endif
+
+#include <xrpld/app/wasm/HostFunc.h>
+#include <xrpld/app/wasm/HostFuncWrapper.h>
+#include <xrpld/app/wasm/WasmiVM.h>
+
+#include <xrpl/basics/Log.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+#include <memory>
+
+namespace ripple {
+
+static void
+setCommonHostFunctions(HostFunctions* hfs, ImportVec& i)
+{
+    // clang-format off
+    WASM_IMPORT_FUNC2(i, getLedgerSqn, "get_ledger_sqn", hfs,                                                   60);
+    WASM_IMPORT_FUNC2(i, getParentLedgerTime, "get_parent_ledger_time", hfs,                                    60);
+    WASM_IMPORT_FUNC2(i, getParentLedgerHash, "get_parent_ledger_hash", hfs,                                    60);
+    WASM_IMPORT_FUNC2(i, getBaseFee, "get_base_fee", hfs,                                                       60);
+    WASM_IMPORT_FUNC2(i, isAmendmentEnabled, "amendment_enabled", hfs,                                         100);
+
+    WASM_IMPORT_FUNC2(i, cacheLedgerObj, "cache_ledger_obj", hfs,                                            5'000);
+    WASM_IMPORT_FUNC2(i, getTxField, "get_tx_field", hfs,                                                       70);
+    WASM_IMPORT_FUNC2(i, getCurrentLedgerObjField, "get_current_ledger_obj_field", hfs,                         70);
+    WASM_IMPORT_FUNC2(i, getLedgerObjField, "get_ledger_obj_field", hfs,                                        70);
+    WASM_IMPORT_FUNC2(i, getTxNestedField, "get_tx_nested_field", hfs,                                         110);
+    WASM_IMPORT_FUNC2(i, getCurrentLedgerObjNestedField, "get_current_ledger_obj_nested_field", hfs,           110);
+    WASM_IMPORT_FUNC2(i, getLedgerObjNestedField, "get_ledger_obj_nested_field", hfs,                          110);
+    WASM_IMPORT_FUNC2(i, getTxArrayLen, "get_tx_array_len", hfs,                                                40);
+    WASM_IMPORT_FUNC2(i, getCurrentLedgerObjArrayLen, "get_current_ledger_obj_array_len", hfs,                  40);
+    WASM_IMPORT_FUNC2(i, getLedgerObjArrayLen, "get_ledger_obj_array_len", hfs,                                 40);
+    WASM_IMPORT_FUNC2(i, getTxNestedArrayLen, "get_tx_nested_array_len", hfs,                                   70);
+    WASM_IMPORT_FUNC2(i, getCurrentLedgerObjNestedArrayLen, "get_current_ledger_obj_nested_array_len",  hfs,    70);
+    WASM_IMPORT_FUNC2(i, getLedgerObjNestedArrayLen, "get_ledger_obj_nested_array_len", hfs,                    70);
+
+    WASM_IMPORT_FUNC2(i, checkSignature, "check_sig", hfs,                                                     300);
+    WASM_IMPORT_FUNC2(i, computeSha512HalfHash, "compute_sha512_half", hfs,                                   2000);
+
+    WASM_IMPORT_FUNC2(i, accountKeylet, "account_keylet", hfs,                                                 350);
+    WASM_IMPORT_FUNC2(i, ammKeylet, "amm_keylet", hfs,                                                         450);
+    WASM_IMPORT_FUNC2(i, checkKeylet, "check_keylet", hfs,                                                     350);
+    WASM_IMPORT_FUNC2(i, credentialKeylet, "credential_keylet", hfs,                                           350);
+    WASM_IMPORT_FUNC2(i, delegateKeylet, "delegate_keylet", hfs,                                               350);
+    WASM_IMPORT_FUNC2(i, depositPreauthKeylet, "deposit_preauth_keylet", hfs,                                  350);
+    WASM_IMPORT_FUNC2(i, didKeylet, "did_keylet", hfs,                                                         350);
+    WASM_IMPORT_FUNC2(i, escrowKeylet, "escrow_keylet", hfs,                                                   350);
+    WASM_IMPORT_FUNC2(i, lineKeylet, "line_keylet", hfs,                                                       400);
+    WASM_IMPORT_FUNC2(i, mptIssuanceKeylet, "mpt_issuance_keylet", hfs,                                        350);
+    WASM_IMPORT_FUNC2(i, mptokenKeylet, "mptoken_keylet", hfs,                                                 500);
+    WASM_IMPORT_FUNC2(i, nftOfferKeylet, "nft_offer_keylet", hfs,                                              350);
+    WASM_IMPORT_FUNC2(i, offerKeylet, "offer_keylet", hfs,                                                     350);
+    WASM_IMPORT_FUNC2(i, oracleKeylet, "oracle_keylet", hfs,                                                   350);
+    WASM_IMPORT_FUNC2(i, paychanKeylet, "paychan_keylet", hfs,                                                 350);
+    WASM_IMPORT_FUNC2(i, permissionedDomainKeylet, "permissioned_domain_keylet", hfs,                          350);
+    WASM_IMPORT_FUNC2(i, signersKeylet, "signers_keylet", hfs,                                                 350);
+    WASM_IMPORT_FUNC2(i, ticketKeylet, "ticket_keylet", hfs,                                                   350);
+    WASM_IMPORT_FUNC2(i, vaultKeylet, "vault_keylet", hfs,                                                     350);
+
+    WASM_IMPORT_FUNC2(i, getNFT, "get_nft", hfs,                                                              1000);
+    WASM_IMPORT_FUNC2(i, getNFTIssuer, "get_nft_issuer", hfs,                                                   70);
+    WASM_IMPORT_FUNC2(i, getNFTTaxon, "get_nft_taxon", hfs,                                                     60);
+    WASM_IMPORT_FUNC2(i, getNFTFlags, "get_nft_flags", hfs,                                                     60);
+    WASM_IMPORT_FUNC2(i, getNFTTransferFee, "get_nft_transfer_fee", hfs,                                        60);
+    WASM_IMPORT_FUNC2(i, getNFTSerial, "get_nft_serial", hfs,                                                   60);
+
+    WASM_IMPORT_FUNC (i, trace, hfs,                                                                           500);
+    WASM_IMPORT_FUNC2(i, traceNum, "trace_num", hfs,                                                           500);
+    WASM_IMPORT_FUNC2(i, traceAccount, "trace_account", hfs,                                                   500);
+    WASM_IMPORT_FUNC2(i, traceFloat, "trace_opaque_float", hfs,                                                500);
+    WASM_IMPORT_FUNC2(i, traceAmount, "trace_amount", hfs,                                                     500);
+
+    WASM_IMPORT_FUNC2(i, floatFromInt, "float_from_int", hfs,                                                  100);
+    WASM_IMPORT_FUNC2(i, floatFromUint, "float_from_uint", hfs,                                                130);
+    WASM_IMPORT_FUNC2(i, floatSet, "float_set", hfs,                                                           100);
+    WASM_IMPORT_FUNC2(i, floatCompare, "float_compare", hfs,                                                    80);
+    WASM_IMPORT_FUNC2(i, floatAdd, "float_add", hfs,                                                           160);
+    WASM_IMPORT_FUNC2(i, floatSubtract, "float_subtract", hfs,                                                 160);
+    WASM_IMPORT_FUNC2(i, floatMultiply, "float_multiply", hfs,                                                 300);
+    WASM_IMPORT_FUNC2(i, floatDivide, "float_divide", hfs,                                                     300);
+    WASM_IMPORT_FUNC2(i, floatRoot, "float_root", hfs,                                                       5'500);
+    WASM_IMPORT_FUNC2(i, floatPower, "float_pow", hfs,                                                       5'500);
+    WASM_IMPORT_FUNC2(i, floatLog, "float_log", hfs,                                                        12'000);
+    // clang-format on
+}
+
+ImportVec
+createWasmImport(HostFunctions& hfs)
+{
+    ImportVec i;
+
+    setCommonHostFunctions(&hfs, i);
+    WASM_IMPORT_FUNC2(i, updateData, "update_data", &hfs, 1000);
+
+    return i;
+}
+
+Expected<EscrowResult, TER>
+runEscrowWasm(
+    Bytes const& wasmCode,
+    HostFunctions& hfs,
+    std::string_view funcName,
+    std::vector<WasmParam> const& params,
+    int64_t gasLimit)
+{
+    //  create VM and set cost limit
+    auto& vm = WasmEngine::instance();
+    // vm.initMaxPages(MAX_PAGES);
+
+    auto const ret = vm.run(
+        wasmCode,
+        funcName,
+        params,
+        createWasmImport(hfs),
+        &hfs,
+        gasLimit,
+        hfs.getJournal());
+
+    // std::cout << "runEscrowWasm, mod size: " << wasmCode.size()
+    //           << ", gasLimit: " << gasLimit << ", funcName: " << funcName;
+
+    if (!ret)
+    {
+#ifdef DEBUG_OUTPUT
+        std::cout << ", error: " << ret.error() << std::endl;
+#endif
+        return Unexpected<TER>(ret.error());
+    }
+
+#ifdef DEBUG_OUTPUT
+    std::cout << ", ret: " << ret->result << ", gas spent: " << ret->cost
+              << std::endl;
+#endif
+    return EscrowResult{ret->result, ret->cost};
+}
+
+NotTEC
+preflightEscrowWasm(
+    Bytes const& wasmCode,
+    HostFunctions& hfs,
+    std::string_view funcName,
+    std::vector<WasmParam> const& params)
+{
+    //  create VM and set cost limit
+    auto& vm = WasmEngine::instance();
+    // vm.initMaxPages(MAX_PAGES);
+
+    auto const ret = vm.check(
+        wasmCode,
+        funcName,
+        params,
+        createWasmImport(hfs),
+        &hfs,
+        hfs.getJournal());
+
+    return ret;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+WasmEngine::WasmEngine() : impl(std::make_unique<WasmiEngine>())
+{
+}
+
+WasmEngine&
+WasmEngine::instance()
+{
+    static WasmEngine e;
+    return e;
+}
+
+Expected<WasmResult<int32_t>, TER>
+WasmEngine::run(
+    Bytes const& wasmCode,
+    std::string_view funcName,
+    std::vector<WasmParam> const& params,
+    ImportVec const& imports,
+    HostFunctions* hfs,
+    int64_t gasLimit,
+    beast::Journal j)
+{
+    return impl->run(wasmCode, funcName, params, imports, hfs, gasLimit, j);
+}
+
+NotTEC
+WasmEngine::check(
+    Bytes const& wasmCode,
+    std::string_view funcName,
+    std::vector<WasmParam> const& params,
+    ImportVec const& imports,
+    HostFunctions* hfs,
+    beast::Journal j)
+{
+    return impl->check(wasmCode, funcName, params, imports, hfs, j);
+}
+
+void*
+WasmEngine::newTrap(std::string const& msg)
+{
+    return impl->newTrap(msg);
+}
+
+// LCOV_EXCL_START
+beast::Journal
+WasmEngine::getJournal() const
+{
+    return impl->getJournal();
+}
+// LCOV_EXCL_STOP
+
+}  // namespace ripple
@@ -0,0 +1,987 @@
+#include <xrpld/app/wasm/WasmiVM.h>
+
+#include <xrpl/basics/Log.h>
+
+#include <memory>
+
+#ifdef _DEBUG
+// #define DEBUG_OUTPUT 1
+#endif
+// #define SHOW_CALL_TIME 1
+
+namespace ripple {
+
+namespace {
+
+void
+print_wasm_error(std::string_view msg, wasm_trap_t* trap, beast::Journal jlog)
+{
+#ifdef DEBUG_OUTPUT
+    auto& j = std::cerr;
+#else
+    auto j = jlog.warn();
+#endif
+
+    wasm_byte_vec_t error_message WASM_EMPTY_VEC;
+
+    if (trap)
+        wasm_trap_message(trap, &error_message);
+
+    if (error_message.size)
+    {
+        j << "WASMI Error: " << msg << ", "
+          << std::string_view(error_message.data, error_message.size - 1);
+    }
+    else
+        j << "WASMI Error: " << msg;
+
+    if (error_message.size)
+        wasm_byte_vec_delete(&error_message);
+
+    if (trap)
+        wasm_trap_delete(trap);
+
+#ifdef DEBUG_OUTPUT
+    j << std::endl;
+#endif
+}
+// LCOV_EXCL_STOP
+
+}  // namespace
+
+InstancePtr
+InstanceWrapper::init(
+    wasm_store_t* s,
+    wasm_module_t* m,
+    wasm_extern_vec_t* expt,
+    wasm_extern_vec_t const& imports,
+    beast::Journal j)
+{
+    wasm_trap_t* trap = nullptr;
+    InstancePtr mi = InstancePtr(
+        wasm_instance_new(s, m, &imports, &trap), &wasm_instance_delete);
+
+    if (!mi || trap)
+    {
+        print_wasm_error("can't create instance", trap, j);
+        throw std::runtime_error("can't create instance");
+    }
+    wasm_instance_exports(mi.get(), expt);
+    return mi;
+}
+
+InstanceWrapper::InstanceWrapper()
+    : exports_{0, nullptr}, instance_(nullptr, &wasm_instance_delete)
+{
+}
+
+// LCOV_EXCL_START
+InstanceWrapper::InstanceWrapper(InstanceWrapper&& o)
+    : exports_{0, nullptr}, instance_(nullptr, &wasm_instance_delete)
+{
+    *this = std::move(o);
+}
+// LCOV_EXCL_STOP
+
+InstanceWrapper::InstanceWrapper(
+    wasm_store_t* s,
+    wasm_module_t* m,
+    wasm_extern_vec_t const& imports,
+    beast::Journal j)
+    : store_(s)
+    , exports_ WASM_EMPTY_VEC
+    , instance_(init(s, m, &exports_, imports, j))
+    , j_(j)
+{
+}
+
+InstanceWrapper::~InstanceWrapper()
+{
+    if (exports_.size)
+        wasm_extern_vec_delete(&exports_);
+}
+
+InstanceWrapper&
+InstanceWrapper::operator=(InstanceWrapper&& o)
+{
+    if (this == &o)
+        return *this;  // LCOV_EXCL_LINE
+
+    store_ = o.store_;
+    o.store_ = nullptr;
+    if (exports_.size)
+        wasm_extern_vec_delete(&exports_);  // LCOV_EXCL_LINE
+    exports_ = o.exports_;
+    o.exports_ = {0, nullptr};
+
+    instance_ = std::move(o.instance_);
+
+    j_ = o.j_;
+
+    return *this;
+}
+
+InstanceWrapper::operator bool() const
+{
+    return static_cast<bool>(instance_);
+}
+
+FuncInfo
+InstanceWrapper::getFunc(
+    std::string_view funcName,
+    wasm_exporttype_vec_t const& export_types) const
+{
+    wasm_func_t* f = nullptr;
+    wasm_functype_t* ft = nullptr;
+
+    if (!instance_)
+        throw std::runtime_error("no instance");  // LCOV_EXCL_LINE
+
+    if (!export_types.size)
+        throw std::runtime_error("no export");  // LCOV_EXCL_LINE
+    if (export_types.size != exports_.size)
+        throw std::runtime_error("invalid export");  // LCOV_EXCL_LINE
+
+    for (unsigned i = 0; i < export_types.size; ++i)
+    {
+        auto const* exp_type(export_types.data[i]);
+
+        wasm_name_t const* name = wasm_exporttype_name(exp_type);
+        wasm_externtype_t const* exn_type = wasm_exporttype_type(exp_type);
+        if (wasm_externtype_kind(exn_type) == WASM_EXTERN_FUNC)
+        {
+            if (funcName == std::string_view(name->data, name->size))
+            {
+                auto* exn(exports_.data[i]);
+                if (wasm_extern_kind(exn) != WASM_EXTERN_FUNC)
+                    throw std::runtime_error(
+                        "invalid export");  // LCOV_EXCL_LINE
+
+                ft = wasm_externtype_as_functype(
+                    const_cast<wasm_externtype_t*>(exn_type));
+                f = wasm_extern_as_func(exn);
+                break;
+            }
+        }
+    }
+
+    if (!f || !ft)
+        throw std::runtime_error(
+            "can't find function <" + std::string(funcName) + ">");
+
+    return {f, ft};
+}
+
+wmem
+InstanceWrapper::getMem() const
+{
+    if (!instance_)
+        throw std::runtime_error("no instance");  // LCOV_EXCL_LINE
+
+    wasm_memory_t* mem = nullptr;
+    for (unsigned i = 0; i < exports_.size; ++i)
+    {
+        auto* e(exports_.data[i]);
+        if (wasm_extern_kind(e) == WASM_EXTERN_MEMORY)
+        {
+            mem = wasm_extern_as_memory(e);
+            break;
+        }
+    }
+
+    if (!mem)
+        throw std::runtime_error("no memory exported");  // LCOV_EXCL_LINE
+
+    return {
+        reinterpret_cast<std::uint8_t*>(wasm_memory_data(mem)),
+        wasm_memory_data_size(mem)};
+}
+
+std::int64_t
+InstanceWrapper::getGas() const
+{
+    if (!store_)
+        return -1;  // LCOV_EXCL_LINE
+    std::uint64_t gas = 0;
+    wasm_store_get_fuel(store_, &gas);
+    return static_cast<std::int64_t>(gas);
+}
+
+std::int64_t
+InstanceWrapper::setGas(std::int64_t gas) const
+{
+    if (!store_)
+        return -1;  // LCOV_EXCL_LINE
+
+    if (gas < 0)
+        gas = std::numeric_limits<decltype(gas)>::max();
+    wasmi_error_t* err =
+        wasm_store_set_fuel(store_, static_cast<std::uint64_t>(gas));
+    if (err)
+    {
+        print_wasm_error(
+            "Can't set instance gas", nullptr, j_);          // LCOV_EXCL_LINE
+        throw std::runtime_error("Can't set instance gas");  // LCOV_EXCL_LINE
+    }
+
+    return gas;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ModulePtr
+ModuleWrapper::init(wasm_store_t* s, Bytes const& wasmBin, beast::Journal j)
+{
+    wasm_byte_vec_t const code{wasmBin.size(), (char*)(wasmBin.data())};
+    ModulePtr m = ModulePtr(wasm_module_new(s, &code), &wasm_module_delete);
+    if (!m)
+        throw std::runtime_error("can't create module");
+
+    return m;
+}
+
+// LCOV_EXCL_START
+ModuleWrapper::ModuleWrapper()
+    : module_(nullptr, &wasm_module_delete), exportTypes_{0, nullptr}
+{
+}
+
+ModuleWrapper::ModuleWrapper(ModuleWrapper&& o)
+    : module_(nullptr, &wasm_module_delete), exportTypes_{0, nullptr}
+{
+    *this = std::move(o);
+}
+// LCOV_EXCL_STOP
+
+ModuleWrapper::ModuleWrapper(
+    wasm_store_t* s,
+    Bytes const& wasmBin,
+    bool instantiate,
+    ImportVec const& imports,
+    beast::Journal j)
+    : module_(init(s, wasmBin, j)), exportTypes_{0, nullptr}, j_(j)
+{
+    wasm_module_exports(module_.get(), &exportTypes_);
+    if (instantiate)
+    {
+        auto wimports = buildImports(s, imports);
+        addInstance(s, wimports);
+        wasm_extern_vec_delete(&wimports);
+    }
+}
+
+ModuleWrapper::~ModuleWrapper()
+{
+    if (exportTypes_.size)
+        wasm_exporttype_vec_delete(&exportTypes_);
+}
+
+// LCOV_EXCL_START
+ModuleWrapper&
+ModuleWrapper::operator=(ModuleWrapper&& o)
+{
+    if (this == &o)
+        return *this;
+
+    module_ = std::move(o.module_);
+    instanceWrap_ = std::move(o.instanceWrap_);
+    if (exportTypes_.size)
+        wasm_exporttype_vec_delete(&exportTypes_);
+    exportTypes_ = o.exportTypes_;
+    o.exportTypes_ = {0, nullptr};
+    j_ = o.j_;
+
+    return *this;
+}
+
+ModuleWrapper::operator bool() const
+{
+    return instanceWrap_;
+}
+
+// LCOV_EXCL_STOP
+
+void
+ModuleWrapper::makeImpParams(wasm_valtype_vec_t& v, WasmImportFunc const& imp)
+{
+    auto const paramSize = imp.params.size();
+
+    if (paramSize)
+    {
+        wasm_valtype_vec_new_uninitialized(&v, paramSize);
+    }
+    else
+        v = WASM_EMPTY_VEC;
+    for (unsigned i = 0; i < paramSize; ++i)
+    {
+        auto const vt = imp.params[i];
+        switch (vt)
+        {
+            case WT_I32:
+                v.data[i] = wasm_valtype_new_i32();
+                break;
+            case WT_I64:
+                v.data[i] = wasm_valtype_new_i64();
+                break;
+                // LCOV_EXCL_START
+            default:
+                throw std::runtime_error("invalid import type");
+                // LCOV_EXCL_STOP
+        }
+    }
+}
+
+void
+ModuleWrapper::makeImpReturn(wasm_valtype_vec_t& v, WasmImportFunc const& imp)
+{
+    if (imp.result)
+    {
+        wasm_valtype_vec_new_uninitialized(&v, 1);
+        switch (*imp.result)
+        {
+            case WT_I32:
+                v.data[0] = wasm_valtype_new_i32();
+                break;
+                // LCOV_EXCL_START
+            case WT_I64:
+                v.data[0] = wasm_valtype_new_i64();
+                break;
+            default:
+                throw std::runtime_error("invalid return type");
+                // LCOV_EXCL_STOP
+        }
+    }
+    else
+        v = WASM_EMPTY_VEC;  // LCOV_EXCL_LINE
+}
+
+wasm_extern_vec_t
+ModuleWrapper::buildImports(wasm_store_t* s, ImportVec const& imports)
+{
+    wasm_importtype_vec_t importTypes = WASM_EMPTY_VEC;
+    wasm_module_imports(module_.get(), &importTypes);
+    std::
+        unique_ptr<wasm_importtype_vec_t, decltype(&wasm_importtype_vec_delete)>
+            itDeleter(&importTypes, &wasm_importtype_vec_delete);
+
+    wasm_extern_vec_t wimports = WASM_EMPTY_VEC;
+    if (!importTypes.size)
+        return wimports;
+
+    wasm_extern_vec_new_uninitialized(&wimports, importTypes.size);
+
+    unsigned impCnt = 0;
+    for (unsigned i = 0; i < importTypes.size; ++i)
+    {
+        wasm_importtype_t const* importtype = importTypes.data[i];
+
+        // wasm_name_t const* mn = wasm_importtype_module(importtype);
+        // auto modName = std::string_view(mn->data, mn->num_elems);
+        wasm_name_t const* fn = wasm_importtype_name(importtype);
+        auto fieldName = std::string_view(fn->data, fn->size);
+
+        wasm_externkind_t const itype =
+            wasm_externtype_kind(wasm_importtype_type(importtype));
+        if ((itype) != WASM_EXTERN_FUNC)
+            throw std::runtime_error(
+                "Invalid import type " +
+                std::to_string(itype));  // LCOV_EXCL_LINE
+
+        // for multi-module support
+        // if ((W_ENV != modName) && (W_HOST_LIB != modName))
+        //     continue;
+
+        bool impSet = false;
+        for (auto const& obj : imports)
+        {
+            auto const& imp = obj.second;
+            if (imp.name != fieldName)
+                continue;
+
+            wasm_valtype_vec_t params = WASM_EMPTY_VEC,
+                               results = WASM_EMPTY_VEC;
+            makeImpReturn(results, imp);
+            makeImpParams(params, imp);
+
+            using ftype_ptr = std::
+                unique_ptr<wasm_functype_t, decltype(&wasm_functype_delete)>;
+            ftype_ptr ftype(
+                wasm_functype_new(&params, &results), &wasm_functype_delete);
+            wasm_func_t* func = wasm_func_new_with_env(
+                s,
+                ftype.get(),
+                reinterpret_cast<wasm_func_callback_with_env_t>(imp.wrap),
+                (void*)&obj,
+                nullptr);
+            if (!func)
+            {
+                // LCOV_EXCL_START
+                throw std::runtime_error(
+                    "can't create import function " + imp.name);
+                // LCOV_EXCL_STOP
+            }
+
+            wimports.data[i] = wasm_func_as_extern(func);
+            ++impCnt;
+            impSet = true;
+
+            break;
+        }
+
+        if (!impSet)
+        {
+            print_wasm_error(
+                "Import not found: " + std::string(fieldName), nullptr, j_);
+        }
+    }
+
+    if (impCnt != importTypes.size)
+    {
+        print_wasm_error(
+            std::string("Imports not finished: ") + std::to_string(impCnt) +
+                "/" + std::to_string(importTypes.size),
+            nullptr,
+            j_);
+    }
+
+    return wimports;
+}
+
+FuncInfo
+ModuleWrapper::getFunc(std::string_view funcName) const
+{
+    return instanceWrap_.getFunc(funcName, exportTypes_);
+}
+
+wmem
+ModuleWrapper::getMem() const
+{
+    return instanceWrap_.getMem();
+}
+
+InstanceWrapper const&
+ModuleWrapper::getInstance(int) const
+{
+    return instanceWrap_;
+}
+
+int
+ModuleWrapper::addInstance(wasm_store_t* s, wasm_extern_vec_t const& imports)
+{
+    instanceWrap_ = {s, module_.get(), imports, j_};
+    return 0;
+}
+
+// int
+// my_module_t::delInstance(int i)
+// {
+//     if (i >= mod_inst.size())
+//         return -1;
+//     if (!mod_inst[i])
+//         mod_inst[i] = my_mod_inst_t();
+//     return i;
+// }
+
+std::int64_t
+ModuleWrapper::getGas()
+{
+    return instanceWrap_ ? instanceWrap_.getGas() : -1;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// void
+// WasmiEngine::clearModules()
+// {
+//     modules.clear();
+//     store.reset();  // to free the memory before creating new store
+//     store = {wasm_store_new(engine.get()), &wasm_store_delete};
+// }
+
+std::unique_ptr<wasm_engine_t, decltype(&wasm_engine_delete)>
+WasmiEngine::init()
+{
+    wasm_config_t* config = wasm_config_new();
+    if (!config)
+        return std::unique_ptr<wasm_engine_t, decltype(&wasm_engine_delete)>{
+            nullptr, &wasm_engine_delete};  // LCOV_EXCL_LINE
+    wasmi_config_consume_fuel_set(config, true);
+    wasmi_config_ignore_custom_sections_set(config, true);
+    wasmi_config_wasm_mutable_globals_set(config, false);
+    wasmi_config_wasm_multi_value_set(config, false);
+    wasmi_config_wasm_sign_extension_set(config, false);
+    wasmi_config_wasm_saturating_float_to_int_set(config, false);
+    wasmi_config_wasm_bulk_memory_set(config, false);
+    wasmi_config_wasm_reference_types_set(config, false);
+    wasmi_config_wasm_tail_call_set(config, false);
+    wasmi_config_wasm_extended_const_set(config, false);
+    wasmi_config_floats_set(config, false);
+
+    return std::unique_ptr<wasm_engine_t, decltype(&wasm_engine_delete)>(
+        wasm_engine_new_with_config(config), &wasm_engine_delete);
+}
+
+WasmiEngine::WasmiEngine()
+    : engine_(init()), store_(nullptr, &wasm_store_delete)
+{
+}
+
+int
+WasmiEngine::addModule(
+    Bytes const& wasmCode,
+    bool instantiate,
+    int64_t gas,
+    ImportVec const& imports)
+{
+    moduleWrap_.reset();
+    store_.reset();  // to free the memory before creating new store
+    store_ = {
+        wasm_store_new_with_memory_max_pages(engine_.get(), MAX_PAGES),
+        &wasm_store_delete};
+
+    if (gas < 0)
+        gas = std::numeric_limits<decltype(gas)>::max();
+    wasmi_error_t* err =
+        wasm_store_set_fuel(store_.get(), static_cast<std::uint64_t>(gas));
+    if (err)
+    {
+        // LCOV_EXCL_START
+        print_wasm_error("Error setting gas", nullptr, j_);
+        throw std::runtime_error("can't set gas");
+        // LCOV_EXCL_STOP
+    }
+
+    moduleWrap_ = std::make_unique<ModuleWrapper>(
+        store_.get(), wasmCode, instantiate, imports, j_);
+
+    if (!moduleWrap_)
+        throw std::runtime_error(
+            "can't create module wrapper");  // LCOV_EXCL_LINE
+
+    return moduleWrap_ ? 0 : -1;
+}
+
+// int
+// WasmiEngine::addInstance()
+// {
+//     return module->addInstance(store.get());
+// }
+
+FuncInfo
+WasmiEngine::getFunc(std::string_view funcName)
+{
+    return moduleWrap_->getFunc(funcName);
+}
+
+std::vector<wasm_val_t>
+WasmiEngine::convertParams(std::vector<WasmParam> const& params)
+{
+    std::vector<wasm_val_t> v;
+    v.reserve(params.size());
+    for (auto const& p : params)
+    {
+        switch (p.type)
+        {
+            case WT_I32:
+                v.push_back(WASM_I32_VAL(p.of.i32));
+                break;
+            // LCOV_EXCL_START
+            case WT_I64:
+                v.push_back(WASM_I64_VAL(p.of.i64));
+                break;
+            // LCOV_EXCL_STOP
+            case WT_U8V: {
+                auto const sz = p.of.u8v.sz;
+                auto const ptr = allocate(sz);
+                auto mem = getMem();
+                memcpy(mem.p + ptr, p.of.u8v.d, sz);
+
+                v.push_back(WASM_I32_VAL(ptr));
+                v.push_back(WASM_I32_VAL(sz));
+            }
+            break;
+            // LCOV_EXCL_START
+            default:
+                throw std::runtime_error(
+                    "unknown parameter type: " + std::to_string(p.type));
+                break;
+                // LCOV_EXCL_STOP
+        }
+    }
+
+    return v;
+}
+
+int
+WasmiEngine::compareParamTypes(
+    wasm_valtype_vec_t const* ftp,
+    std::vector<wasm_val_t> const& p)
+{
+    if (ftp->size != p.size())
+        return std::min(ftp->size, p.size());
+
+    for (unsigned i = 0; i < ftp->size; ++i)
+    {
+        auto const t1 = wasm_valtype_kind(ftp->data[i]);
+        auto const t2 = p[i].kind;
+        if (t1 != t2)
+            return i;
+    }
+
+    return -1;
+}
+
+// LCOV_EXCL_START
+void
+WasmiEngine::add_param(std::vector<wasm_val_t>& in, int32_t p)
+{
+    in.emplace_back();
+    auto& el(in.back());
+    memset(&el, 0, sizeof(el));
+    el = WASM_I32_VAL(p);  // WASM_I32;
+}
+
+// LCOV_EXCL_STOP
+
+void
+WasmiEngine::add_param(std::vector<wasm_val_t>& in, int64_t p)
+{
+    in.emplace_back();
+    auto& el(in.back());
+    el = WASM_I64_VAL(p);
+}
+
+template <int NR, class... Types>
+WasmiResult
+WasmiEngine::call(std::string_view func, Types&&... args)
+{
+    // Lookup our export function
+    auto f = getFunc(func);
+    return call<NR>(f, std::forward<Types>(args)...);
+}
+
+template <int NR, class... Types>
+WasmiResult
+WasmiEngine::call(FuncInfo const& f, Types&&... args)
+{
+    std::vector<wasm_val_t> in;
+    return call<NR>(f, in, std::forward<Types>(args)...);
+}
+
+#ifdef SHOW_CALL_TIME
+static inline uint64_t
+usecs()
+{
+    uint64_t x =
+        std::chrono::duration_cast<std::chrono::microseconds>(
+            std::chrono::high_resolution_clock::now().time_since_epoch())
+            .count();
+    return x;
+}
+#endif
+
+template <int NR, class... Types>
+WasmiResult
+WasmiEngine::call(FuncInfo const& f, std::vector<wasm_val_t>& in)
+{
+    // wasm_val_t rs[1] = {WASM_I32_VAL(0)};
+    WasmiResult ret(NR);
+    // if (NR)  {   wasm_val_vec_new_uninitialized(&ret, NR);    //
+    // wasm_val_vec_new(&ret, NR, &rs[0]);    // ret = WASM_ARRAY_VEC(rs);    }
+
+    wasm_val_vec_t const inv = in.empty()
+        ? wasm_val_vec_t WASM_EMPTY_VEC
+        : wasm_val_vec_t{in.size(), in.data()};
+
+#ifdef SHOW_CALL_TIME
+    auto const start = usecs();
+#endif
+
+    wasm_trap_t* trap = wasm_func_call(f.first, &inv, &ret.r);
+
+#ifdef SHOW_CALL_TIME
+    auto const finish = usecs();
+    auto const delta_ms = (finish - start) / 1000;
+    std::cout << "wasm_func_call: " << delta_ms << "ms" << std::endl;
+#endif
+
+    if (trap)
+    {
+        ret.f = true;
+        print_wasm_error("failure to call func", trap, j_);
+    }
+
+    // assert(results[0].kind == WASM_I32);
+    // if (NR) printf("Result P5: %d\n", ret[0].of.i32);
+
+    return ret;
+}
+
+template <int NR, class... Types>
+WasmiResult
+WasmiEngine::call(
+    FuncInfo const& f,
+    std::vector<wasm_val_t>& in,
+    std::int32_t p,
+    Types&&... args)
+{
+    add_param(in, p);
+    return call<NR>(f, in, std::forward<Types>(args)...);
+}
+
+template <int NR, class... Types>
+WasmiResult
+WasmiEngine::call(
+    FuncInfo const& f,
+    std::vector<wasm_val_t>& in,
+    std::int64_t p,
+    Types&&... args)
+{
+    add_param(in, p);
+    return call<NR>(f, in, std::forward<Types>(args)...);
+}
+
+template <int NR, class... Types>
+WasmiResult
+WasmiEngine::call(
+    FuncInfo const& f,
+    std::vector<wasm_val_t>& in,
+    uint8_t const* d,
+    std::size_t sz,
+    Types&&... args)
+{
+    auto const ptr = allocate(sz);
+    auto mem = getMem();
+    memcpy(mem.p + ptr, d, sz);
+
+    add_param(in, ptr);
+    add_param(in, static_cast<int32_t>(sz));
+    return call<NR>(f, in, std::forward<Types>(args)...);
+}
+
+template <int NR, class... Types>
+WasmiResult
+WasmiEngine::call(
+    FuncInfo const& f,
+    std::vector<wasm_val_t>& in,
+    Bytes const& p,
+    Types&&... args)
+{
+    return call<NR>(f, in, p.data(), p.size(), std::forward<Types>(args)...);
+}
+
+static inline void
+checkImports(ImportVec const& imports, HostFunctions* hfs)
+{
+    for (auto const& obj : imports)
+    {
+        if (hfs != obj.first)
+            Throw<std::runtime_error>("Imports hf unsync");
+    }
+}
+
+Expected<WasmResult<int32_t>, TER>
+WasmiEngine::run(
+    Bytes const& wasmCode,
+    std::string_view funcName,
+    std::vector<WasmParam> const& params,
+    ImportVec const& imports,
+    HostFunctions* hfs,
+    int64_t gas,
+    beast::Journal j)
+{
+    j_ = j;
+    try
+    {
+        checkImports(imports, hfs);
+        return runHlp(wasmCode, funcName, params, imports, hfs, gas);
+    }
+    catch (std::exception const& e)
+    {
+        print_wasm_error(std::string("exception: ") + e.what(), nullptr, j_);
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+        print_wasm_error(std::string("exception: unknown"), nullptr, j_);
+    }
+    // LCOV_EXCL_STOP
+    return Unexpected<TER>(tecFAILED_PROCESSING);
+}
+
+Expected<WasmResult<int32_t>, TER>
+WasmiEngine::runHlp(
+    Bytes const& wasmCode,
+    std::string_view funcName,
+    std::vector<WasmParam> const& params,
+    ImportVec const& imports,
+    HostFunctions* hfs,
+    int64_t gas)
+{
+    // currently only 1 module support, possible parallel UT run
+    std::lock_guard<decltype(m_)> lg(m_);
+
+    // Create and instantiate the module.
+    if (!wasmCode.empty())
+    {
+        [[maybe_unused]] int const m = addModule(wasmCode, true, gas, imports);
+    }
+
+    if (!moduleWrap_ || !moduleWrap_->instanceWrap_)
+        throw std::runtime_error("no instance");  // LCOV_EXCL_LINE
+
+    if (hfs)
+        hfs->setRT(&getRT());
+
+    // Call main
+    auto const f = getFunc(!funcName.empty() ? funcName : "_start");
+    auto const* ftp = wasm_functype_params(f.second);
+
+    // not const because passed directly to VM function (which accept non
+    // const)
+    auto p = convertParams(params);
+
+    if (int const comp = compareParamTypes(ftp, p); comp >= 0)
+        throw std::runtime_error(
+            "invalid parameter type #" + std::to_string(comp));
+
+    auto const res = call<1>(f, p);
+
+    if (res.f)
+        throw std::runtime_error("<" + std::string(funcName) + "> failure");
+    else if (!res.r.size)
+        throw std::runtime_error(
+            "<" + std::string(funcName) +
+            "> return nothing");  // LCOV_EXCL_LINE
+
+    assert(res.r.data[0].kind == WASM_I32);
+    if (gas == -1)
+        gas = std::numeric_limits<decltype(gas)>::max();
+    WasmResult<int32_t> const ret{
+        res.r.data[0].of.i32, gas - moduleWrap_->getGas()};
+
+    // #ifdef DEBUG_OUTPUT
+    //     auto& j = std::cerr;
+    // #else
+    //     auto j = j_.debug();
+    // #endif
+    // j << "WASMI Res: " << ret.result << " cost: " << ret.cost << std::endl;
+
+    return ret;
+}
+
+NotTEC
+WasmiEngine::check(
+    Bytes const& wasmCode,
+    std::string_view funcName,
+    std::vector<WasmParam> const& params,
+    ImportVec const& imports,
+    HostFunctions* hfs,
+    beast::Journal j)
+{
+    j_ = j;
+
+    try
+    {
+        checkImports(imports, hfs);
+        return checkHlp(wasmCode, funcName, params, imports);
+    }
+    catch (std::exception const& e)
+    {
+        print_wasm_error(std::string("exception: ") + e.what(), nullptr, j_);
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+        print_wasm_error(std::string("exception: unknown"), nullptr, j_);
+    }
+    // LCOV_EXCL_STOP
+
+    return temBAD_WASM;
+}
+
+NotTEC
+WasmiEngine::checkHlp(
+    Bytes const& wasmCode,
+    std::string_view funcName,
+    std::vector<WasmParam> const& params,
+    ImportVec const& imports)
+{
+    // currently only 1 module support, possible parallel UT run
+    std::lock_guard<decltype(m_)> lg(m_);
+
+    // Create and instantiate the module.
+    if (wasmCode.empty())
+        throw std::runtime_error("empty nodule");
+
+    int const m = addModule(wasmCode, true, -1, imports);
+    if ((m < 0) || !moduleWrap_ || !moduleWrap_->instanceWrap_)
+        throw std::runtime_error("no instance");  // LCOV_EXCL_LINE
+
+    // Looking for a func and compare parameter types
+    auto const f = getFunc(!funcName.empty() ? funcName : "_start");
+    auto const* ftp = wasm_functype_params(f.second);
+    auto const p = convertParams(params);
+
+    if (int const comp = compareParamTypes(ftp, p); comp >= 0)
+        throw std::runtime_error(
+            "invalid parameter type #" + std::to_string(comp));
+
+    return tesSUCCESS;
+}
+
+// LCOV_EXCL_START
+std::int64_t
+WasmiEngine::getGas()
+{
+    return moduleWrap_ ? moduleWrap_->getGas() : -1;
+}
+// LCOV_EXCL_STOP
+
+wmem
+WasmiEngine::getMem() const
+{
+    return moduleWrap_ ? moduleWrap_->getMem() : wmem();
+}
+
+InstanceWrapper const&
+WasmiEngine::getRT(int m, int i)
+{
+    if (!moduleWrap_)
+        throw std::runtime_error("no module");
+    return moduleWrap_->getInstance(i);
+}
+
+int32_t
+WasmiEngine::allocate(int32_t sz)
+{
+    auto res = call<1>(W_ALLOC, static_cast<int32_t>(sz));
+
+    if (res.f || !res.r.size || (res.r.data[0].kind != WASM_I32) ||
+        !res.r.data[0].of.i32)
+        throw std::runtime_error(
+            "can't allocate memory, " + std::to_string(sz) + " bytes");
+    return res.r.data[0].of.i32;
+}
+
+wasm_trap_t*
+WasmiEngine::newTrap(std::string const& txt)
+{
+    static char empty[1] = {0};
+    wasm_message_t msg = {1, empty};
+
+    if (!txt.empty())
+        wasm_name_new(&msg, txt.size() + 1, txt.c_str());  // include 0
+
+    return wasm_trap_new(store_.get(), &msg);
+}
+
+// LCOV_EXCL_START
+beast::Journal
+WasmiEngine::getJournal() const
+{
+    return j_;
+}
+// LCOV_EXCL_STOP
+
+}  // namespace ripple
@@ -54,6 +54,15 @@ struct FeeSetup
    /** The per-owned item reserve requirement in drops. */
    XRPAmount owner_reserve{2 * DROPS_PER_XRP};

+    /** The compute limit for Feature Extensions. */
+    std::uint32_t extension_compute_limit{1'000'000};
+
+    /** The WASM size limit for Feature Extensions. */
+    std::uint32_t extension_size_limit{100'000};
+
+    /** The price of 1 WASM gas, in micro-drops. */
+    std::uint32_t gas_price{1'000'000};
+
    /* (Remember to update the example cfg files when changing any of these
     * values.) */
 };
@@ -1122,6 +1122,12 @@ setup_FeeVote(Section const& section)
            setup.account_reserve = temp;
        if (set(temp, "owner_reserve", section))
            setup.owner_reserve = temp;
+        if (set(temp, "extension_compute_limit", section))
+            setup.extension_compute_limit = temp;
+        if (set(temp, "extension_size_limit", section))
+            setup.extension_size_limit = temp;
+        if (set(temp, "gas_price", section))
+            setup.gas_price = temp;
    }
    return setup;
 }
Author	SHA1	Message	Date
Oleksandr	398efc0c2a	Wasmi memory limits	2025-12-02 15:18:53 -05:00
Olek	7212793afe	Add host-functions cost for wasmi (#6078 ) * Add host-functions cost for wasmi * Fix codecov * Add trap generation to gas check in HF * Wasmi conan refactoring	2025-12-02 15:18:53 -05:00
Olek	64084010ae	Fix win build (#6073 )	2025-12-02 15:18:52 -05:00
Olek	718ba16e3e	Switch to rust docker (#6061 ) * fix clang-format * Switch to rust docker * fix wasmi conan package * Add TODO * Add patch description * Switch to latest prepare-runner	2025-12-02 15:18:52 -05:00
Olek	db83c7481b	Fix wasmi MacOs build (#6051 )	2025-12-02 15:18:52 -05:00
Oleksandr	fdf915e16f	Wasm small refactoring	2025-12-02 15:18:52 -05:00
Oleksandr	309b8f1fbd	Wasm fixtures sources	2025-12-02 15:18:52 -05:00
Oleksandr	4a04181ada	Wasm fee voting	2025-12-02 15:18:52 -05:00
Oleksandr	fe75c5d441	Wasm SmartEscrow	2025-12-02 15:18:52 -05:00
Oleksandr	801110ee01	Wasmi engine	2025-12-02 15:18:52 -05:00