Check wasm return type (#6240)

* Check wasm return type

* Add more tests

.config/cspell.config.yaml

@@ -268,6 +268,7 @@ words:
   - venv
   - vfalco
   - vinnie
+  - wasmi
   - wextra
   - wptr
   - writeme

.github/CODEOWNERS

@@ -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

.github/actions/generate-version/action.yml

@@ -17,8 +17,10 @@ runs:
         VERSION: ${{ github.ref_name }}
       run: echo "VERSION=${VERSION}" >> "${GITHUB_ENV}"
 
-    # When a tag is not pushed, then the version is extracted from the
-    # BuildInfo.cpp file and the shortened commit hash appended to it.
+    # When a tag is not pushed, then the version (e.g. 1.2.3-b0) is extracted
+    # from the BuildInfo.cpp file and the shortened commit hash appended to it.
+    # We use a plus sign instead of a hyphen because Conan recipe versions do
+    # not support two hyphens.
     - name: Generate version for non-tag event
       if: ${{ github.event_name != 'tag' }}
       shell: bash
@@ -32,7 +34,7 @@ runs:
 
         echo 'Appending shortened commit hash to version.'
         SHA='${{ github.sha }}'
-        VERSION="${VERSION}-${SHA:0:7}"
+        VERSION="${VERSION}+${SHA:0:7}"
 
         echo "VERSION=${VERSION}" >> "${GITHUB_ENV}"
 

.github/actions/setup-conan/action.yml

@@ -31,7 +31,7 @@ runs:
         conan config install conan/profiles/ -tf $(conan config home)/profiles/
 
         echo 'Conan profile:'
-        conan profile show
+        conan profile show --profile ci
 
     - name: Set up Conan remote
       shell: bash

.github/workflows/on-pr.yml

@@ -59,6 +59,7 @@ jobs:
             # Keep the paths below in sync with those in `on-trigger.yml`.
             .github/actions/build-deps/**
             .github/actions/build-test/**
+            .github/actions/generate-version/**
             .github/actions/setup-conan/**
             .github/scripts/strategy-matrix/**
             .github/workflows/reusable-build.yml

.github/workflows/on-trigger.yml

@@ -16,6 +16,7 @@ on:
       # Keep the paths below in sync with those in `on-pr.yml`.
       - ".github/actions/build-deps/**"
       - ".github/actions/build-test/**"
+      - ".github/actions/generate-version/**"
       - ".github/actions/setup-conan/**"
       - ".github/scripts/strategy-matrix/**"
       - ".github/workflows/reusable-build.yml"

.github/workflows/reusable-build-test-config.yml

@@ -125,6 +125,8 @@ jobs:
           subtract: ${{ inputs.nproc_subtract }}
 
       - name: Setup Conan
+        env:
+          SANITIZERS: ${{ inputs.sanitizers }}
         uses: ./.github/actions/setup-conan
 
       - name: Build dependencies

.github/workflows/reusable-upload-recipe.yml

@@ -49,10 +49,6 @@ jobs:
         id: version
         uses: ./.github/actions/generate-version
 
-      - name: Determine recipe reference
-        id: ref
-        run: echo "ref=xrpl/${{ steps.version.outputs.version }}" >> "${GITHUB_OUTPUT}"
-
       - name: Set up Conan
         uses: ./.github/actions/setup-conan
         with:
@@ -62,17 +58,16 @@ jobs:
       - name: Log into Conan remote
         env:
           REMOTE_NAME: ${{ inputs.remote_name }}
-          REMOTE_USERNAME: ${{ inputs.remote_username }}
-          REMOTE_PASSWORD: ${{ inputs.remote_password }}
+          REMOTE_USERNAME: ${{ secrets.remote_username }}
+          REMOTE_PASSWORD: ${{ secrets.remote_password }}
         run: conan remote login "${REMOTE_NAME}" "${REMOTE_USERNAME}" --password "${REMOTE_PASSWORD}"
 
       - name: Upload Conan recipe
         env:
-          RECIPE_REF: ${{ steps.ref.outputs.ref }}
           REMOTE_NAME: ${{ inputs.remote_name }}
         run: |
-          conan export .
-          conan upload --confirm --check --remote="${REMOTE_NAME}" ${RECIPE_REF}
+          conan export . --version=${{ steps.version.outputs.version }}
+          conan upload --confirm --check --remote="${REMOTE_NAME}" xrpl/${{ steps.version.outputs.version }}
 
     outputs:
-      ref: ${{ steps.ref.outputs.ref }}
+      ref: xrpl/${{ steps.version.outputs.version }}

.github/workflows/upload-conan-deps.yml

@@ -84,6 +84,8 @@ jobs:
           subtract: ${{ env.NPROC_SUBTRACT }}
 
       - name: Setup Conan
+        env:
+          SANITIZERS: ${{ matrix.sanitizers }}
         uses: ./.github/actions/setup-conan
         with:
           remote_name: ${{ env.CONAN_REMOTE_NAME }}
@@ -98,6 +100,7 @@ jobs:
           # Set the verbosity to "quiet" for Windows to avoid an excessive
           # amount of logs. For other OSes, the "verbose" logs are more useful.
           log_verbosity: ${{ runner.os == 'Windows' && 'quiet' || 'verbose' }}
+          sanitizers: ${{ matrix.sanitizers }}
 
       - name: Log into Conan remote
         if: ${{ github.repository_owner == 'XRPLF' && (github.event_name == 'push' || github.event_name == 'workflow_dispatch') }}

CMakeLists.txt

@@ -8,7 +8,9 @@ if(POLICY CMP0077)
 endif()
 
 # Fix "unrecognized escape" issues when passing CMAKE_MODULE_PATH on Windows.
-file(TO_CMAKE_PATH "${CMAKE_MODULE_PATH}" CMAKE_MODULE_PATH)
+if(DEFINED CMAKE_MODULE_PATH)
+  file(TO_CMAKE_PATH "${CMAKE_MODULE_PATH}" CMAKE_MODULE_PATH)
+endif()
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
 project(xrpl)
@@ -103,6 +105,7 @@ find_package(OpenSSL REQUIRED)
 find_package(secp256k1 REQUIRED)
 find_package(SOCI REQUIRED)
 find_package(SQLite3 REQUIRED)
+find_package(wasmi REQUIRED)
 find_package(xxHash REQUIRED)
 
 target_link_libraries(xrpl_libs INTERFACE

cmake/CompilationEnv.cmake

@@ -13,6 +13,7 @@ include_guard(GLOBAL)
 set(is_clang FALSE)
 set(is_gcc FALSE)
 set(is_msvc FALSE)
+set(is_xcode FALSE)
 
 if(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang") # Clang or AppleClang
   set(is_clang TRUE)
@@ -24,6 +25,11 @@ else()
   message(FATAL_ERROR "Unsupported C++ compiler: ${CMAKE_CXX_COMPILER_ID}")
 endif()
 
+# Xcode generator detection
+if(CMAKE_GENERATOR STREQUAL "Xcode")
+  set(is_xcode TRUE)
+endif()
+
 
 # --------------------------------------------------------------------
 # Operating system detection

cmake/XrplCore.cmake

@@ -32,14 +32,14 @@ target_protobuf_sources(xrpl.libpb xrpl/proto
 
 target_compile_options(xrpl.libpb
   PUBLIC
-    $<$<BOOL:${MSVC}>:-wd4996>
-    $<$<BOOL:${XCODE}>:
+    $<$<BOOL:${is_msvc}>:-wd4996>
+    $<$<BOOL:${is_xcode}>:
       --system-header-prefix="google/protobuf"
       -Wno-deprecated-dynamic-exception-spec
     >
   PRIVATE
-    $<$<BOOL:${MSVC}>:-wd4065>
-    $<$<NOT:$<BOOL:${MSVC}>>:-Wno-deprecated-declarations>
+    $<$<BOOL:${is_msvc}>:-wd4065>
+    $<$<NOT:$<BOOL:${is_msvc}>>:-Wno-deprecated-declarations>
 )
 
 target_link_libraries(xrpl.libpb
@@ -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>

cmake/XrplInstall.cmake

@@ -4,6 +4,12 @@
 
 include(create_symbolic_link)
 
+# If no suffix is defined for executables (e.g. Windows uses .exe but Linux
+# and macOS use none), then explicitly set it to the empty string.
+if(NOT DEFINED suffix)
+  set(suffix "")
+endif()
+
 install (
   TARGETS
     common

cmake/XrplInterface.cmake

@@ -4,6 +4,11 @@
 
 include(CompilationEnv)
 
+# Set defaults for optional variables to avoid uninitialized variable warnings
+if(NOT DEFINED voidstar)
+  set(voidstar OFF)
+endif()
+
 add_library (opts INTERFACE)
 add_library (Xrpl::opts ALIAS opts)
 target_compile_definitions (opts
@@ -52,7 +57,7 @@ add_library (xrpl_syslibs INTERFACE)
 add_library (Xrpl::syslibs ALIAS xrpl_syslibs)
 target_link_libraries (xrpl_syslibs
   INTERFACE
-    $<$<BOOL:${MSVC}>:
+    $<$<BOOL:${is_msvc}>:
       legacy_stdio_definitions.lib
       Shlwapi
       kernel32
@@ -69,10 +74,10 @@ target_link_libraries (xrpl_syslibs
       odbccp32
       crypt32
     >
-    $<$<NOT:$<BOOL:${MSVC}>>:dl>
-    $<$<NOT:$<OR:$<BOOL:${MSVC}>,$<BOOL:${APPLE}>>>:rt>)
+    $<$<NOT:$<BOOL:${is_msvc}>>:dl>
+    $<$<NOT:$<OR:$<BOOL:${is_msvc}>,$<BOOL:${is_macos}>>>:rt>)
 
-if (NOT MSVC)
+if (NOT is_msvc)
   set (THREADS_PREFER_PTHREAD_FLAG ON)
   find_package (Threads)
   target_link_libraries (xrpl_syslibs INTERFACE Threads::Threads)

cmake/XrplSanitizers.cmake

@@ -43,7 +43,10 @@
 include(CompilationEnv)
 
 # Read environment variable
-set(SANITIZERS $ENV{SANITIZERS})
+set(SANITIZERS "")
+if(DEFINED ENV{SANITIZERS})
+  set(SANITIZERS "$ENV{SANITIZERS}")
+endif()
 
 # Set SANITIZERS_ENABLED flag for use in other modules
 if(SANITIZERS MATCHES "address|thread|undefinedbehavior")

cmake/XrplSettings.cmake

@@ -4,10 +4,11 @@
 
 include(CompilationEnv)
 
-if("$ENV{CI}" STREQUAL "true" OR "$ENV{CONTINUOUS_INTEGRATION}" STREQUAL "true")
-  set(is_ci TRUE)
-else()
-  set(is_ci FALSE)
+set(is_ci FALSE)
+if(DEFINED ENV{CI})
+  if("$ENV{CI}" STREQUAL "true")
+    set(is_ci TRUE)
+  endif()
 endif()
 
 get_directory_property(has_parent PARENT_DIRECTORY)

conan.lock

@@ -3,6 +3,7 @@
     "requires": [
         "zlib/1.3.1#b8bc2603263cf7eccbd6e17e66b0ed76%1765850150.075",
         "xxhash/0.8.3#681d36a0a6111fc56e5e45ea182c19cc%1765850149.987",
+        "wasmi/1.0.6#407c9db14601a8af1c7dd3b388f3e4cd%1768164779.349",
         "sqlite3/3.49.1#8631739a4c9b93bd3d6b753bac548a63%1765850149.926",
         "soci/4.0.3#a9f8d773cd33e356b5879a4b0564f287%1765850149.46",
         "snappy/1.1.10#968fef506ff261592ec30c574d4a7809%1765850147.878",

conanfile.py

@@ -35,6 +35,7 @@ class Xrpl(ConanFile):
         "openssl/3.5.4",
         "secp256k1/0.7.0",
         "soci/4.0.3",
+        "wasmi/1.0.6",
         "zlib/1.3.1",
     ]
 
@@ -216,6 +217,7 @@ class Xrpl(ConanFile):
             "soci::soci",
             "secp256k1::secp256k1",
             "sqlite3::sqlite",
+            "wasmi::wasmi",
             "xxhash::xxhash",
             "zlib::zlib",
         ]

include/xrpl/basics/Number.h

@@ -751,6 +751,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

include/xrpl/protocol/Protocol.h

@@ -252,6 +252,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;
 

include/xrpl/protocol/TER.h

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

include/xrpl/protocol/detail/ledger_entries.macro

@@ -578,7 +578,7 @@ LEDGER_ENTRY(ltLOAN, 0x0089, Loan, loan, ({
     //   The unrounded true total value of the loan.
     //
     // - TrueTotalPrincipalOutstanding can be computed using the algorithm
-    //   in the ripple::detail::loanPrincipalFromPeriodicPayment function.
+    //   in the xrpl::detail::loanPrincipalFromPeriodicPayment function.
     //
     // - TrueTotalInterestOutstanding = TrueTotalLoanValue -
     //      TrueTotalPrincipalOutstanding

src/libxrpl/basics/Number.cpp

@@ -984,6 +984,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

src/libxrpl/beast/core/CurrentThreadName.cpp

@@ -1,4 +1,5 @@
 #include <xrpl/beast/core/CurrentThreadName.h>
+#include <xrpl/beast/utility/instrumentation.h>
 
 #include <string>
 #include <string_view>
@@ -95,6 +96,11 @@ setCurrentThreadNameImpl(std::string_view name)
         std::cerr << "WARNING: Thread name \"" << name << "\" (length "
                   << name.size() << ") exceeds maximum of "
                   << maxThreadNameLength << " characters on Linux.\n";
+
+        XRPL_ASSERT(
+            false,
+            "beast::detail::setCurrentThreadNameImpl : Thread name exceeds "
+            "maximum length for Linux");
     }
 #endif
 }

src/libxrpl/core/detail/Job.cpp

@@ -41,7 +41,7 @@ Job::queue_time() const
 void
 Job::doJob()
 {
-    beast::setCurrentThreadName("doJob: " + mName);
+    beast::setCurrentThreadName("j:" + mName);
     m_loadEvent->start();
     m_loadEvent->setName(mName);
 

src/libxrpl/protocol/TER.cpp

@@ -200,6 +200,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."),

src/test/app/wasm_fixtures/.gitignore

@@ -0,0 +1,3 @@
+**/target
+**/debug
+*.wasm

src/test/app/wasm_fixtures/all_host_functions/Cargo.lock

@@ -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",
+]

src/test/app/wasm_fixtures/all_host_functions/Cargo.toml

@@ -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

src/test/app/wasm_fixtures/all_host_functions/src/lib.rs

@@ -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
+}

src/test/app/wasm_fixtures/all_keylets/Cargo.lock

@@ -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",
+]

src/test/app/wasm_fixtures/all_keylets/Cargo.toml

@@ -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"

src/test/app/wasm_fixtures/all_keylets/src/lib.rs

@@ -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.
+}

src/test/app/wasm_fixtures/b58.c

@@ -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;
+}

src/test/app/wasm_fixtures/bad_align.c

@@ -0,0 +1,23 @@
+#include <stdint.h>
+
+int32_t
+float_from_uint(uint8_t const*, int32_t, uint8_t*, int32_t, int32_t);
+int32_t
+get_tx_nested_field(uint8_t const*, int32_t, uint8_t*, int32_t);
+
+uint8_t e_data[32 * 1024];
+
+int32_t
+test()
+{
+    e_data[1] = 0xFF;
+    e_data[2] = 0xFF;
+    e_data[3] = 0xFF;
+    e_data[4] = 0xFF;
+    e_data[5] = 0xFF;
+    e_data[6] = 0xFF;
+    e_data[7] = 0xFF;
+    e_data[8] = 0xFF;
+    float_from_uint(&e_data[1], 8, &e_data[35], 12, 0);
+    return *((int32_t*)(&e_data[36]));
+}

src/test/app/wasm_fixtures/bad_alloc.c

@@ -0,0 +1,27 @@
+#include <stdint.h>
+
+char buf[1024];
+
+void*
+allocate(int sz)
+{
+    if (!sz)
+        return 0;
+
+    if (sz == 1)
+        return ((void*)(8 * 1024 * 1024));
+    if (sz == 2)
+        return 0;
+    if (sz == 3)
+        return ((void*)(0xFFFFFFFF));
+
+    return &buf[sz];
+}
+
+int32_t
+test(char* p, int32_t sz)
+{
+    if (!sz)
+        return 0;
+    return p[0];
+}

src/test/app/wasm_fixtures/codecov_tests/Cargo.lock

@@ -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",
+]

src/test/app/wasm_fixtures/codecov_tests/Cargo.toml

@@ -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" }

src/test/app/wasm_fixtures/codecov_tests/src/host_bindings_loose.rs

@@ -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;
+}

src/test/app/wasm_fixtures/copyFixtures.py

@@ -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.")

src/test/app/wasm_fixtures/disableFloat.wat

@@ -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)))

src/test/app/wasm_fixtures/fib.c

@@ -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);
+}

src/test/app/wasm_fixtures/fixtures.h

@@ -0,0 +1,87 @@
+#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 memoryPointerAtLimitHex;
+extern std::string const memoryPointerOverLimitHex;
+extern std::string const memoryOffsetOverLimitHex;
+extern std::string const memoryEndOfWordOverLimitHex;
+extern std::string const memoryGrow0To1PageHex;
+extern std::string const memoryGrow1To0PageHex;
+extern std::string const memoryLastByteOf8MBHex;
+extern std::string const memoryGrow1MoreThan8MBHex;
+extern std::string const memoryGrow0MoreThan8MBHex;
+extern std::string const memoryInit1MoreThan8MBHex;
+extern std::string const memoryNegativeAddressHex;
+
+extern std::string const table64ElementsHex;
+extern std::string const table65ElementsHex;
+extern std::string const table2TablesHex;
+extern std::string const table0ElementsHex;
+extern std::string const tableUintMaxHex;
+
+extern std::string const proposalMutableGlobalHex;
+extern std::string const proposalGcStructNewHex;
+extern std::string const proposalMultiValueHex;
+extern std::string const proposalSignExtHex;
+extern std::string const proposalFloatToIntHex;
+extern std::string const proposalBulkMemoryHex;
+extern std::string const proposalRefTypesHex;
+extern std::string const proposalTailCallHex;
+extern std::string const proposalExtendedConstHex;
+extern std::string const proposalMultiMemoryHex;
+extern std::string const proposalCustomPageSizesHex;
+extern std::string const proposalMemory64Hex;
+extern std::string const proposalWideArithmeticHex;
+
+extern std::string const trapDivideBy0Hex;
+extern std::string const trapIntOverflowHex;
+extern std::string const trapUnreachableHex;
+extern std::string const trapNullCallHex;
+extern std::string const trapFuncSigMismatchHex;
+
+extern std::string const wasiGetTimeHex;
+extern std::string const wasiPrintHex;
+
+extern std::string const badMagicNumberHex;
+extern std::string const badVersionNumberHex;
+extern std::string const lyingHeaderHex;
+extern std::string const neverEndingNumberHex;
+extern std::string const vectorLieHex;
+extern std::string const sectionOrderingHex;
+extern std::string const ghostPayloadHex;
+extern std::string const junkAfterSectionHex;
+extern std::string const invalidSectionIdHex;
+extern std::string const localVariableBombHex;
+
+extern std::string const infiniteLoopWasmHex;
+extern std::string const startLoopHex;
+
+extern std::string const badAllocHex;
+extern std::string const badAlignHex;

src/test/app/wasm_fixtures/float_tests/Cargo.lock

@@ -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",
+]

src/test/app/wasm_fixtures/float_tests/Cargo.toml

@@ -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"

src/test/app/wasm_fixtures/float_tests/src/lib.rs

@@ -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
+}

src/test/app/wasm_fixtures/infiniteLoop.c

@@ -0,0 +1,8 @@
+int
+loop()
+{
+    int volatile x = 0;
+    while (1)
+        x++;
+    return x;
+}

src/test/app/wasm_fixtures/ledgerSqn.c

@@ -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);
+}

src/test/app/wasm_fixtures/sha512Pure.c

@@ -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;
+// }

src/test/app/wasm_fixtures/wat/custom_page_sizes.wat

@@ -0,0 +1,13 @@
+(module
+  ;; Define a memory with 1 initial page.
+  ;; CRITICAL: We explicitly set the page size to 1 kilobyte.
+  ;; Standard Wasm implies (pagesize 65536).
+  (memory 1 (pagesize 1024))
+
+  (func $finish (result i32)
+    ;; If this module instantiates, the runtime accepted the custom page size.
+    i32.const 1
+  )
+
+  (export "finish" (func $finish))
+)

src/test/app/wasm_fixtures/wat/deep_recursion.wat

@@ -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))
+)

src/test/app/wasm_fixtures/wat/memory64.wat

@@ -0,0 +1,21 @@
+(module
+  ;; Define a 64-bit memory (index type i64)
+  ;; Start with 1 page.
+  (memory i64 1)
+
+  (func $finish (result i32)
+    ;; 1. Perform a store using a 64-bit address.
+    ;;    Even if the value is small (0), the type MUST be i64.
+    i64.const 0     ;; Address (64-bit)
+    i32.const 42    ;; Value (32-bit)
+    i32.store8      ;; Opcode doesn't change, but validation rules do.
+
+    ;; 2. check memory size
+    ;;    memory.size now returns an i64.
+    memory.size
+    i64.const 1
+    i64.eq          ;; Returns i32 (1 if true)
+  )
+
+  (export "finish" (func $finish))
+)

src/test/app/wasm_fixtures/wat/memory_end_of_word_over_limit.wat

@@ -0,0 +1,28 @@
+(module
+  ;; 1. Define Memory: 1 Page = 64KB = 65,536 bytes
+  (memory 1)
+
+  ;; Export memory so the host can inspect it if needed
+  (export "memory" (memory 0))
+
+  (func $test_straddle (result i32)
+    ;; Push the address onto the stack.
+    ;; 65534 is valid, but it is only 2 bytes away from the end.
+    i32.const 65534
+
+    ;; Attempt to load an i32 (4 bytes) from that address.
+    ;; This requires bytes 65534, 65535, 65536, and 65537.
+    ;; Since 65536 is the first invalid byte, this MUST trap.
+    i32.load
+
+    ;; Clean up the stack.
+    ;; The load pushed a value, but we don't care what it is.
+    drop
+
+    ;; Return 1 to signal "I survived the memory access"
+    i32.const 1
+  )
+
+  ;; Export the function so you can call it from your host (JS, Python, etc.)
+  (export "finish" (func $test_straddle))
+)

src/test/app/wasm_fixtures/wat/memory_grow_0_page_more_than_8MB.wat

@@ -0,0 +1,29 @@
+(module
+  ;; Start at your limit: 128 pages (8MB)
+  (memory 128)
+  (export "memory" (memory 0))
+
+  (func $try_grow_beyond_limit (result i32)
+    ;; Attempt to grow by 0 page
+    i32.const 0
+    memory.grow
+
+    ;; memory.grow returns:
+    ;;   -1  if the growth failed (Correct behavior for your limit)
+    ;;   128 (old size) if growth succeeded (Means limit was bypassed)
+
+    ;; Check if result == -1
+    i32.const -1
+    i32.eq
+    if
+      ;; Growth FAILED (Host blocked it). Return -1.
+      i32.const -1
+      return
+    end
+
+    ;; Growth SUCCEEDED (Host allowed it). Return 1.
+    i32.const 1
+  )
+
+  (export "finish" (func $try_grow_beyond_limit))
+)

src/test/app/wasm_fixtures/wat/memory_grow_0_to_1.wat

@@ -0,0 +1,26 @@
+(module
+  ;; 1. Define Memory: Start with 0 pages
+  (memory 0)
+
+  ;; Export memory to host
+  (export "memory" (memory 0))
+
+  (func $grow_from_zero (result i32)
+    ;; We have 0 pages. We want to add 1 page.
+    ;; Push delta (1) onto stack.
+    i32.const 1
+
+    ;; Grow the memory.
+    ;; If successful: memory becomes 64KB, returns old size (0).
+    ;; If failed: memory stays 0, returns -1.
+    memory.grow
+
+    ;; Drop the return value of memory.grow
+    drop
+
+    ;; Return 1 (as requested)
+    i32.const 1
+  )
+
+  (export "finish" (func $grow_from_zero))
+)

src/test/app/wasm_fixtures/wat/memory_grow_1_page_more_than_8MB.wat

@@ -0,0 +1,29 @@
+(module
+  ;; Start at your limit: 128 pages (8MB)
+  (memory 128)
+  (export "memory" (memory 0))
+
+  (func $try_grow_beyond_limit (result i32)
+    ;; Attempt to grow by 1 page
+    i32.const 1
+    memory.grow
+
+    ;; memory.grow returns:
+    ;;   -1  if the growth failed (Correct behavior for your limit)
+    ;;   128 (old size) if growth succeeded (Means limit was bypassed)
+
+    ;; Check if result == -1
+    i32.const -1
+    i32.eq
+    if
+      ;; Growth FAILED (Host blocked it). Return -1.
+      i32.const -1
+      return
+    end
+
+    ;; Growth SUCCEEDED (Host allowed it). Return 1.
+    i32.const 1
+  )
+
+  (export "finish" (func $try_grow_beyond_limit))
+)

src/test/app/wasm_fixtures/wat/memory_grow_1_to_0.wat

@@ -0,0 +1,33 @@
+(module
+  ;; 1. Define Memory: Start with 1 page (64KB)
+  (memory 1)
+
+  ;; Export memory to host
+  (export "memory" (memory 0))
+
+  (func $grow_negative (result i32)
+    ;; The user pushed -1. In Wasm, this is interpreted as unsigned MAX_UINT32.
+    ;; This is requesting to add 4,294,967,295 pages (approx 256 TB).
+    ;; A secure runtime MUST fail this request (return -1) without crashing.
+    i32.const -1
+
+    ;; Grow the memory.
+    ;; Returns: old_size if success, -1 if failure.
+    memory.grow
+
+    ;; Check if result == -1 (Failure)
+    i32.const -1
+    i32.eq
+    if
+        ;; If memory.grow returned -1, we return -1 to signal "Correctly failed".
+        i32.const -1
+        return
+    end
+
+    ;; If we are here, memory.grow somehow SUCCEEDED (Vulnerability).
+    ;; We return 1 to signal "Unexpected Success".
+    i32.const 1
+  )
+
+  (export "finish" (func $grow_negative))
+)

src/test/app/wasm_fixtures/wat/memory_init_1_page_more_than_8MB.wat

@@ -0,0 +1,27 @@
+(module
+  ;; Define memory: 129 pages (> 8MB limit) min, 129 pages max
+  (memory 129 129)
+
+  ;; Export memory so host can verify size
+  (export "memory" (memory 0))
+
+  ;; access last byte of 8MB limit
+  (func $access_last_byte (result i32)
+    ;; Math: 128 pages * 64,536 bytes/page = 8,388,608 bytes
+    ;; Valid indices: 0 to 8,388,607
+
+    ;; Push the address of the LAST valid byte
+    i32.const 8388607
+
+    ;; Load byte from that address
+    i32.load8_u
+
+    ;; Drop the value (we don't care what it is, just that we could read it)
+    drop
+
+    ;; Return 1 to indicate success
+    i32.const 1
+  )
+
+  (export "finish" (func $access_last_byte))
+)

src/test/app/wasm_fixtures/wat/memory_last_byte_of_8MB.wat

@@ -0,0 +1,26 @@
+(module
+  ;; Define memory: 128 pages (8MB) min, 128 pages max
+  (memory 128 128)
+
+  ;; Export memory so host can verify size
+  (export "memory" (memory 0))
+
+  (func $access_last_byte (result i32)
+    ;; Math: 128 pages * 64,536 bytes/page = 8,388,608 bytes
+    ;; Valid indices: 0 to 8,388,607
+
+    ;; Push the address of the LAST valid byte
+    i32.const 8388607
+
+    ;; Load byte from that address
+    i32.load8_u
+
+    ;; Drop the value (we don't care what it is, just that we could read it)
+    drop
+
+    ;; Return 1 to indicate success
+    i32.const 1
+  )
+
+  (export "finish" (func $access_last_byte))
+)

src/test/app/wasm_fixtures/wat/memory_negative_address.wat

@@ -0,0 +1,23 @@
+(module
+  ;; Define memory: 128 pages (8MB) min, 128 pages max
+  (memory 128 128)
+
+  ;; Export memory so host can verify size
+  (export "memory" (memory 0))
+
+  (func $access_last_byte (result i32)
+    ;; Push a negative address
+    i32.const -1
+
+    ;; Load byte from that address
+    i32.load8_u
+
+    ;; Drop the value
+    drop
+
+    ;; Return 1 to indicate success
+    i32.const 1
+  )
+
+  (export "finish" (func $access_last_byte))
+)

src/test/app/wasm_fixtures/wat/memory_offset_over_limit.wat

@@ -0,0 +1,27 @@
+(module
+  ;; 1. Define Memory: 1 Page = 64KB
+  (memory 1)
+
+  (export "memory" (memory 0))
+
+  (func $test_offset_overflow (result i32)
+    ;; 1. Push the base address onto the stack.
+    ;; We use '0', which is the safest, most valid address possible.
+    i32.const 0
+
+    ;; 2. Attempt to load using a static offset.
+    ;; syntax: i32.load offset=N align=N
+    ;; We set the offset to 65536 (the size of the memory).
+    ;; The effective address becomes 0 + 65536 = 65536.
+    i32.load offset=65536
+
+    ;; Clean up the stack.
+    ;; The load pushed a value, but we don't care what it is.
+    drop
+
+    ;; Return 1 to signal "I survived the memory access"
+    i32.const 1
+  )
+
+  (export "finish" (func $test_offset_overflow))
+)

src/test/app/wasm_fixtures/wat/memory_pointer_at_limit.wat

@@ -0,0 +1,22 @@
+(module
+  ;; Define 1 page of memory (64KB = 65,536 bytes)
+  (memory 1)
+
+  (func $read_edge (result i32)
+    ;; Push the index of the LAST valid byte
+    i32.const 65535
+
+    ;; Load 1 byte (unsigned)
+    i32.load8_u
+
+    ;; Clean up the stack.
+    ;; The load pushed a value, but we don't care what it is.
+    drop
+
+    ;; Return 1 to signal "I survived the memory access"
+    i32.const 1
+  )
+
+  ;; Export as "finish" as requested
+  (export "finish" (func $read_edge))
+)

src/test/app/wasm_fixtures/wat/memory_pointer_over_limit.wat

@@ -0,0 +1,23 @@
+(module
+   ;; Define 1 page of memory (64KB = 65,536 bytes)
+   (memory 1)
+
+   (func $read_overflow (result i32)
+     ;; Push the index of the FIRST invalid byte
+     ;; Memory is 0..65535, so 65536 is out of bounds.
+     i32.const 65536
+
+     ;; Load 1 byte (unsigned)
+     i32.load8_u
+
+     ;; Clean up the stack.
+     ;; The load pushed a value, but we don't care what it is.
+     drop
+
+     ;; Return 1 to signal "I survived the memory access"
+     i32.const 1
+   )
+
+   ;; Export as "finish" as requested
+   (export "finish" (func $read_overflow))
+ )

src/test/app/wasm_fixtures/wat/multi_memory.wat

@@ -0,0 +1,16 @@
+(module
+  ;; Memory 0: Index 0 (Empty)
+  (memory 0)
+
+  ;; Memory 1: Index 1 (Size 1 page)
+  ;; If multi-memory is disabled, this line causes a validation error (max 1 memory).
+  (memory 1)
+
+  (func $finish (result i32)
+    ;; Query size of Memory Index 1.
+    ;; Should return 1 (success).
+    memory.size 1
+  )
+
+  (export "finish" (func $finish))
+)

src/test/app/wasm_fixtures/wat/proposal_bulk_memory.wat

@@ -0,0 +1,25 @@
+(module
+  ;; Define 1 page of memory
+  (memory 1)
+  (export "memory" (memory 0))
+
+  (func $test_bulk_ops (result i32)
+    ;; Setup: Write value 42 at index 0 so we have something to copy
+    (i32.store8 (i32.const 0) (i32.const 42))
+
+    ;; Test memory.copy (Opcode 0xFC 0x0A)
+    ;; Copy 1 byte from offset 0 to offset 100
+    (memory.copy
+      (i32.const 100) ;; Destination Offset
+      (i32.const 0)   ;; Source Offset
+      (i32.const 1)   ;; Size (bytes)
+    )
+
+    ;; Verify: Read byte at offset 100. Should be 42.
+    (i32.load8_u (i32.const 100))
+    (i32.const 42)
+    i32.eq
+  )
+
+  (export "finish" (func $test_bulk_ops))
+)

src/test/app/wasm_fixtures/wat/proposal_extended_const.wat

@@ -0,0 +1,15 @@
+(module
+  ;; 1. Define a global using an EXTENDED constant expression.
+  ;;    MVP only allows (i32.const X).
+  ;;    This proposal allows (i32.add (i32.const X) (i32.const Y)).
+  (global $g i32 (i32.add (i32.const 10) (i32.const 32)))
+
+  (func $finish (result i32)
+    ;; 2. verify the global equals 42
+    global.get $g
+    i32.const 42
+    i32.eq
+  )
+
+  (export "finish" (func $finish))
+)

src/test/app/wasm_fixtures/wat/proposal_float_to_int.wat

@@ -0,0 +1,18 @@
+(module
+  (func $test_saturation (result i32)
+    ;; 1. Push a float that is too big for a 32-bit integer
+    ;; 1e10 (10 billion) > 2.14 billion (Max i32)
+    f32.const 1.0e10
+
+    ;; 2. Attempt saturating conversion (Opcode 0xFC 0x00)
+    ;; If supported: Clamps to MAX_I32.
+    ;; If disabled: Validation error (unknown instruction).
+    i32.trunc_sat_f32_s
+
+    ;; 3. Check if result is MAX_I32 (2147483647)
+    i32.const 2147483647
+    i32.eq
+  )
+
+  (export "finish" (func $test_saturation))
+)

src/test/app/wasm_fixtures/wat/proposal_gc_struct_new.wat

@@ -0,0 +1,12 @@
+;; generated by wasm-tools print gc_test.wasm that has the following hex
+;; 0061736d01000000010b026000017f5f027f017f0103020100070a010666696e69736800000a0a010800fb01011a41010b
+(module
+  (type (;0;) (func (result i32)))
+  (type (;1;) (struct (field (mut i32)) (field (mut i32))))
+  (export "finish" (func 0))
+  (func (;0;) (type 0) (result i32)
+    struct.new_default 1
+    drop
+    i32.const 1
+  )
+)

src/test/app/wasm_fixtures/wat/proposal_multi_value.wat

@@ -0,0 +1,22 @@
+(module
+  ;; 1. Function returning TWO values (Multi-Value feature)
+  (func $get_numbers (result i32 i32)
+    i32.const 10
+    i32.const 20
+  )
+
+  (func $finish (result i32)
+    ;; Call pushes [10, 20] onto the stack
+    call $get_numbers
+
+    ;; 2. Block taking TWO parameters (Multi-Value feature)
+    ;;    It consumes the [10, 20] from the stack.
+    block (param i32 i32) (result i32)
+      i32.add       ;; 10 + 20 = 30
+      i32.const 30  ;; Expected result
+      i32.eq        ;; Compare: returns 1 if equal
+    end
+  )
+
+  (export "finish" (func $finish))
+)

src/test/app/wasm_fixtures/wat/proposal_mutable_global.wat

@@ -0,0 +1,25 @@
+(module
+  ;; Define a mutable global initialized to 0
+  (global $counter (mut i32) (i32.const 0))
+
+  ;; EXPORTING a mutable global is the key feature of this proposal.
+  ;; In strict MVP, exported globals had to be immutable (const).
+  (export "counter" (global $counter))
+
+  (func $finish (result i32)
+    ;; 1. Get current value
+    global.get $counter
+
+    ;; 2. Add 1
+    i32.const 1
+    i32.add
+
+    ;; 3. Set new value (Mutation)
+    global.set $counter
+
+    ;; 4. Return 1 for success
+    i32.const 1
+  )
+
+  (export "finish" (func $finish))
+)

src/test/app/wasm_fixtures/wat/proposal_ref_types.wat

@@ -0,0 +1,18 @@
+(module
+  ;; Import a table from the host that holds externrefs
+  (import "env" "table" (table 1 externref))
+
+  (func $test_ref_types (result i32)
+    ;; Store a null externref into the table at index 0
+    ;; If reference_types is disabled, 'externref' and 'ref.null' will fail parsing.
+    (table.set
+      (i32.const 0)       ;; Index
+      (ref.null extern)   ;; Value (Null External Reference)
+    )
+
+    ;; Return 1 (Success)
+    i32.const 1
+  )
+
+  (export "finish" (func $test_ref_types))
+)

src/test/app/wasm_fixtures/wat/proposal_sign_ext.wat

@@ -0,0 +1,18 @@
+(module
+  (func $test_sign_ext (result i32)
+    ;; Push 255 (0x000000FF) onto the stack
+    i32.const 255
+
+    ;; Sign-extend from 8-bit to 32-bit
+    ;; If 255 is treated as an i8, it is -1.
+    ;; Result should be -1 (0xFFFFFFFF).
+    ;; Without this proposal, this opcode (0xC0) causes a validation error.
+    i32.extend8_s
+
+    ;; Check if result is -1
+    i32.const -1
+    i32.eq
+  )
+
+  (export "finish" (func $test_sign_ext))
+)

src/test/app/wasm_fixtures/wat/proposal_stringref.wat

@@ -0,0 +1 @@
+;;hard to generate

src/test/app/wasm_fixtures/wat/proposal_tail_call.wat

@@ -0,0 +1,15 @@
+(module
+  ;; Define a simple function we can tail-call
+  (func $target (result i32)
+    i32.const 1
+  )
+
+  (func $finish (result i32)
+    ;; Try to use the 'return_call' instruction (Opcode 0x12)
+    ;; If Tail Call proposal is disabled, this fails to Compile/Validate.
+    ;; If enabled, it jumps to $target, which returns 1.
+    return_call $target
+  )
+
+  (export "finish" (func $finish))
+)

src/test/app/wasm_fixtures/wat/start_loop.wat

@@ -0,0 +1,22 @@
+(module
+  ;; Function 1: The Infinite Loop
+  (func $run_forever
+    (loop $infinite
+      br $infinite
+    )
+  )
+
+  ;; Function 2: Finish
+  (func $finish (result i32)
+    i32.const 1
+  )
+
+  ;; 1. EXPORT the functions (optional, if you want to call them later)
+  (export "start" (func $run_forever))
+  (export "finish" (func $finish))
+
+  ;; 2. The special start section
+  ;; This tells the VM: "Run function $run_forever immediately
+  ;; when this module is instantiated."
+  (start $run_forever)
+)

src/test/app/wasm_fixtures/wat/table_0_elements.wat

@@ -0,0 +1,10 @@
+(module
+  ;; Define a table with exactly 0 entries
+  (table 0 funcref)
+
+  ;; Standard finish function
+  (func $finish (result i32)
+    i32.const 1
+  )
+  (export "finish" (func $finish))
+)

src/test/app/wasm_fixtures/wat/table_2_tables.wat

@@ -0,0 +1,24 @@
+(module
+  ;; Define a dummy function to put in the tables
+  (func $dummy)
+
+  ;; TABLE 0: The default table (allowed in MVP)
+  ;; Size: 1 initial, 1 max
+  (table $t0 1 1 funcref)
+
+  ;; Initialize Table 0 at index 0
+  (elem (table $t0) (i32.const 0) $dummy)
+
+  ;; TABLE 1: The second table (Requires Reference Types proposal)
+  ;; If strict MVP is enforced, the parser should error here.
+  (table $t1 1 1 funcref)
+
+  ;; Initialize Table 1 at index 0
+  (elem (table $t1) (i32.const 0) $dummy)
+
+  (func $finish (result i32)
+    ;; If we successfully loaded a module with 2 tables, return 1.
+    i32.const 1
+  )
+  (export "finish" (func $finish))
+)

src/test/app/wasm_fixtures/wat/table_64_elements.wat

@@ -0,0 +1,25 @@
+(module
+  ;; Define a table with exactly 64 entries
+  (table 64 funcref)
+
+  ;; A dummy function to reference
+  (func $dummy)
+
+  ;; Initialize the table at offset 0 with 64 references to $dummy
+  (elem (i32.const 0)
+    $dummy $dummy $dummy $dummy $dummy $dummy $dummy $dummy ;; 8
+    $dummy $dummy $dummy $dummy $dummy $dummy $dummy $dummy ;; 16
+    $dummy $dummy $dummy $dummy $dummy $dummy $dummy $dummy ;; 24
+    $dummy $dummy $dummy $dummy $dummy $dummy $dummy $dummy ;; 32
+    $dummy $dummy $dummy $dummy $dummy $dummy $dummy $dummy ;; 40
+    $dummy $dummy $dummy $dummy $dummy $dummy $dummy $dummy ;; 48
+    $dummy $dummy $dummy $dummy $dummy $dummy $dummy $dummy ;; 56
+    $dummy $dummy $dummy $dummy $dummy $dummy $dummy $dummy ;; 64
+  )
+
+  ;; Standard finish function
+  (func $finish (result i32)
+    i32.const 1
+  )
+  (export "finish" (func $finish))
+)

src/test/app/wasm_fixtures/wat/table_65_elements.wat

@@ -0,0 +1,25 @@
+(module
+  ;; Define a table with exactly 65 entries
+  (table 65 funcref)
+
+  ;; A dummy function to reference
+  (func $dummy)
+
+  ;; Initialize the table at offset 0 with 65 references to $dummy
+  (elem (i32.const 0)
+    $dummy $dummy $dummy $dummy $dummy $dummy $dummy $dummy ;; 8
+    $dummy $dummy $dummy $dummy $dummy $dummy $dummy $dummy ;; 16
+    $dummy $dummy $dummy $dummy $dummy $dummy $dummy $dummy ;; 24
+    $dummy $dummy $dummy $dummy $dummy $dummy $dummy $dummy ;; 32
+    $dummy $dummy $dummy $dummy $dummy $dummy $dummy $dummy ;; 40
+    $dummy $dummy $dummy $dummy $dummy $dummy $dummy $dummy ;; 48
+    $dummy $dummy $dummy $dummy $dummy $dummy $dummy $dummy ;; 56
+    $dummy $dummy $dummy $dummy $dummy $dummy $dummy $dummy ;; 64
+    $dummy ;; 65 (The one that breaks the camel's back)
+  )
+
+  (func $finish (result i32)
+    i32.const 1
+  )
+  (export "finish" (func $finish))
+)

src/test/app/wasm_fixtures/wat/table_uint_max.wat

@@ -0,0 +1,15 @@
+(module
+  ;; Definition: (table <min> <optional_max> <type>)
+  ;; We use 0xFFFFFFFF (4,294,967,295), which is the unsigned equivalent of -1.
+  ;; This tests if the runtime handles the maximum possible u32 value
+  ;; without integer overflows or attempting a massive allocation.
+  ;;
+  ;; Note that using -1 as the table size cannot be parsed by wasm-tools or wat2wasm
+  (table 0xFFFFFFFF funcref)
+
+  (func $finish (result i32)
+    ;; If the module loads despite the massive table, return 1.
+    i32.const 1
+  )
+  (export "finish" (func $finish))
+)

src/test/app/wasm_fixtures/wat/trap_divide_by_0.wat

@@ -0,0 +1,15 @@
+(module
+  (func $finish (export "finish") (result i32)
+    ;; Setup for Requirement 2: Divide an i32 by 0
+    i32.const 42   ;; Push numerator
+    i32.const 0    ;; Push denominator (0)
+    i32.div_s      ;; Perform signed division (42 / 0)
+
+    ;; --- NOTE: Execution usually traps (crashes) at the line above ---
+
+    ;; Logic to satisfy Requirement 1: Return i32 = 1
+    ;; If execution continued, we would drop the division result and return 1
+    drop           ;; Clear the stack
+    i32.const 1    ;; Push the return value
+  )
+)

src/test/app/wasm_fixtures/wat/trap_func_signature_mismatch.wat

@@ -0,0 +1,33 @@
+(module
+  ;; Define a table with 1 slot
+  (table 1 funcref)
+
+  ;; Define Type A: Takes nothing, returns nothing
+  (type $type_void (func))
+
+  ;; Define Type B: Takes nothing, returns i32
+  (type $type_i32 (func (result i32)))
+
+  ;; Define a function of Type A
+  (func $void_func (type $type_void)
+    nop
+  )
+
+  ;; Put Type A function into Table[0]
+  (elem (i32.const 0) $void_func)
+
+  (func $finish (result i32)
+    ;; Attempt to call Index 0, but CLAIM we expect Type B (result i32).
+    ;; The function at Index 0 matches Type A.
+    ;; TRAP: "indirect call type mismatch"
+
+    ;; 1. Push the table index (0) onto the stack
+    i32.const 0
+
+    ;; 2. Call indirect using Type B signature.
+    ;;    This pops the index (0) from the stack.
+    call_indirect (type $type_i32)
+  )
+
+  (export "finish" (func $finish))
+)

src/test/app/wasm_fixtures/wat/trap_int_overflow.wat

@@ -0,0 +1,18 @@
+(module
+  (func $test_int_overflow (result i32)
+    ;; 1. Push INT_MIN (-2147483648)
+    ;; In Hex: 0x80000000
+    i32.const -2147483648
+
+    ;; 2. Push -1
+    i32.const -1
+
+    ;; 3. Signed Division
+    ;; This specific case is the ONLY integer arithmetic operation
+    ;; (besides divide by zero) that traps in the spec.
+    ;; Result would be +2147483648, which is too big for signed i32.
+    i32.div_s
+  )
+
+  (export "finish" (func $test_int_overflow))
+)

src/test/app/wasm_fixtures/wat/trap_null_call.wat

@@ -0,0 +1,22 @@
+(module
+  ;; Table size is 1, so Index 0 is VALID bounds.
+  ;; However, we do NOT initialize it, so it contains 'ref.null'.
+  (table 1 funcref)
+
+  (type $t (func (result i32)))
+
+  (func $finish (result i32)
+    ;; Call Index 0.
+    ;; Bounds check passes (0 < 1).
+    ;; Null check fails.
+    ;; TRAP: "uninitialized element" or "undefined element"
+
+    ;; 1. Push the index (0) onto the stack first
+    i32.const 0
+
+    ;; 2. Perform the call. This pops the index.
+    call_indirect (type $t)
+  )
+
+  (export "finish" (func $finish))
+)

src/test/app/wasm_fixtures/wat/trap_unreachable.wat

@@ -0,0 +1,12 @@
+(module
+  (func $finish (result i32)
+    ;; This instruction explicitly causes a trap.
+    ;; It consumes no fuel (beyond the instruction itself) and stops execution.
+    unreachable
+
+    ;; This code is dead and never reached
+    i32.const 1
+  )
+
+  (export "finish" (func $finish))
+)

src/test/app/wasm_fixtures/wat/wasi_get_time.wat

@@ -0,0 +1,38 @@
+(module
+  ;; Import clock_time_get from WASI
+  ;; Signature: (param clock_id precision return_ptr) (result errno)
+  (import "wasi_snapshot_preview1" "clock_time_get"
+    (func $clock_time_get (param i32 i64 i32) (result i32))
+  )
+
+  (memory 1)
+  (export "memory" (memory 0))
+
+  (func $finish (result i32)
+    ;; We will store the timestamp (a 64-bit integer) at address 0.
+    ;; No setup required in memory beforehand!
+
+    ;; Call the function
+    (call $clock_time_get
+      (i32.const 0)       ;; clock_id: 0 = Realtime (Wallclock)
+      (i64.const 1000)    ;; precision: 1000ns (hint to OS)
+      (i32.const 0)       ;; result_ptr: Write the time to address 0
+    )
+
+    ;; The function returns an 'errno' (error code).
+    ;; 0 = Success. Anything else = Error.
+
+    ;; Check if errno (top of stack) is 0
+    i32.eqz
+    if (result i32)
+      ;; Success! The time is now stored in heap[0..8].
+      ;; We return 1 as requested.
+      i32.const 1
+    else
+      ;; Failed (maybe WASI is disabled or clock is missing)
+      i32.const -1
+    end
+  )
+
+  (export "finish" (func $finish))
+)

src/test/app/wasm_fixtures/wat/wasi_print.wat

@@ -0,0 +1,59 @@
+(module
+  ;; Import WASI fd_write
+  ;; Signature: (fd, iovs_ptr, iovs_len, nwritten_ptr) -> errno
+  (import "wasi_snapshot_preview1" "fd_write"
+    (func $fd_write (param i32 i32 i32 i32) (result i32))
+  )
+
+  (memory 1)
+  (export "memory" (memory 0))
+
+  ;; --- DATA SEGMENTS ---
+
+  ;; 1. The String Data "Hello\n" placed at offset 16
+  ;;    We assume offset 0-16 is reserved for the IOVec struct
+  (data (i32.const 16) "Hello\n")
+
+  ;; 2. The IO Vector (struct iovec) placed at offset 0
+  ;;    Structure: { buf_ptr: u32, buf_len: u32 }
+
+  ;;    Field 1: buf_ptr = 16 (Location of "Hello\n")
+  ;;    Encoded in little-endian: 10 00 00 00
+  (data (i32.const 0) "\10\00\00\00")
+
+  ;;    Field 2: buf_len = 6 (Length of "Hello\n")
+  ;;    Encoded in little-endian: 06 00 00 00
+  (data (i32.const 4) "\06\00\00\00")
+
+  (func $finish (result i32)
+    (local $nwritten_ptr i32)
+
+    ;; We will ask WASI to write the "number of bytes written" to address 24
+    ;; (safely after our string data)
+    i32.const 24
+    local.set $nwritten_ptr
+
+    ;; Call fd_write
+    (call $fd_write
+      (i32.const 1)       ;; fd: 1 = STDOUT
+      (i32.const 0)       ;; iovs_ptr: Address 0 (where we defined the struct)
+      (i32.const 1)       ;; iovs_len: We are passing 1 vector
+      (local.get $nwritten_ptr) ;; nwritten_ptr: Address 24
+    )
+
+    ;; The function returns an 'errno' (i32).
+    ;; 0 means Success.
+
+    ;; Check if errno == 0
+    i32.eqz
+    if (result i32)
+      ;; Success: Return 1
+      i32.const 1
+    else
+      ;; Failure: Return -1
+      i32.const -1
+    end
+  )
+
+  (export "finish" (func $finish))
+)

src/test/app/wasm_fixtures/wat/wide_arithmetic.wat

@@ -0,0 +1,22 @@
+(module
+  (func $finish (result i32)
+    ;; 1. Push operands
+    i64.const 1
+    i64.const 2
+
+    ;; 2. Execute Wide Multiplication
+    ;;    If the feature is DISABLED, the parser/validator will trap here
+    ;;    with "unknown instruction" or "invalid opcode".
+    ;;    Input: [i64, i64] -> Output: [i64, i64]
+    i64.mul_wide_u
+
+    ;; 3. Clean up the stack (drop the two i64 results)
+    drop
+    drop
+
+    ;; 4. Return 1 to signal that validation passed
+    i32.const 1
+  )
+
+  (export "finish" (func $finish))
+)

src/test/beast/beast_CurrentThreadName_test.cpp

@@ -88,20 +88,15 @@ public:
             BEAST_EXPECT(stateB == 2);
         }
 #if BOOST_OS_LINUX
-        // On Linux, verify that thread names longer than 15 characters
-        // are truncated to 15 characters (the 16th character is reserved for
-        // the null terminator).
+        // On Linux, verify that thread names within the 15 character limit
+        // are set correctly (the 16th character is reserved for the null
+        // terminator).
         {
             testName(
                 "123456789012345",
-                "123456789012345");  // 15 chars, no truncation
-            testName(
-                "1234567890123456", "123456789012345");  // 16 chars, truncated
-            testName(
-                "ThisIsAVeryLongThreadNameExceedingLimit",
-                "ThisIsAVeryLong");      // 39 chars, truncated
+                "123456789012345");      // 15 chars, maximum allowed
             testName("", "");            // empty name
-            testName("short", "short");  // short name, no truncation
+            testName("short", "short");  // short name
         }
 #endif
     }

src/test/core/Coroutine_test.cpp

@@ -56,7 +56,7 @@ public:
         gate g1, g2;
         std::shared_ptr<JobQueue::Coro> c;
         env.app().getJobQueue().postCoro(
-            jtCLIENT, "Coroutine-Test", [&](auto const& cr) {
+            jtCLIENT, "CoroTest", [&](auto const& cr) {
                 c = cr;
                 g1.signal();
                 c->yield();
@@ -83,7 +83,7 @@ public:
 
         gate g;
         env.app().getJobQueue().postCoro(
-            jtCLIENT, "Coroutine-Test", [&](auto const& c) {
+            jtCLIENT, "CoroTest", [&](auto const& c) {
                 c->post();
                 c->yield();
                 g.signal();
@@ -109,7 +109,7 @@ public:
         BEAST_EXPECT(*lv == -1);
 
         gate g;
-        jq.addJob(jtCLIENT, "LocalValue-Test", [&]() {
+        jq.addJob(jtCLIENT, "LocalValTest", [&]() {
             this->BEAST_EXPECT(*lv == -1);
             *lv = -2;
             this->BEAST_EXPECT(*lv == -2);
@@ -120,7 +120,7 @@ public:
 
         for (int i = 0; i < N; ++i)
         {
-            jq.postCoro(jtCLIENT, "Coroutine-Test", [&, id = i](auto const& c) {
+            jq.postCoro(jtCLIENT, "CoroTest", [&, id = i](auto const& c) {
                 a[id] = c;
                 g.signal();
                 c->yield();
@@ -148,7 +148,7 @@ public:
             c->join();
         }
 
-        jq.addJob(jtCLIENT, "LocalValue-Test", [&]() {
+        jq.addJob(jtCLIENT, "LocalValTest", [&]() {
             this->BEAST_EXPECT(*lv == -2);
             g.signal();
         });

src/xrpld/app/consensus/RCLConsensus.cpp

@@ -119,9 +119,7 @@ RCLConsensus::Adaptor::acquireLedger(LedgerHash const& hash)
             acquiringLedger_ = hash;
 
             app_.getJobQueue().addJob(
-                jtADVANCE,
-                "getConsensusLedger1",
-                [id = hash, &app = app_, this]() {
+                jtADVANCE, "GetConsL1", [id = hash, &app = app_, this]() {
                     JLOG(j_.debug())
                         << "JOB advanceLedger getConsensusLedger1 started";
                     app.getInboundLedgers().acquireAsync(
@@ -420,7 +418,7 @@ RCLConsensus::Adaptor::onAccept(
 {
     app_.getJobQueue().addJob(
         jtACCEPT,
-        "acceptLedger",
+        "AcceptLedger",
         [=, this, cj = std::move(consensusJson)]() mutable {
             // Note that no lock is held or acquired during this job.
             // This is because generic Consensus guarantees that once a ledger

src/xrpld/app/consensus/RCLValidations.cpp

@@ -122,13 +122,11 @@ RCLValidationsAdaptor::acquire(LedgerHash const& hash)
 
         Application* pApp = &app_;
 
-        app_.getJobQueue().addJob(
-            jtADVANCE, "getConsensusLedger2", [pApp, hash, this]() {
-                JLOG(j_.debug())
-                    << "JOB advanceLedger getConsensusLedger2 started";
-                pApp->getInboundLedgers().acquireAsync(
-                    hash, 0, InboundLedger::Reason::CONSENSUS);
-            });
+        app_.getJobQueue().addJob(jtADVANCE, "GetConsL2", [pApp, hash, this]() {
+            JLOG(j_.debug()) << "JOB advanceLedger getConsensusLedger2 started";
+            pApp->getInboundLedgers().acquireAsync(
+                hash, 0, InboundLedger::Reason::CONSENSUS);
+        });
         return std::nullopt;
     }
 

src/xrpld/app/ledger/ConsensusTransSetSF.cpp

@@ -46,7 +46,7 @@ ConsensusTransSetSF::gotNode(
                 "xrpl::ConsensusTransSetSF::gotNode : transaction hash "
                 "match");
             auto const pap = &app_;
-            app_.getJobQueue().addJob(jtTRANSACTION, "TXS->TXN", [pap, stx]() {
+            app_.getJobQueue().addJob(jtTRANSACTION, "TxsToTxn", [pap, stx]() {
                 pap->getOPs().submitTransaction(stx);
             });
         }

src/xrpld/app/ledger/OrderBookDB.cpp

@@ -48,9 +48,9 @@ OrderBookDB::setup(std::shared_ptr<ReadView const> const& ledger)
             update(ledger);
         else
             app_.getJobQueue().addJob(
-                jtUPDATE_PF,
-                "OrderBookDB::update: " + std::to_string(ledger->seq()),
-                [this, ledger]() { update(ledger); });
+                jtUPDATE_PF, "OrderBookUpd", [this, ledger]() {
+                    update(ledger);
+                });
     }
 }
 

src/xrpld/app/ledger/detail/InboundLedger.cpp

@@ -454,7 +454,7 @@ InboundLedger::done()
 
     // We hold the PeerSet lock, so must dispatch
     app_.getJobQueue().addJob(
-        jtLEDGER_DATA, "AcquisitionDone", [self = shared_from_this()]() {
+        jtLEDGER_DATA, "AcqDone", [self = shared_from_this()]() {
             if (self->complete_ && !self->failed_)
             {
                 self->app_.getLedgerMaster().checkAccept(self->getLedger());