Add tests for wasm functions with many parameters (#6343)

* Add functions with many parameters

* Add 10k locals function

* Module with  5k functions

* fix typo

Co-authored-by: Mayukha Vadari <mvadari@gmail.com>

---------

Co-authored-by: Mayukha Vadari <mvadari@gmail.com>

CMakeLists.txt

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

cmake/XrplCore.cmake

@@ -45,6 +45,7 @@ target_link_libraries(
               Xrpl::opts
               Xrpl::syslibs
               secp256k1::secp256k1
+              wasmi::wasmi
               xrpl.libpb
               xxHash::xxhash
               $<$<BOOL:${voidstar}>:antithesis-sdk-cpp>)

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.5",
         "secp256k1/0.7.1",
         "soci/4.0.3",
+        "wasmi/1.0.6",
         "zlib/1.3.1",
     ]
 
@@ -215,6 +216,7 @@ class Xrpl(ConanFile):
             "soci::soci",
             "secp256k1::secp256k1",
             "sqlite3::sqlite",
+            "wasmi::wasmi",
             "xxhash::xxhash",
             "zlib::zlib",
         ]

cspell.config.yaml

@@ -6,6 +6,8 @@ ignorePaths:
   - docs/**/*.puml
   - cmake/**
   - LICENSE.md
+  - src/test/app/wasm_fixtures/**/*.wat
+  - src/test/app/wasm_fixtures/*.c
 language: en
 allowCompoundWords: true # TODO (#6334)
 ignoreRandomStrings: true
@@ -59,6 +61,7 @@ words:
   - Britto
   - Btrfs
   - canonicality
+  - cdylib
   - changespq
   - checkme
   - choco
@@ -287,6 +290,7 @@ words:
   - venv
   - vfalco
   - vinnie
+  - wasmi
   - wextra
   - wptr
   - writeme

include/xrpl/basics/Number.h

@@ -716,6 +716,10 @@ abs(Number x) noexcept
 Number
 power(Number const& f, unsigned n);
 
+// logarithm with base 10
+Number
+log10(Number const& value, int iterations = 50);
+
 // 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

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

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

@@ -925,6 +925,73 @@ power(Number const& f, unsigned n)
     return r;
 }
 
+// Series expansion method approximation of ln(x)
+static Number
+ln(Number const& x, int iterations = 50)
+{
+    static Number const N0(0);
+    static Number const N2(2, 0);
+    static Number const N05(5, -1);
+    static Number const LN2(693'147'180'559'945'309ll, -18);
+
+    if (x <= 0)
+        throw std::runtime_error("Not a positive value");
+    else if (x == 1)
+        return N0;
+
+    int exponent = 0;
+    Number mantissa = x;
+
+    while (mantissa >= N2)
+    {
+        mantissa /= 2;
+        exponent += 1;
+    }
+    while (mantissa < N05)
+    {
+        mantissa *= 2;
+        exponent -= 1;
+    }
+
+    Number z = (mantissa - 1) / (mantissa + 1);
+    Number const zz = z * z;
+    Number sum;
+
+    for (int i = 1; i <= iterations; ++i)
+    {
+        sum = sum + z / (2 * i - 1);
+        z = z * zz;
+    }
+
+    return 2 * sum + exponent * LN2;
+}
+
+Number
+log10(Number const& x, int iterations)
+{
+    static Number const N0(0);
+    static Number const LN10(2'302'585'092'994'046ll, -15);
+
+    if (x <= 0)
+        throw std::runtime_error("Not a positive value");
+    else if (x == 1)
+        return N0;
+
+    if (x <= Number(10))
+    {
+        auto const r = ln(x, iterations) / LN10;
+        return r;
+    }
+
+    // (1 <= normalX < 10)
+    // ln(x) = ln(normalX * 10^norm) = ln(normalX) + norm * ln(10)
+    int diffExp = 15 + x.exponent();
+    Number const normalX = x / Number(1, diffExp);
+    auto const lnX = ln(normalX, iterations) + diffExp * LN10;
+    auto const lgX = lnX / LN10;
+    return lgX;
+}
+
 // 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/protocol/TER.cpp

@@ -198,6 +198,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?branch=u32-buffer#1e5d096f46742ef7fcf1cb6f28a2526a72ed59d8"
+dependencies = [
+ "bs58",
+ "quote",
+ "sha2",
+ "syn",
+]
+
+[[package]]
+name = "xrpl-wasm-stdlib"
+version = "0.7.1"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git?branch=u32-buffer#1e5d096f46742ef7fcf1cb6f28a2526a72ed59d8"
+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", branch = "u32-buffer" }
+
+[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,783 @@
+#![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 mut sqn_buffer = [0u8; 4];
+    let sqn_result = unsafe { host::get_ledger_sqn(sqn_buffer.as_mut_ptr(), sqn_buffer.len()) };
+
+    if sqn_result <= 0 {
+        let _ = trace_num("ERROR: get_ledger_sqn failed:", sqn_result as i64);
+        return -101; // Ledger sequence number test failed
+    }
+    let ledger_sqn = u32::from_be_bytes(sqn_buffer);
+    let _ = trace_num("Ledger sequence number:", ledger_sqn as i64);
+
+    // Test 1.2: get_parent_ledger_time() - should return parent ledger timestamp
+    let mut time_buffer = [0u8; 4];
+    let time_result =
+        unsafe { host::get_parent_ledger_time(time_buffer.as_mut_ptr(), time_buffer.len()) };
+
+    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 parent_ledger_time = u32::from_be_bytes(time_buffer);
+    let _ = trace_num("Parent ledger time:", parent_ledger_time 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 sequence_number: i32 = 1000;
+    let sequence_number_bytes = sequence_number.to_be_bytes();
+    let escrow_keylet_result = unsafe {
+        host::escrow_keylet(
+            account_id.0.as_ptr(),
+            account_id.0.len(),
+            sequence_number_bytes.as_ptr(),
+            sequence_number_bytes.len(),
+            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 document_id: i32 = 42;
+    let document_id_bytes = document_id.to_be_bytes();
+    let oracle_keylet_result = unsafe {
+        host::oracle_keylet(
+            account_id.0.as_ptr(),
+            account_id.0.len(),
+            document_id_bytes.as_ptr(),
+            document_id_bytes.len(),
+            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?branch=u32-buffer#1e5d096f46742ef7fcf1cb6f28a2526a72ed59d8"
+dependencies = [
+ "bs58",
+ "quote",
+ "sha2",
+ "syn",
+]
+
+[[package]]
+name = "xrpl-wasm-stdlib"
+version = "0.7.1"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git?branch=u32-buffer#1e5d096f46742ef7fcf1cb6f28a2526a72ed59d8"
+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", branch = "u32-buffer" }
+
+[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,72 @@
+#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,47 @@
+#include <stdint.h>
+
+int32_t
+float_from_uint(uint8_t const*, int32_t, uint8_t*, int32_t, int32_t);
+int32_t
+check_keylet(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+
+uint8_t e_data1[32 * 1024];
+uint8_t e_data2[32 * 1024];
+
+int32_t
+test1()
+{
+    e_data1[1] = 0xFF;
+    e_data1[2] = 0xFF;
+    e_data1[3] = 0xFF;
+    e_data1[4] = 0xFF;
+    e_data1[5] = 0xFF;
+    e_data1[6] = 0xFF;
+    e_data1[7] = 0xFF;
+    e_data1[8] = 0xFF;
+    int32_t result = float_from_uint(&e_data1[1], 8, &e_data1[35], 12, 0);
+    return result >= 0 ? *((int32_t*)(&e_data1[36])) : result;
+}
+
+int32_t
+test2()
+{
+    // Set up misaligned uint32 (seq) at offset 1
+    e_data2[1] = 0xFF;
+    e_data2[2] = 0xFF;
+    e_data2[3] = 0xFF;
+    e_data2[4] = 0xFF;
+    // Set up valid non-zero AccountID (20 bytes) at offset 10
+    for (int i = 0; i < 20; i++)
+        e_data2[10 + i] = i + 1;
+    // Call check_keylet with misaligned uint32 at &e_data2[1] to hit line 72 in HostFuncWrapper.cpp
+    int32_t result = check_keylet(&e_data2[10], 20, &e_data2[1], 4, &e_data2[35], 32);
+    // Return the misaligned value directly to validate it was read correctly (-1 if all 0xFF)
+    return result >= 0 ? *((int32_t*)(&e_data2[36])) : result;
+}
+
+int32_t
+test()
+{
+    return test1() + test2();
+}

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?branch=u32-buffer#1e5d096f46742ef7fcf1cb6f28a2526a72ed59d8"
+dependencies = [
+ "bs58",
+ "quote",
+ "sha2",
+ "syn",
+]
+
+[[package]]
+name = "xrpl-wasm-stdlib"
+version = "0.7.1"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git?branch=u32-buffer#1e5d096f46742ef7fcf1cb6f28a2526a72ed59d8"
+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", branch = "u32-buffer" }

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,125 @@
+# cspell: disable
+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:
+        subprocess.run(build_cmd, shell=True, check=True)
+        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:
+        subprocess.run(build_cmd, shell=True, check=True)
+        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,92 @@
+#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 badAlignWasmHex;
+
+extern std::string const thousandParamsHex;
+extern std::string const thousand1ParamsHex;
+extern std::string const locals10kHex;
+extern std::string const functions5kHex;

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?branch=u32-buffer#1e5d096f46742ef7fcf1cb6f28a2526a72ed59d8"
+dependencies = [
+ "bs58",
+ "quote",
+ "sha2",
+ "syn",
+]
+
+[[package]]
+name = "xrpl-wasm-stdlib"
+version = "0.7.1"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git?branch=u32-buffer#1e5d096f46742ef7fcf1cb6f28a2526a72ed59d8"
+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", branch = "u32-buffer" }
+
+[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,16 @@
+#include <stdint.h>
+
+int32_t
+get_ledger_sqn(uint8_t*, int32_t);
+
+int
+finish()
+{
+    uint32_t sqn;
+    int32_t result = get_ledger_sqn((uint8_t*)&sqn, sizeof(sqn));
+
+    if (result < 0)
+        return result;
+
+    return sqn >= 5 ? 5 : 0;
+}

src/test/app/wasm_fixtures/sha512Pure.c

@@ -0,0 +1,133 @@
+#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/thousand1_params.c

@@ -0,0 +1,264 @@
+// clang-format off
+
+#include <stdint.h>
+
+int32_t test(
+  int32_t p0, int32_t p1, int32_t p2, int32_t p3, int32_t p4, int32_t p5, int32_t p6, int32_t p7
+, int32_t p8, int32_t p9, int32_t p10, int32_t p11, int32_t p12, int32_t p13, int32_t p14, int32_t p15
+, int32_t p16, int32_t p17, int32_t p18, int32_t p19, int32_t p20, int32_t p21, int32_t p22, int32_t p23
+, int32_t p24, int32_t p25, int32_t p26, int32_t p27, int32_t p28, int32_t p29, int32_t p30, int32_t p31
+, int32_t p32, int32_t p33, int32_t p34, int32_t p35, int32_t p36, int32_t p37, int32_t p38, int32_t p39
+, int32_t p40, int32_t p41, int32_t p42, int32_t p43, int32_t p44, int32_t p45, int32_t p46, int32_t p47
+, int32_t p48, int32_t p49, int32_t p50, int32_t p51, int32_t p52, int32_t p53, int32_t p54, int32_t p55
+, int32_t p56, int32_t p57, int32_t p58, int32_t p59, int32_t p60, int32_t p61, int32_t p62, int32_t p63
+, int32_t p64, int32_t p65, int32_t p66, int32_t p67, int32_t p68, int32_t p69, int32_t p70, int32_t p71
+, int32_t p72, int32_t p73, int32_t p74, int32_t p75, int32_t p76, int32_t p77, int32_t p78, int32_t p79
+, int32_t p80, int32_t p81, int32_t p82, int32_t p83, int32_t p84, int32_t p85, int32_t p86, int32_t p87
+, int32_t p88, int32_t p89, int32_t p90, int32_t p91, int32_t p92, int32_t p93, int32_t p94, int32_t p95
+, int32_t p96, int32_t p97, int32_t p98, int32_t p99, int32_t p100, int32_t p101, int32_t p102, int32_t p103
+, int32_t p104, int32_t p105, int32_t p106, int32_t p107, int32_t p108, int32_t p109, int32_t p110, int32_t p111
+, int32_t p112, int32_t p113, int32_t p114, int32_t p115, int32_t p116, int32_t p117, int32_t p118, int32_t p119
+, int32_t p120, int32_t p121, int32_t p122, int32_t p123, int32_t p124, int32_t p125, int32_t p126, int32_t p127
+, int32_t p128, int32_t p129, int32_t p130, int32_t p131, int32_t p132, int32_t p133, int32_t p134, int32_t p135
+, int32_t p136, int32_t p137, int32_t p138, int32_t p139, int32_t p140, int32_t p141, int32_t p142, int32_t p143
+, int32_t p144, int32_t p145, int32_t p146, int32_t p147, int32_t p148, int32_t p149, int32_t p150, int32_t p151
+, int32_t p152, int32_t p153, int32_t p154, int32_t p155, int32_t p156, int32_t p157, int32_t p158, int32_t p159
+, int32_t p160, int32_t p161, int32_t p162, int32_t p163, int32_t p164, int32_t p165, int32_t p166, int32_t p167
+, int32_t p168, int32_t p169, int32_t p170, int32_t p171, int32_t p172, int32_t p173, int32_t p174, int32_t p175
+, int32_t p176, int32_t p177, int32_t p178, int32_t p179, int32_t p180, int32_t p181, int32_t p182, int32_t p183
+, int32_t p184, int32_t p185, int32_t p186, int32_t p187, int32_t p188, int32_t p189, int32_t p190, int32_t p191
+, int32_t p192, int32_t p193, int32_t p194, int32_t p195, int32_t p196, int32_t p197, int32_t p198, int32_t p199
+, int32_t p200, int32_t p201, int32_t p202, int32_t p203, int32_t p204, int32_t p205, int32_t p206, int32_t p207
+, int32_t p208, int32_t p209, int32_t p210, int32_t p211, int32_t p212, int32_t p213, int32_t p214, int32_t p215
+, int32_t p216, int32_t p217, int32_t p218, int32_t p219, int32_t p220, int32_t p221, int32_t p222, int32_t p223
+, int32_t p224, int32_t p225, int32_t p226, int32_t p227, int32_t p228, int32_t p229, int32_t p230, int32_t p231
+, int32_t p232, int32_t p233, int32_t p234, int32_t p235, int32_t p236, int32_t p237, int32_t p238, int32_t p239
+, int32_t p240, int32_t p241, int32_t p242, int32_t p243, int32_t p244, int32_t p245, int32_t p246, int32_t p247
+, int32_t p248, int32_t p249, int32_t p250, int32_t p251, int32_t p252, int32_t p253, int32_t p254, int32_t p255
+, int32_t p256, int32_t p257, int32_t p258, int32_t p259, int32_t p260, int32_t p261, int32_t p262, int32_t p263
+, int32_t p264, int32_t p265, int32_t p266, int32_t p267, int32_t p268, int32_t p269, int32_t p270, int32_t p271
+, int32_t p272, int32_t p273, int32_t p274, int32_t p275, int32_t p276, int32_t p277, int32_t p278, int32_t p279
+, int32_t p280, int32_t p281, int32_t p282, int32_t p283, int32_t p284, int32_t p285, int32_t p286, int32_t p287
+, int32_t p288, int32_t p289, int32_t p290, int32_t p291, int32_t p292, int32_t p293, int32_t p294, int32_t p295
+, int32_t p296, int32_t p297, int32_t p298, int32_t p299, int32_t p300, int32_t p301, int32_t p302, int32_t p303
+, int32_t p304, int32_t p305, int32_t p306, int32_t p307, int32_t p308, int32_t p309, int32_t p310, int32_t p311
+, int32_t p312, int32_t p313, int32_t p314, int32_t p315, int32_t p316, int32_t p317, int32_t p318, int32_t p319
+, int32_t p320, int32_t p321, int32_t p322, int32_t p323, int32_t p324, int32_t p325, int32_t p326, int32_t p327
+, int32_t p328, int32_t p329, int32_t p330, int32_t p331, int32_t p332, int32_t p333, int32_t p334, int32_t p335
+, int32_t p336, int32_t p337, int32_t p338, int32_t p339, int32_t p340, int32_t p341, int32_t p342, int32_t p343
+, int32_t p344, int32_t p345, int32_t p346, int32_t p347, int32_t p348, int32_t p349, int32_t p350, int32_t p351
+, int32_t p352, int32_t p353, int32_t p354, int32_t p355, int32_t p356, int32_t p357, int32_t p358, int32_t p359
+, int32_t p360, int32_t p361, int32_t p362, int32_t p363, int32_t p364, int32_t p365, int32_t p366, int32_t p367
+, int32_t p368, int32_t p369, int32_t p370, int32_t p371, int32_t p372, int32_t p373, int32_t p374, int32_t p375
+, int32_t p376, int32_t p377, int32_t p378, int32_t p379, int32_t p380, int32_t p381, int32_t p382, int32_t p383
+, int32_t p384, int32_t p385, int32_t p386, int32_t p387, int32_t p388, int32_t p389, int32_t p390, int32_t p391
+, int32_t p392, int32_t p393, int32_t p394, int32_t p395, int32_t p396, int32_t p397, int32_t p398, int32_t p399
+, int32_t p400, int32_t p401, int32_t p402, int32_t p403, int32_t p404, int32_t p405, int32_t p406, int32_t p407
+, int32_t p408, int32_t p409, int32_t p410, int32_t p411, int32_t p412, int32_t p413, int32_t p414, int32_t p415
+, int32_t p416, int32_t p417, int32_t p418, int32_t p419, int32_t p420, int32_t p421, int32_t p422, int32_t p423
+, int32_t p424, int32_t p425, int32_t p426, int32_t p427, int32_t p428, int32_t p429, int32_t p430, int32_t p431
+, int32_t p432, int32_t p433, int32_t p434, int32_t p435, int32_t p436, int32_t p437, int32_t p438, int32_t p439
+, int32_t p440, int32_t p441, int32_t p442, int32_t p443, int32_t p444, int32_t p445, int32_t p446, int32_t p447
+, int32_t p448, int32_t p449, int32_t p450, int32_t p451, int32_t p452, int32_t p453, int32_t p454, int32_t p455
+, int32_t p456, int32_t p457, int32_t p458, int32_t p459, int32_t p460, int32_t p461, int32_t p462, int32_t p463
+, int32_t p464, int32_t p465, int32_t p466, int32_t p467, int32_t p468, int32_t p469, int32_t p470, int32_t p471
+, int32_t p472, int32_t p473, int32_t p474, int32_t p475, int32_t p476, int32_t p477, int32_t p478, int32_t p479
+, int32_t p480, int32_t p481, int32_t p482, int32_t p483, int32_t p484, int32_t p485, int32_t p486, int32_t p487
+, int32_t p488, int32_t p489, int32_t p490, int32_t p491, int32_t p492, int32_t p493, int32_t p494, int32_t p495
+, int32_t p496, int32_t p497, int32_t p498, int32_t p499, int32_t p500, int32_t p501, int32_t p502, int32_t p503
+, int32_t p504, int32_t p505, int32_t p506, int32_t p507, int32_t p508, int32_t p509, int32_t p510, int32_t p511
+, int32_t p512, int32_t p513, int32_t p514, int32_t p515, int32_t p516, int32_t p517, int32_t p518, int32_t p519
+, int32_t p520, int32_t p521, int32_t p522, int32_t p523, int32_t p524, int32_t p525, int32_t p526, int32_t p527
+, int32_t p528, int32_t p529, int32_t p530, int32_t p531, int32_t p532, int32_t p533, int32_t p534, int32_t p535
+, int32_t p536, int32_t p537, int32_t p538, int32_t p539, int32_t p540, int32_t p541, int32_t p542, int32_t p543
+, int32_t p544, int32_t p545, int32_t p546, int32_t p547, int32_t p548, int32_t p549, int32_t p550, int32_t p551
+, int32_t p552, int32_t p553, int32_t p554, int32_t p555, int32_t p556, int32_t p557, int32_t p558, int32_t p559
+, int32_t p560, int32_t p561, int32_t p562, int32_t p563, int32_t p564, int32_t p565, int32_t p566, int32_t p567
+, int32_t p568, int32_t p569, int32_t p570, int32_t p571, int32_t p572, int32_t p573, int32_t p574, int32_t p575
+, int32_t p576, int32_t p577, int32_t p578, int32_t p579, int32_t p580, int32_t p581, int32_t p582, int32_t p583
+, int32_t p584, int32_t p585, int32_t p586, int32_t p587, int32_t p588, int32_t p589, int32_t p590, int32_t p591
+, int32_t p592, int32_t p593, int32_t p594, int32_t p595, int32_t p596, int32_t p597, int32_t p598, int32_t p599
+, int32_t p600, int32_t p601, int32_t p602, int32_t p603, int32_t p604, int32_t p605, int32_t p606, int32_t p607
+, int32_t p608, int32_t p609, int32_t p610, int32_t p611, int32_t p612, int32_t p613, int32_t p614, int32_t p615
+, int32_t p616, int32_t p617, int32_t p618, int32_t p619, int32_t p620, int32_t p621, int32_t p622, int32_t p623
+, int32_t p624, int32_t p625, int32_t p626, int32_t p627, int32_t p628, int32_t p629, int32_t p630, int32_t p631
+, int32_t p632, int32_t p633, int32_t p634, int32_t p635, int32_t p636, int32_t p637, int32_t p638, int32_t p639
+, int32_t p640, int32_t p641, int32_t p642, int32_t p643, int32_t p644, int32_t p645, int32_t p646, int32_t p647
+, int32_t p648, int32_t p649, int32_t p650, int32_t p651, int32_t p652, int32_t p653, int32_t p654, int32_t p655
+, int32_t p656, int32_t p657, int32_t p658, int32_t p659, int32_t p660, int32_t p661, int32_t p662, int32_t p663
+, int32_t p664, int32_t p665, int32_t p666, int32_t p667, int32_t p668, int32_t p669, int32_t p670, int32_t p671
+, int32_t p672, int32_t p673, int32_t p674, int32_t p675, int32_t p676, int32_t p677, int32_t p678, int32_t p679
+, int32_t p680, int32_t p681, int32_t p682, int32_t p683, int32_t p684, int32_t p685, int32_t p686, int32_t p687
+, int32_t p688, int32_t p689, int32_t p690, int32_t p691, int32_t p692, int32_t p693, int32_t p694, int32_t p695
+, int32_t p696, int32_t p697, int32_t p698, int32_t p699, int32_t p700, int32_t p701, int32_t p702, int32_t p703
+, int32_t p704, int32_t p705, int32_t p706, int32_t p707, int32_t p708, int32_t p709, int32_t p710, int32_t p711
+, int32_t p712, int32_t p713, int32_t p714, int32_t p715, int32_t p716, int32_t p717, int32_t p718, int32_t p719
+, int32_t p720, int32_t p721, int32_t p722, int32_t p723, int32_t p724, int32_t p725, int32_t p726, int32_t p727
+, int32_t p728, int32_t p729, int32_t p730, int32_t p731, int32_t p732, int32_t p733, int32_t p734, int32_t p735
+, int32_t p736, int32_t p737, int32_t p738, int32_t p739, int32_t p740, int32_t p741, int32_t p742, int32_t p743
+, int32_t p744, int32_t p745, int32_t p746, int32_t p747, int32_t p748, int32_t p749, int32_t p750, int32_t p751
+, int32_t p752, int32_t p753, int32_t p754, int32_t p755, int32_t p756, int32_t p757, int32_t p758, int32_t p759
+, int32_t p760, int32_t p761, int32_t p762, int32_t p763, int32_t p764, int32_t p765, int32_t p766, int32_t p767
+, int32_t p768, int32_t p769, int32_t p770, int32_t p771, int32_t p772, int32_t p773, int32_t p774, int32_t p775
+, int32_t p776, int32_t p777, int32_t p778, int32_t p779, int32_t p780, int32_t p781, int32_t p782, int32_t p783
+, int32_t p784, int32_t p785, int32_t p786, int32_t p787, int32_t p788, int32_t p789, int32_t p790, int32_t p791
+, int32_t p792, int32_t p793, int32_t p794, int32_t p795, int32_t p796, int32_t p797, int32_t p798, int32_t p799
+, int32_t p800, int32_t p801, int32_t p802, int32_t p803, int32_t p804, int32_t p805, int32_t p806, int32_t p807
+, int32_t p808, int32_t p809, int32_t p810, int32_t p811, int32_t p812, int32_t p813, int32_t p814, int32_t p815
+, int32_t p816, int32_t p817, int32_t p818, int32_t p819, int32_t p820, int32_t p821, int32_t p822, int32_t p823
+, int32_t p824, int32_t p825, int32_t p826, int32_t p827, int32_t p828, int32_t p829, int32_t p830, int32_t p831
+, int32_t p832, int32_t p833, int32_t p834, int32_t p835, int32_t p836, int32_t p837, int32_t p838, int32_t p839
+, int32_t p840, int32_t p841, int32_t p842, int32_t p843, int32_t p844, int32_t p845, int32_t p846, int32_t p847
+, int32_t p848, int32_t p849, int32_t p850, int32_t p851, int32_t p852, int32_t p853, int32_t p854, int32_t p855
+, int32_t p856, int32_t p857, int32_t p858, int32_t p859, int32_t p860, int32_t p861, int32_t p862, int32_t p863
+, int32_t p864, int32_t p865, int32_t p866, int32_t p867, int32_t p868, int32_t p869, int32_t p870, int32_t p871
+, int32_t p872, int32_t p873, int32_t p874, int32_t p875, int32_t p876, int32_t p877, int32_t p878, int32_t p879
+, int32_t p880, int32_t p881, int32_t p882, int32_t p883, int32_t p884, int32_t p885, int32_t p886, int32_t p887
+, int32_t p888, int32_t p889, int32_t p890, int32_t p891, int32_t p892, int32_t p893, int32_t p894, int32_t p895
+, int32_t p896, int32_t p897, int32_t p898, int32_t p899, int32_t p900, int32_t p901, int32_t p902, int32_t p903
+, int32_t p904, int32_t p905, int32_t p906, int32_t p907, int32_t p908, int32_t p909, int32_t p910, int32_t p911
+, int32_t p912, int32_t p913, int32_t p914, int32_t p915, int32_t p916, int32_t p917, int32_t p918, int32_t p919
+, int32_t p920, int32_t p921, int32_t p922, int32_t p923, int32_t p924, int32_t p925, int32_t p926, int32_t p927
+, int32_t p928, int32_t p929, int32_t p930, int32_t p931, int32_t p932, int32_t p933, int32_t p934, int32_t p935
+, int32_t p936, int32_t p937, int32_t p938, int32_t p939, int32_t p940, int32_t p941, int32_t p942, int32_t p943
+, int32_t p944, int32_t p945, int32_t p946, int32_t p947, int32_t p948, int32_t p949, int32_t p950, int32_t p951
+, int32_t p952, int32_t p953, int32_t p954, int32_t p955, int32_t p956, int32_t p957, int32_t p958, int32_t p959
+, int32_t p960, int32_t p961, int32_t p962, int32_t p963, int32_t p964, int32_t p965, int32_t p966, int32_t p967
+, int32_t p968, int32_t p969, int32_t p970, int32_t p971, int32_t p972, int32_t p973, int32_t p974, int32_t p975
+, int32_t p976, int32_t p977, int32_t p978, int32_t p979, int32_t p980, int32_t p981, int32_t p982, int32_t p983
+, int32_t p984, int32_t p985, int32_t p986, int32_t p987, int32_t p988, int32_t p989, int32_t p990, int32_t p991
+, int32_t p992, int32_t p993, int32_t p994, int32_t p995, int32_t p996, int32_t p997, int32_t p998, int32_t p999
+, int32_t p1000
+)
+{
+    int32_t x;
+    x = p0 + p1 + p2 + p3 + p4 + p5 + p6 + p7
+ + p8 + p9 + p10 + p11 + p12 + p13 + p14 + p15
+ + p16 + p17 + p18 + p19 + p20 + p21 + p22 + p23
+ + p24 + p25 + p26 + p27 + p28 + p29 + p30 + p31
+ + p32 + p33 + p34 + p35 + p36 + p37 + p38 + p39
+ + p40 + p41 + p42 + p43 + p44 + p45 + p46 + p47
+ + p48 + p49 + p50 + p51 + p52 + p53 + p54 + p55
+ + p56 + p57 + p58 + p59 + p60 + p61 + p62 + p63
+ + p64 + p65 + p66 + p67 + p68 + p69 + p70 + p71
+ + p72 + p73 + p74 + p75 + p76 + p77 + p78 + p79
+ + p80 + p81 + p82 + p83 + p84 + p85 + p86 + p87
+ + p88 + p89 + p90 + p91 + p92 + p93 + p94 + p95
+ + p96 + p97 + p98 + p99 + p100 + p101 + p102 + p103
+ + p104 + p105 + p106 + p107 + p108 + p109 + p110 + p111
+ + p112 + p113 + p114 + p115 + p116 + p117 + p118 + p119
+ + p120 + p121 + p122 + p123 + p124 + p125 + p126 + p127
+ + p128 + p129 + p130 + p131 + p132 + p133 + p134 + p135
+ + p136 + p137 + p138 + p139 + p140 + p141 + p142 + p143
+ + p144 + p145 + p146 + p147 + p148 + p149 + p150 + p151
+ + p152 + p153 + p154 + p155 + p156 + p157 + p158 + p159
+ + p160 + p161 + p162 + p163 + p164 + p165 + p166 + p167
+ + p168 + p169 + p170 + p171 + p172 + p173 + p174 + p175
+ + p176 + p177 + p178 + p179 + p180 + p181 + p182 + p183
+ + p184 + p185 + p186 + p187 + p188 + p189 + p190 + p191
+ + p192 + p193 + p194 + p195 + p196 + p197 + p198 + p199
+ + p200 + p201 + p202 + p203 + p204 + p205 + p206 + p207
+ + p208 + p209 + p210 + p211 + p212 + p213 + p214 + p215
+ + p216 + p217 + p218 + p219 + p220 + p221 + p222 + p223
+ + p224 + p225 + p226 + p227 + p228 + p229 + p230 + p231
+ + p232 + p233 + p234 + p235 + p236 + p237 + p238 + p239
+ + p240 + p241 + p242 + p243 + p244 + p245 + p246 + p247
+ + p248 + p249 + p250 + p251 + p252 + p253 + p254 + p255
+ + p256 + p257 + p258 + p259 + p260 + p261 + p262 + p263
+ + p264 + p265 + p266 + p267 + p268 + p269 + p270 + p271
+ + p272 + p273 + p274 + p275 + p276 + p277 + p278 + p279
+ + p280 + p281 + p282 + p283 + p284 + p285 + p286 + p287
+ + p288 + p289 + p290 + p291 + p292 + p293 + p294 + p295
+ + p296 + p297 + p298 + p299 + p300 + p301 + p302 + p303
+ + p304 + p305 + p306 + p307 + p308 + p309 + p310 + p311
+ + p312 + p313 + p314 + p315 + p316 + p317 + p318 + p319
+ + p320 + p321 + p322 + p323 + p324 + p325 + p326 + p327
+ + p328 + p329 + p330 + p331 + p332 + p333 + p334 + p335
+ + p336 + p337 + p338 + p339 + p340 + p341 + p342 + p343
+ + p344 + p345 + p346 + p347 + p348 + p349 + p350 + p351
+ + p352 + p353 + p354 + p355 + p356 + p357 + p358 + p359
+ + p360 + p361 + p362 + p363 + p364 + p365 + p366 + p367
+ + p368 + p369 + p370 + p371 + p372 + p373 + p374 + p375
+ + p376 + p377 + p378 + p379 + p380 + p381 + p382 + p383
+ + p384 + p385 + p386 + p387 + p388 + p389 + p390 + p391
+ + p392 + p393 + p394 + p395 + p396 + p397 + p398 + p399
+ + p400 + p401 + p402 + p403 + p404 + p405 + p406 + p407
+ + p408 + p409 + p410 + p411 + p412 + p413 + p414 + p415
+ + p416 + p417 + p418 + p419 + p420 + p421 + p422 + p423
+ + p424 + p425 + p426 + p427 + p428 + p429 + p430 + p431
+ + p432 + p433 + p434 + p435 + p436 + p437 + p438 + p439
+ + p440 + p441 + p442 + p443 + p444 + p445 + p446 + p447
+ + p448 + p449 + p450 + p451 + p452 + p453 + p454 + p455
+ + p456 + p457 + p458 + p459 + p460 + p461 + p462 + p463
+ + p464 + p465 + p466 + p467 + p468 + p469 + p470 + p471
+ + p472 + p473 + p474 + p475 + p476 + p477 + p478 + p479
+ + p480 + p481 + p482 + p483 + p484 + p485 + p486 + p487
+ + p488 + p489 + p490 + p491 + p492 + p493 + p494 + p495
+ + p496 + p497 + p498 + p499 + p500 + p501 + p502 + p503
+ + p504 + p505 + p506 + p507 + p508 + p509 + p510 + p511
+ + p512 + p513 + p514 + p515 + p516 + p517 + p518 + p519
+ + p520 + p521 + p522 + p523 + p524 + p525 + p526 + p527
+ + p528 + p529 + p530 + p531 + p532 + p533 + p534 + p535
+ + p536 + p537 + p538 + p539 + p540 + p541 + p542 + p543
+ + p544 + p545 + p546 + p547 + p548 + p549 + p550 + p551
+ + p552 + p553 + p554 + p555 + p556 + p557 + p558 + p559
+ + p560 + p561 + p562 + p563 + p564 + p565 + p566 + p567
+ + p568 + p569 + p570 + p571 + p572 + p573 + p574 + p575
+ + p576 + p577 + p578 + p579 + p580 + p581 + p582 + p583
+ + p584 + p585 + p586 + p587 + p588 + p589 + p590 + p591
+ + p592 + p593 + p594 + p595 + p596 + p597 + p598 + p599
+ + p600 + p601 + p602 + p603 + p604 + p605 + p606 + p607
+ + p608 + p609 + p610 + p611 + p612 + p613 + p614 + p615
+ + p616 + p617 + p618 + p619 + p620 + p621 + p622 + p623
+ + p624 + p625 + p626 + p627 + p628 + p629 + p630 + p631
+ + p632 + p633 + p634 + p635 + p636 + p637 + p638 + p639
+ + p640 + p641 + p642 + p643 + p644 + p645 + p646 + p647
+ + p648 + p649 + p650 + p651 + p652 + p653 + p654 + p655
+ + p656 + p657 + p658 + p659 + p660 + p661 + p662 + p663
+ + p664 + p665 + p666 + p667 + p668 + p669 + p670 + p671
+ + p672 + p673 + p674 + p675 + p676 + p677 + p678 + p679
+ + p680 + p681 + p682 + p683 + p684 + p685 + p686 + p687
+ + p688 + p689 + p690 + p691 + p692 + p693 + p694 + p695
+ + p696 + p697 + p698 + p699 + p700 + p701 + p702 + p703
+ + p704 + p705 + p706 + p707 + p708 + p709 + p710 + p711
+ + p712 + p713 + p714 + p715 + p716 + p717 + p718 + p719
+ + p720 + p721 + p722 + p723 + p724 + p725 + p726 + p727
+ + p728 + p729 + p730 + p731 + p732 + p733 + p734 + p735
+ + p736 + p737 + p738 + p739 + p740 + p741 + p742 + p743
+ + p744 + p745 + p746 + p747 + p748 + p749 + p750 + p751
+ + p752 + p753 + p754 + p755 + p756 + p757 + p758 + p759
+ + p760 + p761 + p762 + p763 + p764 + p765 + p766 + p767
+ + p768 + p769 + p770 + p771 + p772 + p773 + p774 + p775
+ + p776 + p777 + p778 + p779 + p780 + p781 + p782 + p783
+ + p784 + p785 + p786 + p787 + p788 + p789 + p790 + p791
+ + p792 + p793 + p794 + p795 + p796 + p797 + p798 + p799
+ + p800 + p801 + p802 + p803 + p804 + p805 + p806 + p807
+ + p808 + p809 + p810 + p811 + p812 + p813 + p814 + p815
+ + p816 + p817 + p818 + p819 + p820 + p821 + p822 + p823
+ + p824 + p825 + p826 + p827 + p828 + p829 + p830 + p831
+ + p832 + p833 + p834 + p835 + p836 + p837 + p838 + p839
+ + p840 + p841 + p842 + p843 + p844 + p845 + p846 + p847
+ + p848 + p849 + p850 + p851 + p852 + p853 + p854 + p855
+ + p856 + p857 + p858 + p859 + p860 + p861 + p862 + p863
+ + p864 + p865 + p866 + p867 + p868 + p869 + p870 + p871
+ + p872 + p873 + p874 + p875 + p876 + p877 + p878 + p879
+ + p880 + p881 + p882 + p883 + p884 + p885 + p886 + p887
+ + p888 + p889 + p890 + p891 + p892 + p893 + p894 + p895
+ + p896 + p897 + p898 + p899 + p900 + p901 + p902 + p903
+ + p904 + p905 + p906 + p907 + p908 + p909 + p910 + p911
+ + p912 + p913 + p914 + p915 + p916 + p917 + p918 + p919
+ + p920 + p921 + p922 + p923 + p924 + p925 + p926 + p927
+ + p928 + p929 + p930 + p931 + p932 + p933 + p934 + p935
+ + p936 + p937 + p938 + p939 + p940 + p941 + p942 + p943
+ + p944 + p945 + p946 + p947 + p948 + p949 + p950 + p951
+ + p952 + p953 + p954 + p955 + p956 + p957 + p958 + p959
+ + p960 + p961 + p962 + p963 + p964 + p965 + p966 + p967
+ + p968 + p969 + p970 + p971 + p972 + p973 + p974 + p975
+ + p976 + p977 + p978 + p979 + p980 + p981 + p982 + p983
+ + p984 + p985 + p986 + p987 + p988 + p989 + p990 + p991
+ + p992 + p993 + p994 + p995 + p996 + p997 + p998 + p999
+ + p1000;
+    return x;
+}
+
+// clang-format on

src/test/app/wasm_fixtures/thousand_params.c

@@ -0,0 +1,262 @@
+// clang-format off
+
+#include <stdint.h>
+
+int32_t test(
+  int32_t p0, int32_t p1, int32_t p2, int32_t p3, int32_t p4, int32_t p5, int32_t p6, int32_t p7
+, int32_t p8, int32_t p9, int32_t p10, int32_t p11, int32_t p12, int32_t p13, int32_t p14, int32_t p15
+, int32_t p16, int32_t p17, int32_t p18, int32_t p19, int32_t p20, int32_t p21, int32_t p22, int32_t p23
+, int32_t p24, int32_t p25, int32_t p26, int32_t p27, int32_t p28, int32_t p29, int32_t p30, int32_t p31
+, int32_t p32, int32_t p33, int32_t p34, int32_t p35, int32_t p36, int32_t p37, int32_t p38, int32_t p39
+, int32_t p40, int32_t p41, int32_t p42, int32_t p43, int32_t p44, int32_t p45, int32_t p46, int32_t p47
+, int32_t p48, int32_t p49, int32_t p50, int32_t p51, int32_t p52, int32_t p53, int32_t p54, int32_t p55
+, int32_t p56, int32_t p57, int32_t p58, int32_t p59, int32_t p60, int32_t p61, int32_t p62, int32_t p63
+, int32_t p64, int32_t p65, int32_t p66, int32_t p67, int32_t p68, int32_t p69, int32_t p70, int32_t p71
+, int32_t p72, int32_t p73, int32_t p74, int32_t p75, int32_t p76, int32_t p77, int32_t p78, int32_t p79
+, int32_t p80, int32_t p81, int32_t p82, int32_t p83, int32_t p84, int32_t p85, int32_t p86, int32_t p87
+, int32_t p88, int32_t p89, int32_t p90, int32_t p91, int32_t p92, int32_t p93, int32_t p94, int32_t p95
+, int32_t p96, int32_t p97, int32_t p98, int32_t p99, int32_t p100, int32_t p101, int32_t p102, int32_t p103
+, int32_t p104, int32_t p105, int32_t p106, int32_t p107, int32_t p108, int32_t p109, int32_t p110, int32_t p111
+, int32_t p112, int32_t p113, int32_t p114, int32_t p115, int32_t p116, int32_t p117, int32_t p118, int32_t p119
+, int32_t p120, int32_t p121, int32_t p122, int32_t p123, int32_t p124, int32_t p125, int32_t p126, int32_t p127
+, int32_t p128, int32_t p129, int32_t p130, int32_t p131, int32_t p132, int32_t p133, int32_t p134, int32_t p135
+, int32_t p136, int32_t p137, int32_t p138, int32_t p139, int32_t p140, int32_t p141, int32_t p142, int32_t p143
+, int32_t p144, int32_t p145, int32_t p146, int32_t p147, int32_t p148, int32_t p149, int32_t p150, int32_t p151
+, int32_t p152, int32_t p153, int32_t p154, int32_t p155, int32_t p156, int32_t p157, int32_t p158, int32_t p159
+, int32_t p160, int32_t p161, int32_t p162, int32_t p163, int32_t p164, int32_t p165, int32_t p166, int32_t p167
+, int32_t p168, int32_t p169, int32_t p170, int32_t p171, int32_t p172, int32_t p173, int32_t p174, int32_t p175
+, int32_t p176, int32_t p177, int32_t p178, int32_t p179, int32_t p180, int32_t p181, int32_t p182, int32_t p183
+, int32_t p184, int32_t p185, int32_t p186, int32_t p187, int32_t p188, int32_t p189, int32_t p190, int32_t p191
+, int32_t p192, int32_t p193, int32_t p194, int32_t p195, int32_t p196, int32_t p197, int32_t p198, int32_t p199
+, int32_t p200, int32_t p201, int32_t p202, int32_t p203, int32_t p204, int32_t p205, int32_t p206, int32_t p207
+, int32_t p208, int32_t p209, int32_t p210, int32_t p211, int32_t p212, int32_t p213, int32_t p214, int32_t p215
+, int32_t p216, int32_t p217, int32_t p218, int32_t p219, int32_t p220, int32_t p221, int32_t p222, int32_t p223
+, int32_t p224, int32_t p225, int32_t p226, int32_t p227, int32_t p228, int32_t p229, int32_t p230, int32_t p231
+, int32_t p232, int32_t p233, int32_t p234, int32_t p235, int32_t p236, int32_t p237, int32_t p238, int32_t p239
+, int32_t p240, int32_t p241, int32_t p242, int32_t p243, int32_t p244, int32_t p245, int32_t p246, int32_t p247
+, int32_t p248, int32_t p249, int32_t p250, int32_t p251, int32_t p252, int32_t p253, int32_t p254, int32_t p255
+, int32_t p256, int32_t p257, int32_t p258, int32_t p259, int32_t p260, int32_t p261, int32_t p262, int32_t p263
+, int32_t p264, int32_t p265, int32_t p266, int32_t p267, int32_t p268, int32_t p269, int32_t p270, int32_t p271
+, int32_t p272, int32_t p273, int32_t p274, int32_t p275, int32_t p276, int32_t p277, int32_t p278, int32_t p279
+, int32_t p280, int32_t p281, int32_t p282, int32_t p283, int32_t p284, int32_t p285, int32_t p286, int32_t p287
+, int32_t p288, int32_t p289, int32_t p290, int32_t p291, int32_t p292, int32_t p293, int32_t p294, int32_t p295
+, int32_t p296, int32_t p297, int32_t p298, int32_t p299, int32_t p300, int32_t p301, int32_t p302, int32_t p303
+, int32_t p304, int32_t p305, int32_t p306, int32_t p307, int32_t p308, int32_t p309, int32_t p310, int32_t p311
+, int32_t p312, int32_t p313, int32_t p314, int32_t p315, int32_t p316, int32_t p317, int32_t p318, int32_t p319
+, int32_t p320, int32_t p321, int32_t p322, int32_t p323, int32_t p324, int32_t p325, int32_t p326, int32_t p327
+, int32_t p328, int32_t p329, int32_t p330, int32_t p331, int32_t p332, int32_t p333, int32_t p334, int32_t p335
+, int32_t p336, int32_t p337, int32_t p338, int32_t p339, int32_t p340, int32_t p341, int32_t p342, int32_t p343
+, int32_t p344, int32_t p345, int32_t p346, int32_t p347, int32_t p348, int32_t p349, int32_t p350, int32_t p351
+, int32_t p352, int32_t p353, int32_t p354, int32_t p355, int32_t p356, int32_t p357, int32_t p358, int32_t p359
+, int32_t p360, int32_t p361, int32_t p362, int32_t p363, int32_t p364, int32_t p365, int32_t p366, int32_t p367
+, int32_t p368, int32_t p369, int32_t p370, int32_t p371, int32_t p372, int32_t p373, int32_t p374, int32_t p375
+, int32_t p376, int32_t p377, int32_t p378, int32_t p379, int32_t p380, int32_t p381, int32_t p382, int32_t p383
+, int32_t p384, int32_t p385, int32_t p386, int32_t p387, int32_t p388, int32_t p389, int32_t p390, int32_t p391
+, int32_t p392, int32_t p393, int32_t p394, int32_t p395, int32_t p396, int32_t p397, int32_t p398, int32_t p399
+, int32_t p400, int32_t p401, int32_t p402, int32_t p403, int32_t p404, int32_t p405, int32_t p406, int32_t p407
+, int32_t p408, int32_t p409, int32_t p410, int32_t p411, int32_t p412, int32_t p413, int32_t p414, int32_t p415
+, int32_t p416, int32_t p417, int32_t p418, int32_t p419, int32_t p420, int32_t p421, int32_t p422, int32_t p423
+, int32_t p424, int32_t p425, int32_t p426, int32_t p427, int32_t p428, int32_t p429, int32_t p430, int32_t p431
+, int32_t p432, int32_t p433, int32_t p434, int32_t p435, int32_t p436, int32_t p437, int32_t p438, int32_t p439
+, int32_t p440, int32_t p441, int32_t p442, int32_t p443, int32_t p444, int32_t p445, int32_t p446, int32_t p447
+, int32_t p448, int32_t p449, int32_t p450, int32_t p451, int32_t p452, int32_t p453, int32_t p454, int32_t p455
+, int32_t p456, int32_t p457, int32_t p458, int32_t p459, int32_t p460, int32_t p461, int32_t p462, int32_t p463
+, int32_t p464, int32_t p465, int32_t p466, int32_t p467, int32_t p468, int32_t p469, int32_t p470, int32_t p471
+, int32_t p472, int32_t p473, int32_t p474, int32_t p475, int32_t p476, int32_t p477, int32_t p478, int32_t p479
+, int32_t p480, int32_t p481, int32_t p482, int32_t p483, int32_t p484, int32_t p485, int32_t p486, int32_t p487
+, int32_t p488, int32_t p489, int32_t p490, int32_t p491, int32_t p492, int32_t p493, int32_t p494, int32_t p495
+, int32_t p496, int32_t p497, int32_t p498, int32_t p499, int32_t p500, int32_t p501, int32_t p502, int32_t p503
+, int32_t p504, int32_t p505, int32_t p506, int32_t p507, int32_t p508, int32_t p509, int32_t p510, int32_t p511
+, int32_t p512, int32_t p513, int32_t p514, int32_t p515, int32_t p516, int32_t p517, int32_t p518, int32_t p519
+, int32_t p520, int32_t p521, int32_t p522, int32_t p523, int32_t p524, int32_t p525, int32_t p526, int32_t p527
+, int32_t p528, int32_t p529, int32_t p530, int32_t p531, int32_t p532, int32_t p533, int32_t p534, int32_t p535
+, int32_t p536, int32_t p537, int32_t p538, int32_t p539, int32_t p540, int32_t p541, int32_t p542, int32_t p543
+, int32_t p544, int32_t p545, int32_t p546, int32_t p547, int32_t p548, int32_t p549, int32_t p550, int32_t p551
+, int32_t p552, int32_t p553, int32_t p554, int32_t p555, int32_t p556, int32_t p557, int32_t p558, int32_t p559
+, int32_t p560, int32_t p561, int32_t p562, int32_t p563, int32_t p564, int32_t p565, int32_t p566, int32_t p567
+, int32_t p568, int32_t p569, int32_t p570, int32_t p571, int32_t p572, int32_t p573, int32_t p574, int32_t p575
+, int32_t p576, int32_t p577, int32_t p578, int32_t p579, int32_t p580, int32_t p581, int32_t p582, int32_t p583
+, int32_t p584, int32_t p585, int32_t p586, int32_t p587, int32_t p588, int32_t p589, int32_t p590, int32_t p591
+, int32_t p592, int32_t p593, int32_t p594, int32_t p595, int32_t p596, int32_t p597, int32_t p598, int32_t p599
+, int32_t p600, int32_t p601, int32_t p602, int32_t p603, int32_t p604, int32_t p605, int32_t p606, int32_t p607
+, int32_t p608, int32_t p609, int32_t p610, int32_t p611, int32_t p612, int32_t p613, int32_t p614, int32_t p615
+, int32_t p616, int32_t p617, int32_t p618, int32_t p619, int32_t p620, int32_t p621, int32_t p622, int32_t p623
+, int32_t p624, int32_t p625, int32_t p626, int32_t p627, int32_t p628, int32_t p629, int32_t p630, int32_t p631
+, int32_t p632, int32_t p633, int32_t p634, int32_t p635, int32_t p636, int32_t p637, int32_t p638, int32_t p639
+, int32_t p640, int32_t p641, int32_t p642, int32_t p643, int32_t p644, int32_t p645, int32_t p646, int32_t p647
+, int32_t p648, int32_t p649, int32_t p650, int32_t p651, int32_t p652, int32_t p653, int32_t p654, int32_t p655
+, int32_t p656, int32_t p657, int32_t p658, int32_t p659, int32_t p660, int32_t p661, int32_t p662, int32_t p663
+, int32_t p664, int32_t p665, int32_t p666, int32_t p667, int32_t p668, int32_t p669, int32_t p670, int32_t p671
+, int32_t p672, int32_t p673, int32_t p674, int32_t p675, int32_t p676, int32_t p677, int32_t p678, int32_t p679
+, int32_t p680, int32_t p681, int32_t p682, int32_t p683, int32_t p684, int32_t p685, int32_t p686, int32_t p687
+, int32_t p688, int32_t p689, int32_t p690, int32_t p691, int32_t p692, int32_t p693, int32_t p694, int32_t p695
+, int32_t p696, int32_t p697, int32_t p698, int32_t p699, int32_t p700, int32_t p701, int32_t p702, int32_t p703
+, int32_t p704, int32_t p705, int32_t p706, int32_t p707, int32_t p708, int32_t p709, int32_t p710, int32_t p711
+, int32_t p712, int32_t p713, int32_t p714, int32_t p715, int32_t p716, int32_t p717, int32_t p718, int32_t p719
+, int32_t p720, int32_t p721, int32_t p722, int32_t p723, int32_t p724, int32_t p725, int32_t p726, int32_t p727
+, int32_t p728, int32_t p729, int32_t p730, int32_t p731, int32_t p732, int32_t p733, int32_t p734, int32_t p735
+, int32_t p736, int32_t p737, int32_t p738, int32_t p739, int32_t p740, int32_t p741, int32_t p742, int32_t p743
+, int32_t p744, int32_t p745, int32_t p746, int32_t p747, int32_t p748, int32_t p749, int32_t p750, int32_t p751
+, int32_t p752, int32_t p753, int32_t p754, int32_t p755, int32_t p756, int32_t p757, int32_t p758, int32_t p759
+, int32_t p760, int32_t p761, int32_t p762, int32_t p763, int32_t p764, int32_t p765, int32_t p766, int32_t p767
+, int32_t p768, int32_t p769, int32_t p770, int32_t p771, int32_t p772, int32_t p773, int32_t p774, int32_t p775
+, int32_t p776, int32_t p777, int32_t p778, int32_t p779, int32_t p780, int32_t p781, int32_t p782, int32_t p783
+, int32_t p784, int32_t p785, int32_t p786, int32_t p787, int32_t p788, int32_t p789, int32_t p790, int32_t p791
+, int32_t p792, int32_t p793, int32_t p794, int32_t p795, int32_t p796, int32_t p797, int32_t p798, int32_t p799
+, int32_t p800, int32_t p801, int32_t p802, int32_t p803, int32_t p804, int32_t p805, int32_t p806, int32_t p807
+, int32_t p808, int32_t p809, int32_t p810, int32_t p811, int32_t p812, int32_t p813, int32_t p814, int32_t p815
+, int32_t p816, int32_t p817, int32_t p818, int32_t p819, int32_t p820, int32_t p821, int32_t p822, int32_t p823
+, int32_t p824, int32_t p825, int32_t p826, int32_t p827, int32_t p828, int32_t p829, int32_t p830, int32_t p831
+, int32_t p832, int32_t p833, int32_t p834, int32_t p835, int32_t p836, int32_t p837, int32_t p838, int32_t p839
+, int32_t p840, int32_t p841, int32_t p842, int32_t p843, int32_t p844, int32_t p845, int32_t p846, int32_t p847
+, int32_t p848, int32_t p849, int32_t p850, int32_t p851, int32_t p852, int32_t p853, int32_t p854, int32_t p855
+, int32_t p856, int32_t p857, int32_t p858, int32_t p859, int32_t p860, int32_t p861, int32_t p862, int32_t p863
+, int32_t p864, int32_t p865, int32_t p866, int32_t p867, int32_t p868, int32_t p869, int32_t p870, int32_t p871
+, int32_t p872, int32_t p873, int32_t p874, int32_t p875, int32_t p876, int32_t p877, int32_t p878, int32_t p879
+, int32_t p880, int32_t p881, int32_t p882, int32_t p883, int32_t p884, int32_t p885, int32_t p886, int32_t p887
+, int32_t p888, int32_t p889, int32_t p890, int32_t p891, int32_t p892, int32_t p893, int32_t p894, int32_t p895
+, int32_t p896, int32_t p897, int32_t p898, int32_t p899, int32_t p900, int32_t p901, int32_t p902, int32_t p903
+, int32_t p904, int32_t p905, int32_t p906, int32_t p907, int32_t p908, int32_t p909, int32_t p910, int32_t p911
+, int32_t p912, int32_t p913, int32_t p914, int32_t p915, int32_t p916, int32_t p917, int32_t p918, int32_t p919
+, int32_t p920, int32_t p921, int32_t p922, int32_t p923, int32_t p924, int32_t p925, int32_t p926, int32_t p927
+, int32_t p928, int32_t p929, int32_t p930, int32_t p931, int32_t p932, int32_t p933, int32_t p934, int32_t p935
+, int32_t p936, int32_t p937, int32_t p938, int32_t p939, int32_t p940, int32_t p941, int32_t p942, int32_t p943
+, int32_t p944, int32_t p945, int32_t p946, int32_t p947, int32_t p948, int32_t p949, int32_t p950, int32_t p951
+, int32_t p952, int32_t p953, int32_t p954, int32_t p955, int32_t p956, int32_t p957, int32_t p958, int32_t p959
+, int32_t p960, int32_t p961, int32_t p962, int32_t p963, int32_t p964, int32_t p965, int32_t p966, int32_t p967
+, int32_t p968, int32_t p969, int32_t p970, int32_t p971, int32_t p972, int32_t p973, int32_t p974, int32_t p975
+, int32_t p976, int32_t p977, int32_t p978, int32_t p979, int32_t p980, int32_t p981, int32_t p982, int32_t p983
+, int32_t p984, int32_t p985, int32_t p986, int32_t p987, int32_t p988, int32_t p989, int32_t p990, int32_t p991
+, int32_t p992, int32_t p993, int32_t p994, int32_t p995, int32_t p996, int32_t p997, int32_t p998, int32_t p999
+)
+{
+    int32_t x;
+    x = p0 + p1 + p2 + p3 + p4 + p5 + p6 + p7
+ + p8 + p9 + p10 + p11 + p12 + p13 + p14 + p15
+ + p16 + p17 + p18 + p19 + p20 + p21 + p22 + p23
+ + p24 + p25 + p26 + p27 + p28 + p29 + p30 + p31
+ + p32 + p33 + p34 + p35 + p36 + p37 + p38 + p39
+ + p40 + p41 + p42 + p43 + p44 + p45 + p46 + p47
+ + p48 + p49 + p50 + p51 + p52 + p53 + p54 + p55
+ + p56 + p57 + p58 + p59 + p60 + p61 + p62 + p63
+ + p64 + p65 + p66 + p67 + p68 + p69 + p70 + p71
+ + p72 + p73 + p74 + p75 + p76 + p77 + p78 + p79
+ + p80 + p81 + p82 + p83 + p84 + p85 + p86 + p87
+ + p88 + p89 + p90 + p91 + p92 + p93 + p94 + p95
+ + p96 + p97 + p98 + p99 + p100 + p101 + p102 + p103
+ + p104 + p105 + p106 + p107 + p108 + p109 + p110 + p111
+ + p112 + p113 + p114 + p115 + p116 + p117 + p118 + p119
+ + p120 + p121 + p122 + p123 + p124 + p125 + p126 + p127
+ + p128 + p129 + p130 + p131 + p132 + p133 + p134 + p135
+ + p136 + p137 + p138 + p139 + p140 + p141 + p142 + p143
+ + p144 + p145 + p146 + p147 + p148 + p149 + p150 + p151
+ + p152 + p153 + p154 + p155 + p156 + p157 + p158 + p159
+ + p160 + p161 + p162 + p163 + p164 + p165 + p166 + p167
+ + p168 + p169 + p170 + p171 + p172 + p173 + p174 + p175
+ + p176 + p177 + p178 + p179 + p180 + p181 + p182 + p183
+ + p184 + p185 + p186 + p187 + p188 + p189 + p190 + p191
+ + p192 + p193 + p194 + p195 + p196 + p197 + p198 + p199
+ + p200 + p201 + p202 + p203 + p204 + p205 + p206 + p207
+ + p208 + p209 + p210 + p211 + p212 + p213 + p214 + p215
+ + p216 + p217 + p218 + p219 + p220 + p221 + p222 + p223
+ + p224 + p225 + p226 + p227 + p228 + p229 + p230 + p231
+ + p232 + p233 + p234 + p235 + p236 + p237 + p238 + p239
+ + p240 + p241 + p242 + p243 + p244 + p245 + p246 + p247
+ + p248 + p249 + p250 + p251 + p252 + p253 + p254 + p255
+ + p256 + p257 + p258 + p259 + p260 + p261 + p262 + p263
+ + p264 + p265 + p266 + p267 + p268 + p269 + p270 + p271
+ + p272 + p273 + p274 + p275 + p276 + p277 + p278 + p279
+ + p280 + p281 + p282 + p283 + p284 + p285 + p286 + p287
+ + p288 + p289 + p290 + p291 + p292 + p293 + p294 + p295
+ + p296 + p297 + p298 + p299 + p300 + p301 + p302 + p303
+ + p304 + p305 + p306 + p307 + p308 + p309 + p310 + p311
+ + p312 + p313 + p314 + p315 + p316 + p317 + p318 + p319
+ + p320 + p321 + p322 + p323 + p324 + p325 + p326 + p327
+ + p328 + p329 + p330 + p331 + p332 + p333 + p334 + p335
+ + p336 + p337 + p338 + p339 + p340 + p341 + p342 + p343
+ + p344 + p345 + p346 + p347 + p348 + p349 + p350 + p351
+ + p352 + p353 + p354 + p355 + p356 + p357 + p358 + p359
+ + p360 + p361 + p362 + p363 + p364 + p365 + p366 + p367
+ + p368 + p369 + p370 + p371 + p372 + p373 + p374 + p375
+ + p376 + p377 + p378 + p379 + p380 + p381 + p382 + p383
+ + p384 + p385 + p386 + p387 + p388 + p389 + p390 + p391
+ + p392 + p393 + p394 + p395 + p396 + p397 + p398 + p399
+ + p400 + p401 + p402 + p403 + p404 + p405 + p406 + p407
+ + p408 + p409 + p410 + p411 + p412 + p413 + p414 + p415
+ + p416 + p417 + p418 + p419 + p420 + p421 + p422 + p423
+ + p424 + p425 + p426 + p427 + p428 + p429 + p430 + p431
+ + p432 + p433 + p434 + p435 + p436 + p437 + p438 + p439
+ + p440 + p441 + p442 + p443 + p444 + p445 + p446 + p447
+ + p448 + p449 + p450 + p451 + p452 + p453 + p454 + p455
+ + p456 + p457 + p458 + p459 + p460 + p461 + p462 + p463
+ + p464 + p465 + p466 + p467 + p468 + p469 + p470 + p471
+ + p472 + p473 + p474 + p475 + p476 + p477 + p478 + p479
+ + p480 + p481 + p482 + p483 + p484 + p485 + p486 + p487
+ + p488 + p489 + p490 + p491 + p492 + p493 + p494 + p495
+ + p496 + p497 + p498 + p499 + p500 + p501 + p502 + p503
+ + p504 + p505 + p506 + p507 + p508 + p509 + p510 + p511
+ + p512 + p513 + p514 + p515 + p516 + p517 + p518 + p519
+ + p520 + p521 + p522 + p523 + p524 + p525 + p526 + p527
+ + p528 + p529 + p530 + p531 + p532 + p533 + p534 + p535
+ + p536 + p537 + p538 + p539 + p540 + p541 + p542 + p543
+ + p544 + p545 + p546 + p547 + p548 + p549 + p550 + p551
+ + p552 + p553 + p554 + p555 + p556 + p557 + p558 + p559
+ + p560 + p561 + p562 + p563 + p564 + p565 + p566 + p567
+ + p568 + p569 + p570 + p571 + p572 + p573 + p574 + p575
+ + p576 + p577 + p578 + p579 + p580 + p581 + p582 + p583
+ + p584 + p585 + p586 + p587 + p588 + p589 + p590 + p591
+ + p592 + p593 + p594 + p595 + p596 + p597 + p598 + p599
+ + p600 + p601 + p602 + p603 + p604 + p605 + p606 + p607
+ + p608 + p609 + p610 + p611 + p612 + p613 + p614 + p615
+ + p616 + p617 + p618 + p619 + p620 + p621 + p622 + p623
+ + p624 + p625 + p626 + p627 + p628 + p629 + p630 + p631
+ + p632 + p633 + p634 + p635 + p636 + p637 + p638 + p639
+ + p640 + p641 + p642 + p643 + p644 + p645 + p646 + p647
+ + p648 + p649 + p650 + p651 + p652 + p653 + p654 + p655
+ + p656 + p657 + p658 + p659 + p660 + p661 + p662 + p663
+ + p664 + p665 + p666 + p667 + p668 + p669 + p670 + p671
+ + p672 + p673 + p674 + p675 + p676 + p677 + p678 + p679
+ + p680 + p681 + p682 + p683 + p684 + p685 + p686 + p687
+ + p688 + p689 + p690 + p691 + p692 + p693 + p694 + p695
+ + p696 + p697 + p698 + p699 + p700 + p701 + p702 + p703
+ + p704 + p705 + p706 + p707 + p708 + p709 + p710 + p711
+ + p712 + p713 + p714 + p715 + p716 + p717 + p718 + p719
+ + p720 + p721 + p722 + p723 + p724 + p725 + p726 + p727
+ + p728 + p729 + p730 + p731 + p732 + p733 + p734 + p735
+ + p736 + p737 + p738 + p739 + p740 + p741 + p742 + p743
+ + p744 + p745 + p746 + p747 + p748 + p749 + p750 + p751
+ + p752 + p753 + p754 + p755 + p756 + p757 + p758 + p759
+ + p760 + p761 + p762 + p763 + p764 + p765 + p766 + p767
+ + p768 + p769 + p770 + p771 + p772 + p773 + p774 + p775
+ + p776 + p777 + p778 + p779 + p780 + p781 + p782 + p783
+ + p784 + p785 + p786 + p787 + p788 + p789 + p790 + p791
+ + p792 + p793 + p794 + p795 + p796 + p797 + p798 + p799
+ + p800 + p801 + p802 + p803 + p804 + p805 + p806 + p807
+ + p808 + p809 + p810 + p811 + p812 + p813 + p814 + p815
+ + p816 + p817 + p818 + p819 + p820 + p821 + p822 + p823
+ + p824 + p825 + p826 + p827 + p828 + p829 + p830 + p831
+ + p832 + p833 + p834 + p835 + p836 + p837 + p838 + p839
+ + p840 + p841 + p842 + p843 + p844 + p845 + p846 + p847
+ + p848 + p849 + p850 + p851 + p852 + p853 + p854 + p855
+ + p856 + p857 + p858 + p859 + p860 + p861 + p862 + p863
+ + p864 + p865 + p866 + p867 + p868 + p869 + p870 + p871
+ + p872 + p873 + p874 + p875 + p876 + p877 + p878 + p879
+ + p880 + p881 + p882 + p883 + p884 + p885 + p886 + p887
+ + p888 + p889 + p890 + p891 + p892 + p893 + p894 + p895
+ + p896 + p897 + p898 + p899 + p900 + p901 + p902 + p903
+ + p904 + p905 + p906 + p907 + p908 + p909 + p910 + p911
+ + p912 + p913 + p914 + p915 + p916 + p917 + p918 + p919
+ + p920 + p921 + p922 + p923 + p924 + p925 + p926 + p927
+ + p928 + p929 + p930 + p931 + p932 + p933 + p934 + p935
+ + p936 + p937 + p938 + p939 + p940 + p941 + p942 + p943
+ + p944 + p945 + p946 + p947 + p948 + p949 + p950 + p951
+ + p952 + p953 + p954 + p955 + p956 + p957 + p958 + p959
+ + p960 + p961 + p962 + p963 + p964 + p965 + p966 + p967
+ + p968 + p969 + p970 + p971 + p972 + p973 + p974 + p975
+ + p976 + p977 + p978 + p979 + p980 + p981 + p982 + p983
+ + p984 + p985 + p986 + p987 + p988 + p989 + p990 + p991
+ + p992 + p993 + p994 + p995 + p996 + p997 + p998 + p999;
+    return x;
+}
+
+// clang-format on

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/basics/Number_test.cpp

@@ -1334,6 +1334,75 @@ public:
         }
     }
 
+    void
+    test_log10()
+    {
+        auto const scale = Number::getMantissaScale();
+        testcase << "test_lg " << to_string(scale);
+
+        using Case = std::tuple<Number, Number>;
+        auto test = [this](auto const& c) {
+            for (auto const& [x, z] : c)
+            {
+                auto const result = log10(x);
+                std::stringstream ss;
+                ss << "lg(" << x << ") = " << result << ". Expected: " << z;
+                // std::cout << ss.str() << std::endl;
+                BEAST_EXPECTS(result == z, ss.str());
+            }
+        };
+
+        auto const cSmall = std::to_array<Case>(
+            {{Number{2}, Number{3'010'299'956'639'811ll, -16}},
+             {Number{2'000'000}, Number{6'301'029'995'663'985ll, -15}},
+             {Number{2, -30}, Number{-2'969'897'000'433'602ll, -14}},
+             {Number{1}, Number{0}},
+             {Number{1'000'000'000'000'000ll}, Number{15}},
+             {Number{5625, -4}, Number{-2'498'774'732'165'998, -16}}});
+
+        auto const cLarge = std::to_array<Case>(
+            {{Number{false, Number::maxMantissa() - 9, -1, Number::normalized{}},
+              Number{false, 1'746'901'684'478'673'451ll, -17, Number::normalized{}}},
+             {Number{false, Number::maxMantissa() - 9, 0, Number::normalized{}},
+              Number{false, 1'846'901'684'478'673'451ll, -17, Number::normalized{}}},
+             {Number{Number::maxRep}, Number{false, 1'861'728'612'932'620'011ll, -17, Number::normalized{}}}});
+
+        if (Number::getMantissaScale() == MantissaRange::small)
+        {
+            test(cSmall);
+        }
+        else
+        {
+            NumberRoundModeGuard mg(Number::towards_zero);
+            test(cLarge);
+        }
+
+        {
+            bool caught = false;
+            try
+            {
+                log10(Number{-2});
+            }
+            catch (std::runtime_error const&)
+            {
+                caught = true;
+            }
+            BEAST_EXPECT(caught);
+            caught = false;
+
+            try
+            {
+                log10(Number());
+            }
+            catch (std::runtime_error const&)
+            {
+                caught = true;
+            }
+            BEAST_EXPECT(caught);
+            caught = false;
+        }
+    }
+
     void
     run() override
     {
@@ -1361,6 +1430,7 @@ public:
             test_truncate();
             testRounding();
             testInt64();
+            test_log10();
         }
     }
 };

src/xrpld/app/wasm/HostFunc.h

@@ -0,0 +1,507 @@
+#pragma once
+
+#include <xrpld/app/wasm/ParamsHelper.h>
+
+#include <xrpl/basics/Expected.h>
+#include <xrpl/basics/Slice.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Asset.h>
+#include <xrpl/protocol/Keylet.h>
+#include <xrpl/protocol/TER.h>
+#include <xrpl/protocol/UintTypes.h>
+
+namespace xrpl {
+
+enum class HostFunctionError : int32_t {
+    INTERNAL = -1,
+    FIELD_NOT_FOUND = -2,
+    BUFFER_TOO_SMALL = -3,
+    NO_ARRAY = -4,
+    NOT_LEAF_FIELD = -5,
+    LOCATOR_MALFORMED = -6,
+    SLOT_OUT_RANGE = -7,
+    SLOTS_FULL = -8,
+    EMPTY_SLOT = -9,
+    LEDGER_OBJ_NOT_FOUND = -10,
+    DECODING = -11,
+    DATA_FIELD_TOO_LARGE = -12,
+    POINTER_OUT_OF_BOUNDS = -13,
+    NO_MEM_EXPORTED = -14,
+    INVALID_PARAMS = -15,
+    INVALID_ACCOUNT = -16,
+    INVALID_FIELD = -17,
+    INDEX_OUT_OF_BOUNDS = -18,
+    FLOAT_INPUT_MALFORMED = -19,
+    FLOAT_COMPUTATION_ERROR = -20,
+    NO_RUNTIME = -21,
+    OUT_OF_GAS = -22,
+};
+
+inline int32_t
+HfErrorToInt(HostFunctionError e)
+{
+    return static_cast<int32_t>(e);
+}
+
+namespace wasm_float {
+
+std::string
+floatToString(Slice const& data);
+
+Expected<Bytes, HostFunctionError>
+floatFromIntImpl(int64_t x, int32_t mode);
+
+Expected<Bytes, HostFunctionError>
+floatFromUintImpl(uint64_t x, int32_t mode);
+
+Expected<Bytes, HostFunctionError>
+floatSetImpl(int64_t mantissa, int32_t exponent, int32_t mode);
+
+Expected<int32_t, HostFunctionError>
+floatCompareImpl(Slice const& x, Slice const& y);
+
+Expected<Bytes, HostFunctionError>
+floatAddImpl(Slice const& x, Slice const& y, int32_t mode);
+
+Expected<Bytes, HostFunctionError>
+floatSubtractImpl(Slice const& x, Slice const& y, int32_t mode);
+
+Expected<Bytes, HostFunctionError>
+floatMultiplyImpl(Slice const& x, Slice const& y, int32_t mode);
+
+Expected<Bytes, HostFunctionError>
+floatDivideImpl(Slice const& x, Slice const& y, int32_t mode);
+
+Expected<Bytes, HostFunctionError>
+floatRootImpl(Slice const& x, int32_t n, int32_t mode);
+
+Expected<Bytes, HostFunctionError>
+floatPowerImpl(Slice const& x, int32_t n, int32_t mode);
+
+Expected<Bytes, HostFunctionError>
+floatLogImpl(Slice const& x, int32_t mode);
+
+}  // namespace wasm_float
+
+struct HostFunctions
+{
+    beast::Journal j_;
+
+    HostFunctions(beast::Journal j = beast::Journal{beast::Journal::getNullSink()}) : j_(j)
+    {
+    }
+
+    // LCOV_EXCL_START
+    virtual void
+    setRT(void const*)
+    {
+    }
+
+    virtual void const*
+    getRT() const
+    {
+        return nullptr;
+    }
+
+    std::int64_t
+    getGas()
+    {
+        return -1;
+    }
+
+    void
+    setGas(std::int64_t)
+    {
+        return;
+    }
+
+    beast::Journal
+    getJournal()
+    {
+        return j_;
+    }
+
+    virtual Expected<std::uint32_t, HostFunctionError>
+    getLedgerSqn()
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<std::uint32_t, HostFunctionError>
+    getParentLedgerTime()
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Hash, HostFunctionError>
+    getParentLedgerHash()
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<uint32_t, HostFunctionError>
+    getBaseFee()
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    isAmendmentEnabled(uint256 const& amendmentId)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    isAmendmentEnabled(std::string_view const& amendmentName)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    cacheLedgerObj(uint256 const& objId, int32_t cacheIdx)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    getTxField(SField const& fname)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    getCurrentLedgerObjField(SField const& fname)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    getLedgerObjField(int32_t cacheIdx, SField const& fname)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    getTxNestedField(Slice const& locator)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    getCurrentLedgerObjNestedField(Slice const& locator)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    getLedgerObjNestedField(int32_t cacheIdx, Slice const& locator)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    getTxArrayLen(SField const& fname)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    getCurrentLedgerObjArrayLen(SField const& fname)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    getLedgerObjArrayLen(int32_t cacheIdx, SField const& fname)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    getTxNestedArrayLen(Slice const& locator)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    getCurrentLedgerObjNestedArrayLen(Slice const& locator)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    getLedgerObjNestedArrayLen(int32_t cacheIdx, Slice const& locator)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    updateData(Slice const& data)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    checkSignature(Slice const& message, Slice const& signature, Slice const& pubkey)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Hash, HostFunctionError>
+    computeSha512HalfHash(Slice const& data)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    accountKeylet(AccountID const& account)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    ammKeylet(Asset const& issue1, Asset const& issue2)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    checkKeylet(AccountID const& account, std::uint32_t seq)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    credentialKeylet(AccountID const& subject, AccountID const& issuer, Slice const& credentialType)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    didKeylet(AccountID const& account)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    delegateKeylet(AccountID const& account, AccountID const& authorize)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    depositPreauthKeylet(AccountID const& account, AccountID const& authorize)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    escrowKeylet(AccountID const& account, std::uint32_t seq)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    lineKeylet(AccountID const& account1, AccountID const& account2, Currency const& currency)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    mptIssuanceKeylet(AccountID const& issuer, std::uint32_t seq)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    mptokenKeylet(MPTID const& mptid, AccountID const& holder)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    nftOfferKeylet(AccountID const& account, std::uint32_t seq)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    offerKeylet(AccountID const& account, std::uint32_t seq)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    oracleKeylet(AccountID const& account, std::uint32_t docId)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    paychanKeylet(AccountID const& account, AccountID const& destination, std::uint32_t seq)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    permissionedDomainKeylet(AccountID const& account, std::uint32_t seq)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    signersKeylet(AccountID const& account)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    ticketKeylet(AccountID const& account, std::uint32_t seq)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    vaultKeylet(AccountID const& account, std::uint32_t seq)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    getNFT(AccountID const& account, uint256 const& nftId)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    getNFTIssuer(uint256 const& nftId)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<std::uint32_t, HostFunctionError>
+    getNFTTaxon(uint256 const& nftId)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    getNFTFlags(uint256 const& nftId)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    getNFTTransferFee(uint256 const& nftId)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<std::uint32_t, HostFunctionError>
+    getNFTSerial(uint256 const& nftId)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    trace(std::string_view const& msg, Slice const& data, bool asHex)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    traceNum(std::string_view const& msg, int64_t data)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    traceAccount(std::string_view const& msg, AccountID const& account)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    traceFloat(std::string_view const& msg, Slice const& data)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    traceAmount(std::string_view const& msg, STAmount const& amount)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    floatFromInt(int64_t x, int32_t mode)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    floatFromUint(uint64_t x, int32_t mode)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    floatSet(int64_t mantissa, int32_t exponent, int32_t mode)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<int32_t, HostFunctionError>
+    floatCompare(Slice const& x, Slice const& y)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    floatAdd(Slice const& x, Slice const& y, int32_t mode)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    floatSubtract(Slice const& x, Slice const& y, int32_t mode)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    floatMultiply(Slice const& x, Slice const& y, int32_t mode)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    floatDivide(Slice const& x, Slice const& y, int32_t mode)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    floatRoot(Slice const& x, int32_t n, int32_t mode)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    floatPower(Slice const& x, int32_t n, int32_t mode)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual Expected<Bytes, HostFunctionError>
+    floatLog(Slice const& x, int32_t mode)
+    {
+        return Unexpected(HostFunctionError::INTERNAL);
+    }
+
+    virtual ~HostFunctions() = default;
+    // LCOV_EXCL_STOP
+};
+
+}  // namespace xrpl

src/xrpld/app/wasm/HostFuncImpl.h

@@ -0,0 +1,285 @@
+#pragma once
+
+#include <xrpld/app/tx/detail/ApplyContext.h>
+#include <xrpld/app/wasm/HostFunc.h>
+
+namespace xrpl {
+class WasmHostFunctionsImpl : public HostFunctions
+{
+    ApplyContext& ctx;
+    Keylet leKey;
+    std::shared_ptr<SLE const> currentLedgerObj = nullptr;
+    bool isLedgerObjCached = false;
+
+    static int constexpr MAX_CACHE = 256;
+    std::array<std::shared_ptr<SLE const>, MAX_CACHE> cache;
+    std::optional<Bytes> data_;
+
+    void const* rt_ = nullptr;
+
+    Expected<std::shared_ptr<SLE const>, HostFunctionError>
+    getCurrentLedgerObj()
+    {
+        if (!isLedgerObjCached)
+        {
+            isLedgerObjCached = true;
+            currentLedgerObj = ctx.view().read(leKey);
+        }
+        if (currentLedgerObj)
+            return currentLedgerObj;
+        return Unexpected(HostFunctionError::LEDGER_OBJ_NOT_FOUND);
+    }
+
+    Expected<int32_t, HostFunctionError>
+    normalizeCacheIndex(int32_t cacheIdx)
+    {
+        --cacheIdx;
+        if (cacheIdx < 0 || cacheIdx >= MAX_CACHE)
+            return Unexpected(HostFunctionError::SLOT_OUT_RANGE);
+        if (!cache[cacheIdx])
+            return Unexpected(HostFunctionError::EMPTY_SLOT);
+        return cacheIdx;
+    }
+
+    template <typename F>
+    void
+    log(std::string_view const& msg, F&& dataFn)
+    {
+#ifdef DEBUG_OUTPUT
+        auto& j = std::cerr;
+#else
+        if (!getJournal().active(beast::severities::kTrace))
+            return;
+        auto j = getJournal().trace();
+#endif
+        j << "WasmTrace[" << to_short_string(leKey.key) << "]: " << msg << " " << dataFn();
+
+#ifdef DEBUG_OUTPUT
+        j << std::endl;
+#endif
+    }
+
+public:
+    WasmHostFunctionsImpl(ApplyContext& ct, Keylet const& leKey) : HostFunctions(ct.journal), ctx(ct), leKey(leKey)
+    {
+    }
+
+    virtual void
+    setRT(void const* rt) override
+    {
+        rt_ = rt;
+    }
+
+    virtual void const*
+    getRT() const override
+    {
+        return rt_;
+    }
+
+    std::optional<Bytes> const&
+    getData() const
+    {
+        return data_;
+    }
+
+    Expected<std::uint32_t, HostFunctionError>
+    getLedgerSqn() override;
+
+    Expected<std::uint32_t, HostFunctionError>
+    getParentLedgerTime() override;
+
+    Expected<Hash, HostFunctionError>
+    getParentLedgerHash() override;
+
+    Expected<std::uint32_t, HostFunctionError>
+    getBaseFee() override;
+
+    Expected<int32_t, HostFunctionError>
+    isAmendmentEnabled(uint256 const& amendmentId) override;
+
+    Expected<int32_t, HostFunctionError>
+    isAmendmentEnabled(std::string_view const& amendmentName) override;
+
+    Expected<int32_t, HostFunctionError>
+    cacheLedgerObj(uint256 const& objId, int32_t cacheIdx) override;
+
+    Expected<Bytes, HostFunctionError>
+    getTxField(SField const& fname) override;
+
+    Expected<Bytes, HostFunctionError>
+    getCurrentLedgerObjField(SField const& fname) override;
+
+    Expected<Bytes, HostFunctionError>
+    getLedgerObjField(int32_t cacheIdx, SField const& fname) override;
+
+    Expected<Bytes, HostFunctionError>
+    getTxNestedField(Slice const& locator) override;
+
+    Expected<Bytes, HostFunctionError>
+    getCurrentLedgerObjNestedField(Slice const& locator) override;
+
+    Expected<Bytes, HostFunctionError>
+    getLedgerObjNestedField(int32_t cacheIdx, Slice const& locator) override;
+
+    Expected<int32_t, HostFunctionError>
+    getTxArrayLen(SField const& fname) override;
+
+    Expected<int32_t, HostFunctionError>
+    getCurrentLedgerObjArrayLen(SField const& fname) override;
+
+    Expected<int32_t, HostFunctionError>
+    getLedgerObjArrayLen(int32_t cacheIdx, SField const& fname) override;
+
+    Expected<int32_t, HostFunctionError>
+    getTxNestedArrayLen(Slice const& locator) override;
+
+    Expected<int32_t, HostFunctionError>
+    getCurrentLedgerObjNestedArrayLen(Slice const& locator) override;
+
+    Expected<int32_t, HostFunctionError>
+    getLedgerObjNestedArrayLen(int32_t cacheIdx, Slice const& locator) override;
+
+    Expected<int32_t, HostFunctionError>
+    updateData(Slice const& data) override;
+
+    Expected<int32_t, HostFunctionError>
+    checkSignature(Slice const& message, Slice const& signature, Slice const& pubkey) override;
+
+    Expected<Hash, HostFunctionError>
+    computeSha512HalfHash(Slice const& data) override;
+
+    Expected<Bytes, HostFunctionError>
+    accountKeylet(AccountID const& account) override;
+
+    Expected<Bytes, HostFunctionError>
+    ammKeylet(Asset const& issue1, Asset const& issue2) override;
+
+    Expected<Bytes, HostFunctionError>
+    checkKeylet(AccountID const& account, std::uint32_t seq) override;
+
+    Expected<Bytes, HostFunctionError>
+    credentialKeylet(AccountID const& subject, AccountID const& issuer, Slice const& credentialType) override;
+
+    Expected<Bytes, HostFunctionError>
+    didKeylet(AccountID const& account) override;
+
+    Expected<Bytes, HostFunctionError>
+    delegateKeylet(AccountID const& account, AccountID const& authorize) override;
+
+    Expected<Bytes, HostFunctionError>
+    depositPreauthKeylet(AccountID const& account, AccountID const& authorize) override;
+
+    Expected<Bytes, HostFunctionError>
+    escrowKeylet(AccountID const& account, std::uint32_t seq) override;
+
+    Expected<Bytes, HostFunctionError>
+    lineKeylet(AccountID const& account1, AccountID const& account2, Currency const& currency) override;
+
+    Expected<Bytes, HostFunctionError>
+    mptIssuanceKeylet(AccountID const& issuer, std::uint32_t seq) override;
+
+    Expected<Bytes, HostFunctionError>
+    mptokenKeylet(MPTID const& mptid, AccountID const& holder) override;
+
+    Expected<Bytes, HostFunctionError>
+    nftOfferKeylet(AccountID const& account, std::uint32_t seq) override;
+
+    Expected<Bytes, HostFunctionError>
+    offerKeylet(AccountID const& account, std::uint32_t seq) override;
+
+    Expected<Bytes, HostFunctionError>
+    oracleKeylet(AccountID const& account, std::uint32_t docId) override;
+
+    Expected<Bytes, HostFunctionError>
+    paychanKeylet(AccountID const& account, AccountID const& destination, std::uint32_t seq) override;
+
+    Expected<Bytes, HostFunctionError>
+    permissionedDomainKeylet(AccountID const& account, std::uint32_t seq) override;
+
+    Expected<Bytes, HostFunctionError>
+    signersKeylet(AccountID const& account) override;
+
+    Expected<Bytes, HostFunctionError>
+    ticketKeylet(AccountID const& account, std::uint32_t seq) override;
+
+    Expected<Bytes, HostFunctionError>
+    vaultKeylet(AccountID const& account, std::uint32_t seq) override;
+
+    Expected<Bytes, HostFunctionError>
+    getNFT(AccountID const& account, uint256 const& nftId) override;
+
+    Expected<Bytes, HostFunctionError>
+    getNFTIssuer(uint256 const& nftId) override;
+
+    Expected<std::uint32_t, HostFunctionError>
+    getNFTTaxon(uint256 const& nftId) override;
+
+    Expected<int32_t, HostFunctionError>
+    getNFTFlags(uint256 const& nftId) override;
+
+    Expected<int32_t, HostFunctionError>
+    getNFTTransferFee(uint256 const& nftId) override;
+
+    Expected<std::uint32_t, HostFunctionError>
+    getNFTSerial(uint256 const& nftId) override;
+
+    Expected<int32_t, HostFunctionError>
+    trace(std::string_view const& msg, Slice const& data, bool asHex) override;
+
+    Expected<int32_t, HostFunctionError>
+    traceNum(std::string_view const& msg, int64_t data) override;
+
+    Expected<int32_t, HostFunctionError>
+    traceAccount(std::string_view const& msg, AccountID const& account) override;
+
+    Expected<int32_t, HostFunctionError>
+    traceFloat(std::string_view const& msg, Slice const& data) override;
+
+    Expected<int32_t, HostFunctionError>
+    traceAmount(std::string_view const& msg, STAmount const& amount) override;
+
+    Expected<Bytes, HostFunctionError>
+    floatFromInt(int64_t x, int32_t mode) override;
+
+    Expected<Bytes, HostFunctionError>
+    floatFromUint(uint64_t x, int32_t mode) override;
+
+    Expected<Bytes, HostFunctionError>
+    floatSet(int64_t mantissa, int32_t exponent, int32_t mode) override;
+
+    Expected<int32_t, HostFunctionError>
+    floatCompare(Slice const& x, Slice const& y) override;
+
+    Expected<Bytes, HostFunctionError>
+    floatAdd(Slice const& x, Slice const& y, int32_t mode) override;
+
+    Expected<Bytes, HostFunctionError>
+    floatSubtract(Slice const& x, Slice const& y, int32_t mode) override;
+
+    Expected<Bytes, HostFunctionError>
+    floatMultiply(Slice const& x, Slice const& y, int32_t mode) override;
+
+    Expected<Bytes, HostFunctionError>
+    floatDivide(Slice const& x, Slice const& y, int32_t mode) override;
+
+    Expected<Bytes, HostFunctionError>
+    floatRoot(Slice const& x, int32_t n, int32_t mode) override;
+
+    Expected<Bytes, HostFunctionError>
+    floatPower(Slice const& x, int32_t n, int32_t mode) override;
+
+    Expected<Bytes, HostFunctionError>
+    floatLog(Slice const& x, int32_t mode) override;
+};
+
+namespace wasm_float {
+
+// The range for the mantissa and exponent when normalized
+static std::int64_t constexpr wasmMinMantissa = 1'000'000'000'000'000ll;
+static std::int64_t constexpr wasmMaxMantissa = wasmMinMantissa * 10 - 1;
+static int constexpr wasmMinExponent = -96;
+static int constexpr wasmMaxExponent = 80;
+
+}  // namespace wasm_float
+
+}  // namespace xrpl

src/xrpld/app/wasm/HostFuncWrapper.h

@@ -0,0 +1,258 @@
+#pragma once
+
+#include <xrpld/app/wasm/WasmiVM.h>
+
+namespace xrpl {
+
+using getLedgerSqn_proto = int32_t(uint8_t*, int32_t);
+wasm_trap_t*
+getLedgerSqn_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using getParentLedgerTime_proto = int32_t(uint8_t*, int32_t);
+wasm_trap_t*
+getParentLedgerTime_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using getParentLedgerHash_proto = int32_t(uint8_t*, int32_t);
+wasm_trap_t*
+getParentLedgerHash_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using getBaseFee_proto = int32_t(uint8_t*, int32_t);
+wasm_trap_t*
+getBaseFee_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using isAmendmentEnabled_proto = int32_t(uint8_t const*, int32_t);
+wasm_trap_t*
+isAmendmentEnabled_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using cacheLedgerObj_proto = int32_t(uint8_t const*, int32_t, int32_t);
+wasm_trap_t*
+cacheLedgerObj_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using getTxField_proto = int32_t(int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+getTxField_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using getCurrentLedgerObjField_proto = int32_t(int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+getCurrentLedgerObjField_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using getLedgerObjField_proto = int32_t(int32_t, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+getLedgerObjField_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using getTxNestedField_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+getTxNestedField_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using getCurrentLedgerObjNestedField_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+getCurrentLedgerObjNestedField_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using getLedgerObjNestedField_proto = int32_t(int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+getLedgerObjNestedField_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using getTxArrayLen_proto = int32_t(int32_t);
+wasm_trap_t*
+getTxArrayLen_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using getCurrentLedgerObjArrayLen_proto = int32_t(int32_t);
+wasm_trap_t*
+getCurrentLedgerObjArrayLen_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using getLedgerObjArrayLen_proto = int32_t(int32_t, int32_t);
+wasm_trap_t*
+getLedgerObjArrayLen_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using getTxNestedArrayLen_proto = int32_t(uint8_t const*, int32_t);
+wasm_trap_t*
+getTxNestedArrayLen_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using getCurrentLedgerObjNestedArrayLen_proto = int32_t(uint8_t const*, int32_t);
+wasm_trap_t*
+getCurrentLedgerObjNestedArrayLen_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using getLedgerObjNestedArrayLen_proto = int32_t(int32_t, uint8_t const*, int32_t);
+wasm_trap_t*
+getLedgerObjNestedArrayLen_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using updateData_proto = int32_t(uint8_t const*, int32_t);
+wasm_trap_t*
+updateData_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using checkSignature_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t const*, int32_t);
+wasm_trap_t*
+checkSignature_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using computeSha512HalfHash_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+computeSha512HalfHash_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using accountKeylet_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+accountKeylet_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using ammKeylet_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+ammKeylet_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using checkKeylet_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+checkKeylet_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using credentialKeylet_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+credentialKeylet_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using delegateKeylet_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+delegateKeylet_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using depositPreauthKeylet_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+depositPreauthKeylet_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using didKeylet_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+didKeylet_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using escrowKeylet_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+escrowKeylet_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using lineKeylet_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+lineKeylet_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using mptIssuanceKeylet_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+mptIssuanceKeylet_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using mptokenKeylet_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+mptokenKeylet_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using nftOfferKeylet_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+nftOfferKeylet_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using offerKeylet_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+offerKeylet_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using oracleKeylet_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+oracleKeylet_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using paychanKeylet_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+paychanKeylet_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using permissionedDomainKeylet_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+permissionedDomainKeylet_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using signersKeylet_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+signersKeylet_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using ticketKeylet_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+ticketKeylet_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using vaultKeylet_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+vaultKeylet_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using getNFT_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+getNFT_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using getNFTIssuer_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+getNFTIssuer_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using getNFTTaxon_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+getNFTTaxon_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using getNFTFlags_proto = int32_t(uint8_t const*, int32_t);
+wasm_trap_t*
+getNFTFlags_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using getNFTTransferFee_proto = int32_t(uint8_t const*, int32_t);
+wasm_trap_t*
+getNFTTransferFee_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using getNFTSerial_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t*
+getNFTSerial_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using trace_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, int32_t);
+wasm_trap_t*
+trace_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using traceNum_proto = int32_t(uint8_t const*, int32_t, int64_t);
+wasm_trap_t*
+traceNum_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using traceAccount_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t);
+wasm_trap_t*
+traceAccount_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using traceFloat_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t);
+wasm_trap_t*
+traceFloat_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using traceAmount_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t);
+wasm_trap_t*
+traceAmount_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using floatFromInt_proto = int32_t(int64_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t*
+floatFromInt_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using floatFromUint_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t*
+floatFromUint_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using floatSet_proto = int32_t(int32_t, int64_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t*
+floatSet_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using floatCompare_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t);
+wasm_trap_t*
+floatCompare_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using floatAdd_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t*
+floatAdd_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using floatSubtract_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t*
+floatSubtract_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using floatMultiply_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t*
+floatMultiply_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using floatDivide_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t*
+floatDivide_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using floatRoot_proto = int32_t(uint8_t const*, int32_t, int32_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t*
+floatRoot_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using floatPower_proto = int32_t(uint8_t const*, int32_t, int32_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t*
+floatPower_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+using floatLog_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t*
+floatLog_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+}  // namespace xrpl

src/xrpld/app/wasm/ParamsHelper.h

@@ -0,0 +1,269 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+
+#include <boost/function_types/function_arity.hpp>
+#include <boost/function_types/parameter_types.hpp>
+#include <boost/function_types/result_type.hpp>
+#include <boost/mpl/vector.hpp>
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace bft = boost::function_types;
+
+namespace xrpl {
+
+using Bytes = std::vector<std::uint8_t>;
+using Hash = xrpl::uint256;
+
+struct wmem
+{
+    std::uint8_t* p = nullptr;
+    std::size_t s = 0;
+};
+
+template <typename T>
+struct WasmResult
+{
+    T result;
+    int64_t cost;
+};
+typedef WasmResult<int32_t> EscrowResult;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+enum WasmTypes { WT_I32, WT_I64, WT_U8V };
+
+struct WasmImportFunc
+{
+    std::string name;
+    std::optional<WasmTypes> result;
+    std::vector<WasmTypes> params;
+    // void* udata = nullptr;
+    // wasm_func_callback_with_env_t
+    void* wrap = nullptr;
+    uint32_t gas = 0;
+};
+
+typedef std::pair<void*, WasmImportFunc> WasmUserData;
+typedef std::vector<WasmUserData> ImportVec;
+
+#define WASM_IMPORT_FUNC(v, f, ...) WasmImpFunc<f##_proto>(v, #f, reinterpret_cast<void*>(&f##_wrap), ##__VA_ARGS__)
+
+#define WASM_IMPORT_FUNC2(v, f, n, ...) WasmImpFunc<f##_proto>(v, n, reinterpret_cast<void*>(&f##_wrap), ##__VA_ARGS__)
+
+template <int N, int C, typename mpl>
+void
+WasmImpArgs(WasmImportFunc& e)
+{
+    if constexpr (N < C)
+    {
+        using at = typename boost::mpl::at_c<mpl, N>::type;
+        if constexpr (std::is_pointer_v<at>)
+            e.params.push_back(WT_I32);
+        else if constexpr (std::is_same_v<at, std::int32_t>)
+            e.params.push_back(WT_I32);
+        else if constexpr (std::is_same_v<at, std::int64_t>)
+            e.params.push_back(WT_I64);
+        else
+            static_assert(std::is_pointer_v<at>, "Unsupported argument type");
+
+        return WasmImpArgs<N + 1, C, mpl>(e);
+    }
+    return;
+}
+
+template <typename rt>
+void
+WasmImpRet(WasmImportFunc& e)
+{
+    if constexpr (std::is_pointer_v<rt>)
+        e.result = WT_I32;
+    else if constexpr (std::is_same_v<rt, std::int32_t>)
+        e.result = WT_I32;
+    else if constexpr (std::is_same_v<rt, std::int64_t>)
+        e.result = WT_I64;
+    else if constexpr (std::is_void_v<rt>)
+        e.result.reset();
+#if (defined(__GNUC__) && (__GNUC__ >= 14)) || ((defined(__clang_major__)) && (__clang_major__ >= 18))
+    else
+        static_assert(false, "Unsupported return type");
+#endif
+}
+
+template <typename F>
+void
+WasmImpFuncHelper(WasmImportFunc& e)
+{
+    using rt = typename bft::result_type<F>::type;
+    using pt = typename bft::parameter_types<F>::type;
+    // typename boost::mpl::at_c<mpl, N>::type
+
+    WasmImpRet<rt>(e);
+    WasmImpArgs<0, bft::function_arity<F>::value, pt>(e);
+    // WasmImpWrap(e, std::forward<F>(f));
+}
+
+template <typename F>
+void
+WasmImpFunc(ImportVec& v, std::string_view imp_name, void* f_wrap, void* data = nullptr, uint32_t gas = 0)
+{
+    WasmImportFunc e;
+    e.name = imp_name;
+    e.wrap = f_wrap;
+    e.gas = gas;
+    WasmImpFuncHelper<F>(e);
+    v.push_back(std::make_pair(data, std::move(e)));
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+struct WasmParamVec
+{
+    std::uint8_t const* d = nullptr;
+    std::int32_t sz = 0;
+};
+
+struct WasmParam
+{
+    WasmTypes type = WT_I32;
+    union
+    {
+        std::int32_t i32;
+        std::int64_t i64 = 0;
+        float f32;
+        double f64;
+        WasmParamVec u8v;
+    } of;
+};
+
+template <class... Types>
+inline void
+wasmParamsHlp(std::vector<WasmParam>& v, std::int32_t p, Types&&... args)
+{
+    v.push_back({.type = WT_I32, .of = {.i32 = p}});
+    wasmParamsHlp(v, std::forward<Types>(args)...);
+}
+
+template <class... Types>
+inline void
+wasmParamsHlp(std::vector<WasmParam>& v, std::int64_t p, Types&&... args)
+{
+    v.push_back({.type = WT_I64, .of = {.i64 = p}});
+    wasmParamsHlp(v, std::forward<Types>(args)...);
+}
+
+// We are not supporting float/double for now
+// Leaving this code here so that it is easier to add later if needed
+// template <class... Types>
+// inline void
+// wasmParamsHlp(std::vector<WasmParam>& v, float p, Types&&... args)
+// {
+//     v.push_back({.type = WT_F32, .of = {.f32 = p}});
+//     wasmParamsHlp(v, std::forward<Types>(args)...);
+// }
+
+// template <class... Types>
+// inline void
+// wasmParamsHlp(std::vector<WasmParam>& v, double p, Types&&... args)
+// {
+//     v.push_back({.type = WT_F64, .of = {.f64 = p}});
+//     wasmParamsHlp(v, std::forward<Types>(args)...);
+// }
+
+template <class... Types>
+inline void
+wasmParamsHlp(std::vector<WasmParam>& v, std::uint8_t const* dt, std::int32_t sz, Types&&... args)
+{
+    v.push_back({.type = WT_U8V, .of = {.u8v = {.d = dt, .sz = sz}}});
+    wasmParamsHlp(v, std::forward<Types>(args)...);
+}
+
+template <class... Types>
+inline void
+wasmParamsHlp(std::vector<WasmParam>& v, Bytes const& p, Types&&... args)
+{
+    if (p.size() > std::numeric_limits<int32_t>::max())
+        throw std::runtime_error("can't allocate memory, size: " + std::to_string(p.size()));  // LCOV_EXCL_LINE
+
+    wasmParamsHlp(v, p.data(), static_cast<std::int32_t>(p.size()), std::forward<Types>(args)...);
+}
+
+template <class... Types>
+inline void
+wasmParamsHlp(std::vector<WasmParam>& v, std::string_view const& p, Types&&... args)
+{
+    if (p.size() > std::numeric_limits<int32_t>::max())
+        throw std::runtime_error("can't allocate memory, size: " + std::to_string(p.size()));
+
+    wasmParamsHlp(
+        v,
+        reinterpret_cast<std::uint8_t const*>(p.data()),
+        static_cast<std::int32_t>(p.size()),
+        std::forward<Types>(args)...);
+}
+
+template <class... Types>
+inline void
+wasmParamsHlp(std::vector<WasmParam>& v, std::string const& p, Types&&... args)
+{
+    if (p.size() > std::numeric_limits<int32_t>::max())
+        throw std::runtime_error("can't allocate memory, size: " + std::to_string(p.size()));  // LCOV_EXCL_LINE
+
+    wasmParamsHlp(
+        v,
+        reinterpret_cast<std::uint8_t const*>(p.c_str()),
+        static_cast<std::int32_t>(p.size()),
+        std::forward<Types>(args)...);
+}
+
+inline void
+wasmParamsHlp(std::vector<WasmParam>& v)
+{
+    return;
+}
+
+template <class... Types>
+inline std::vector<WasmParam>
+wasmParams(Types&&... args)
+{
+    std::vector<WasmParam> v;
+    v.reserve(sizeof...(args));
+    wasmParamsHlp(v, std::forward<Types>(args)...);
+    return v;
+}
+
+template <typename T, size_t size = sizeof(T)>
+inline constexpr T
+adjustWasmEndianessHlp(T x)
+{
+    static_assert(std::is_integral<T>::value, "Only integral types");
+    if constexpr (size > 1)
+    {
+        using U = std::make_unsigned<T>::type;
+        U u = static_cast<U>(x);
+        U const low = (u & 0xFF) << ((size - 1) << 3);
+        u = adjustWasmEndianessHlp<U, size - 1>(u >> 8);
+        return static_cast<T>(low | u);
+    }
+
+    return x;
+}
+
+template <typename T, size_t size = sizeof(T)>
+inline constexpr T
+adjustWasmEndianess(T x)
+{
+    // LCOV_EXCL_START
+    static_assert(std::is_integral<T>::value, "Only integral types");
+    if constexpr (std::endian::native == std::endian::big)
+    {
+        return adjustWasmEndianessHlp(x);
+    }
+    return x;
+    // LCOV_EXCL_STOP
+}
+
+}  // namespace xrpl

src/xrpld/app/wasm/README.md

@@ -0,0 +1,189 @@
+# WASM Module for Programmable Escrows
+
+This module provides WebAssembly (WASM) execution capabilities for programmable
+escrows on the XRP Ledger. When an escrow is finished, the WASM code runs to
+determine whether the escrow conditions are met, enabling custom programmable
+logic for escrow release conditions.
+
+For the full specification, see
+[XLS-0102: WASM VM](https://xls.xrpl.org/xls/XLS-0102-wasm-vm.html).
+
+## Architecture
+
+The module follows a layered architecture:
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                 WasmEngine (WasmVM.h)                       │
+│         runEscrowWasm(), preflightEscrowWasm()              │
+│              Host function registration                     │
+├─────────────────────────────────────────────────────────────┤
+│                 WasmiEngine (WasmiVM.h)                     │
+│            Low-level wasmi interpreter integration          │
+├─────────────────────────────────────────────────────────────┤
+│    HostFuncWrapper          │       HostFuncImpl            │
+│   C-style WASM bridges      │   C++ implementations         │
+├─────────────────────────────────────────────────────────────┤
+│                   HostFunc (Interface)                      │
+│            Abstract base class for host functions           │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Key Components
+
+- **`WasmVM.h` / `detail/WasmVM.cpp`** - High-level facade providing:
+  - `WasmEngine` singleton that wraps the underlying WASM interpreter
+  - `runEscrowWasm()` - Execute WASM code for escrow finish
+  - `preflightEscrowWasm()` - Validate WASM code during preflight
+  - `createWasmImport()` - Register all host functions
+
+- **`WasmiVM.h` / `detail/WasmiVM.cpp`** - Low-level integration with the
+  [wasmi](https://github.com/wasmi-labs/wasmi) WebAssembly interpreter:
+  - `WasmiEngine` - Manages WASM modules, instances, and execution
+  - Memory management and gas metering
+  - Function invocation and result handling
+
+- **`HostFunc.h`** - Abstract `HostFunctions` base class defining the interface
+  for all callable host functions. Each method returns
+  `Expected<T, HostFunctionError>`.
+
+- **`HostFuncImpl.h` / `detail/HostFuncImpl*.cpp`** - Concrete
+  `WasmHostFunctionsImpl` class that implements host functions with access to
+  `ApplyContext` for ledger state queries. Implementation split across files:
+  - `HostFuncImpl.cpp` - Core utilities (updateData, checkSignature, etc.)
+  - `HostFuncImplFloat.cpp` - Float/number arithmetic operations
+  - `HostFuncImplGetter.cpp` - Field access (transaction, ledger objects)
+  - `HostFuncImplKeylet.cpp` - Keylet construction functions
+  - `HostFuncImplLedgerHeader.cpp` - Ledger header info access
+  - `HostFuncImplNFT.cpp` - NFT-related queries
+  - `HostFuncImplTrace.cpp` - Debugging/tracing functions
+
+- **`HostFuncWrapper.h` / `detail/HostFuncWrapper.cpp`** - C-style wrapper
+  functions that bridge WASM calls to C++ `HostFunctions` methods. Each host
+  function has:
+  - A `_proto` type alias defining the function signature
+  - A `_wrap` function that extracts parameters and calls the implementation
+
+- **`ParamsHelper.h`** - Utilities for WASM parameter handling:
+  - `WASM_IMPORT_FUNC` / `WASM_IMPORT_FUNC2` macros for registration
+  - `wasmParams()` helper for building parameter vectors
+  - Type conversion between WASM and C++ types
+
+## Host Functions
+
+Host functions allow WASM code to interact with the XRP Ledger. They are
+organized into categories:
+
+- **Ledger Information** - Access ledger sequence, timestamps, hashes, fees
+- **Transaction & Ledger Object Access** - Read fields from the transaction
+  and ledger objects (including the current escrow object)
+- **Keylet Construction** - Build keylets to look up various ledger object types
+- **Cryptography** - Signature verification and hashing
+- **Float Arithmetic** - Mathematical operations for amount calculations
+- **NFT Operations** - Query NFT properties
+- **Tracing/Debugging** - Log messages for debugging
+
+For the complete list of available host functions, their WASM names, and gas
+costs, see the [XLS-0102 specification](https://xls.xrpl.org/xls/XLS-0102-wasm-vm.html)
+or `detail/WasmVM.cpp` where they are registered via `WASM_IMPORT_FUNC2` macros.
+For method signatures, see `HostFunc.h`.
+
+## Gas Model
+
+Each host function has an associated gas cost. The gas cost is specified when
+registering the function in `detail/WasmVM.cpp`:
+
+```cpp
+WASM_IMPORT_FUNC2(i, getLedgerSqn, "get_ledger_sqn", hfs, 60);
+//                                                        ^^ gas cost
+```
+
+WASM execution is metered, and if the gas limit is exceeded, execution fails.
+
+## Entry Point
+
+The WASM module must export a function with the name defined by
+`ESCROW_FUNCTION_NAME` (currently `"finish"`). This function:
+
+- Takes no parameters (or parameters passed via host function calls)
+- Returns an `int32_t`:
+  - `1` (or positive): Escrow conditions are met, allow finish
+  - `0` (or negative): Escrow conditions are not met, reject finish
+
+## Adding a New Host Function
+
+To add a new host function, follow these steps:
+
+### 1. Add to HostFunc.h (Base Class)
+
+Add a virtual method declaration with a default implementation that returns an
+error:
+
+```cpp
+virtual Expected<ReturnType, HostFunctionError>
+myNewFunction(ParamType1 param1, ParamType2 param2)
+{
+    return Unexpected(HostFunctionError::INTERNAL);
+}
+```
+
+### 2. Add to HostFuncImpl.h (Declaration)
+
+Add the method override declaration in `WasmHostFunctionsImpl`:
+
+```cpp
+Expected<ReturnType, HostFunctionError>
+myNewFunction(ParamType1 param1, ParamType2 param2) override;
+```
+
+### 3. Implement in detail/HostFuncImpl\*.cpp
+
+Add the implementation in the appropriate file:
+
+```cpp
+Expected<ReturnType, HostFunctionError>
+WasmHostFunctionsImpl::myNewFunction(ParamType1 param1, ParamType2 param2)
+{
+    // Implementation using ctx (ApplyContext) for ledger access
+    return result;
+}
+```
+
+### 4. Add Wrapper to HostFuncWrapper.h
+
+Add the prototype and wrapper declaration:
+
+```cpp
+using myNewFunction_proto = int32_t(uint8_t const*, int32_t, ...);
+wasm_trap_t*
+myNewFunction_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+```
+
+### 5. Implement Wrapper in detail/HostFuncWrapper.cpp
+
+Implement the C-style wrapper that bridges WASM to C++:
+
+```cpp
+wasm_trap_t*
+myNewFunction_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results)
+{
+    // Extract parameters from params
+    // Call hfs->myNewFunction(...)
+    // Set results and return
+}
+```
+
+### 6. Register in WasmVM.cpp
+
+Add the function registration in `setCommonHostFunctions()` or
+`createWasmImport()`:
+
+```cpp
+WASM_IMPORT_FUNC2(i, myNewFunction, "my_new_function", hfs, 100);
+//                                   ^^ WASM name       ^^ gas cost
+```
+
+> [!IMPORTANT]
+> New host functions MUST be amendment-gated in `WasmVM.cpp`.
+> Wrap the registration in an amendment check to ensure the function is only
+> available after the corresponding amendment is enabled on the network.

src/xrpld/app/wasm/WasmVM.h

@@ -0,0 +1,90 @@
+#pragma once
+
+#include <xrpld/app/wasm/HostFunc.h>
+
+#include <string_view>
+
+namespace xrpl {
+
+static std::string_view const W_ENV = "env";
+static std::string_view const W_HOST_LIB = "host_lib";
+static std::string_view const W_MEM = "memory";
+static std::string_view const W_STORE = "store";
+static std::string_view const W_LOAD = "load";
+static std::string_view const W_SIZE = "size";
+static std::string_view const W_ALLOC = "allocate";
+static std::string_view const W_DEALLOC = "deallocate";
+static std::string_view const W_PROC_EXIT = "proc_exit";
+
+static std::string_view const ESCROW_FUNCTION_NAME = "finish";
+
+uint32_t const MAX_PAGES = 128;  // 8MB = 64KB*128
+
+class WasmiEngine;
+
+class WasmEngine
+{
+    std::unique_ptr<WasmiEngine> const impl;
+
+    WasmEngine();
+
+    WasmEngine(WasmEngine const&) = delete;
+    WasmEngine(WasmEngine&&) = delete;
+    WasmEngine&
+    operator=(WasmEngine const&) = delete;
+    WasmEngine&
+    operator=(WasmEngine&&) = delete;
+
+public:
+    ~WasmEngine() = default;
+
+    static WasmEngine&
+    instance();
+
+    Expected<WasmResult<int32_t>, TER>
+    run(Bytes const& wasmCode,
+        std::string_view funcName = {},
+        std::vector<WasmParam> const& params = {},
+        std::shared_ptr<ImportVec> const& imports = {},
+        std::shared_ptr<HostFunctions> const& hfs = {},
+        int64_t gasLimit = -1,
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()});
+
+    NotTEC
+    check(
+        Bytes const& wasmCode,
+        std::string_view funcName,
+        std::vector<WasmParam> const& params = {},
+        std::shared_ptr<ImportVec> const& imports = {},
+        std::shared_ptr<HostFunctions> const& hfs = {},
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()});
+
+    // Host functions helper functionality
+    void*
+    newTrap(std::string const& txt = std::string());
+
+    beast::Journal
+    getJournal() const;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+std::shared_ptr<ImportVec>
+createWasmImport(HostFunctions& hfs);
+
+Expected<EscrowResult, TER>
+runEscrowWasm(
+    Bytes const& wasmCode,
+    std::shared_ptr<HostFunctions> const& hfs,
+    std::string_view funcName = ESCROW_FUNCTION_NAME,
+    std::vector<WasmParam> const& params = {},
+    int64_t gasLimit = -1);
+
+NotTEC
+preflightEscrowWasm(
+    Bytes const& wasmCode,
+    std::shared_ptr<HostFunctions> const& hfs,
+    std::string_view funcName = ESCROW_FUNCTION_NAME,
+    std::vector<WasmParam> const& params = {});
+
+}  // namespace xrpl

src/xrpld/app/wasm/WasmiVM.h

@@ -0,0 +1,300 @@
+#pragma once
+
+#include <xrpld/app/wasm/WasmVM.h>
+
+#include <wasm.h>
+#include <wasmi.h>
+
+namespace xrpl {
+
+template <class T, void (*Create)(T*, size_t), void (*Destroy)(T*)>
+struct WasmVec
+{
+    T vec_;
+
+    WasmVec(size_t s = 0) : vec_ WASM_EMPTY_VEC
+    {
+        if (s > 0)
+            Create(&vec_, s);  // zeroes memory
+    }
+
+    ~WasmVec()
+    {
+        clear();
+    }
+
+    WasmVec(WasmVec const&) = delete;
+    WasmVec&
+    operator=(WasmVec const&) = delete;
+
+    WasmVec(WasmVec&& other) noexcept : vec_ WASM_EMPTY_VEC
+    {
+        *this = std::move(other);
+    }
+
+    WasmVec&
+    operator=(WasmVec&& other) noexcept
+    {
+        if (this != &other)
+        {
+            clear();
+            vec_ = other.vec_;
+            other.vec_ = WASM_EMPTY_VEC;
+        }
+        return *this;
+    }
+
+    void
+    clear()
+    {
+        Destroy(&vec_);  // call destructor for every elements too
+        vec_ = WASM_EMPTY_VEC;
+    }
+
+    T
+    release()
+    {
+        T result = vec_;
+        vec_ = WASM_EMPTY_VEC;
+        return result;
+    }
+};
+
+using WasmValtypeVec = WasmVec<wasm_valtype_vec_t, &wasm_valtype_vec_new_uninitialized, &wasm_valtype_vec_delete>;
+using WasmValVec = WasmVec<wasm_val_vec_t, &wasm_val_vec_new_uninitialized, &wasm_val_vec_delete>;
+using WasmExternVec = WasmVec<wasm_extern_vec_t, &wasm_extern_vec_new_uninitialized, &wasm_extern_vec_delete>;
+using WasmExporttypeVec =
+    WasmVec<wasm_exporttype_vec_t, &wasm_exporttype_vec_new_uninitialized, &wasm_exporttype_vec_delete>;
+using WasmImporttypeVec =
+    WasmVec<wasm_importtype_vec_t, &wasm_importtype_vec_new_uninitialized, &wasm_importtype_vec_delete>;
+
+struct WasmiResult
+{
+    WasmValVec r;
+    bool f;  // failure flag
+
+    WasmiResult(unsigned N = 0) : r(N), f(false)
+    {
+    }
+
+    ~WasmiResult() = default;
+    WasmiResult(WasmiResult&& o) = default;
+    WasmiResult&
+    operator=(WasmiResult&& o) = default;
+};
+
+using ModulePtr = std::unique_ptr<wasm_module_t, decltype(&wasm_module_delete)>;
+using InstancePtr = std::unique_ptr<wasm_instance_t, decltype(&wasm_instance_delete)>;
+using EnginePtr = std::unique_ptr<wasm_engine_t, decltype(&wasm_engine_delete)>;
+using StorePtr = std::unique_ptr<wasm_store_t, decltype(&wasm_store_delete)>;
+
+using FuncInfo = std::pair<wasm_func_t const*, wasm_functype_t const*>;
+
+struct InstanceWrapper
+{
+    wasm_store_t* store_ = nullptr;
+    WasmExternVec exports_;
+    mutable int memIdx_ = -1;
+    InstancePtr instance_;
+    beast::Journal j_ = beast::Journal(beast::Journal::getNullSink());
+
+private:
+    static InstancePtr
+    init(StorePtr& s, ModulePtr& m, WasmExternVec& expt, WasmExternVec const& imports, beast::Journal j);
+
+public:
+    InstanceWrapper();
+
+    InstanceWrapper(InstanceWrapper&& o);
+
+    InstanceWrapper&
+    operator=(InstanceWrapper&& o);
+
+    InstanceWrapper(StorePtr& s, ModulePtr& m, WasmExternVec const& imports, beast::Journal j);
+
+    ~InstanceWrapper() = default;
+
+    operator bool() const;
+
+    FuncInfo
+    getFunc(std::string_view funcName, WasmExporttypeVec const& exportTypes) const;
+
+    wmem
+    getMem() const;
+
+    std::int64_t
+    getGas() const;
+
+    std::int64_t setGas(std::int64_t) const;
+};
+
+struct ModuleWrapper
+{
+    ModulePtr module_;
+    InstanceWrapper instanceWrap_;
+    WasmExporttypeVec exportTypes_;
+    beast::Journal j_ = beast::Journal(beast::Journal::getNullSink());
+
+private:
+    static ModulePtr
+    init(StorePtr& s, Bytes const& wasmBin, beast::Journal j);
+
+public:
+    ModuleWrapper();
+    ModuleWrapper(ModuleWrapper&& o);
+    ModuleWrapper&
+    operator=(ModuleWrapper&& o);
+    ModuleWrapper(
+        StorePtr& s,
+        Bytes const& wasmBin,
+        bool instantiate,
+        std::shared_ptr<ImportVec> const& imports,
+        beast::Journal j);
+    ~ModuleWrapper() = default;
+
+    operator bool() const;
+
+    FuncInfo
+    getFunc(std::string_view funcName) const;
+
+    wasm_functype_t*
+    getFuncType(std::string_view funcName) const;
+
+    wmem
+    getMem() const;
+
+    InstanceWrapper const&
+    getInstance(int i = 0) const;
+
+    int
+    addInstance(StorePtr& s, WasmExternVec const& imports);
+
+    std::int64_t
+    getGas();
+
+private:
+    WasmExternVec
+    buildImports(StorePtr& s, std::shared_ptr<ImportVec> const& imports);
+};
+
+class WasmiEngine
+{
+    EnginePtr engine_;
+    StorePtr store_;
+    std::unique_ptr<ModuleWrapper> moduleWrap_;
+    beast::Journal j_ = beast::Journal(beast::Journal::getNullSink());
+
+    std::mutex m_;  // 1 instance mutex
+
+    // to ensure lifetime during next executions with the same module
+    std::shared_ptr<ImportVec> imports_;
+    std::shared_ptr<HostFunctions> hfs_;
+
+public:
+    WasmiEngine();
+    ~WasmiEngine() = default;
+
+    static EnginePtr
+    init();
+
+    Expected<WasmResult<int32_t>, TER>
+    run(Bytes const& wasmCode,
+        std::string_view funcName,
+        std::vector<WasmParam> const& params,
+        std::shared_ptr<ImportVec> const& imports,
+        std::shared_ptr<HostFunctions> const& hfs,
+        int64_t gas,
+        beast::Journal j);
+
+    NotTEC
+    check(
+        Bytes const& wasmCode,
+        std::string_view funcName,
+        std::vector<WasmParam> const& params,
+        std::shared_ptr<ImportVec> const& imports,
+        std::shared_ptr<HostFunctions> const& hfs,
+        beast::Journal j);
+
+    std::int64_t
+    getGas();
+
+    // Host functions helper functionality
+    wasm_trap_t*
+    newTrap(std::string const& msg);
+
+    beast::Journal
+    getJournal() const;
+
+private:
+    InstanceWrapper const&
+    getRT(int m = 0, int i = 0);
+
+    wmem
+    getMem() const;
+
+    int32_t
+    allocate(int32_t size);
+
+    Expected<WasmResult<int32_t>, TER>
+    runHlp(Bytes const& wasmCode, std::string_view funcName, std::vector<WasmParam> const& params, int64_t gas);
+
+    NotTEC
+    checkHlp(Bytes const& wasmCode, std::string_view funcName, std::vector<WasmParam> const& params);
+
+    int
+    addModule(Bytes const& wasmCode, bool instantiate, int64_t gas);
+    void
+    clearModules();
+
+    // int  addInstance();
+
+    int32_t
+    runFunc(std::string_view const funcName, int32_t p);
+
+    int32_t
+    makeModule(Bytes const& wasmCode, WasmExternVec const& imports = {});
+
+    FuncInfo
+    getFunc(std::string_view funcName);
+
+    std::vector<wasm_val_t>
+    convertParams(std::vector<WasmParam> const& params);
+
+    static int
+    compareParamTypes(wasm_valtype_vec_t const* ftp, std::vector<wasm_val_t> const& p);
+
+    static void
+    add_param(std::vector<wasm_val_t>& in, int32_t p);
+    static void
+    add_param(std::vector<wasm_val_t>& in, int64_t p);
+
+    template <int NR, class... Types>
+    inline WasmiResult
+    call(std::string_view func, Types&&... args);
+
+    template <int NR, class... Types>
+    inline WasmiResult
+    call(FuncInfo const& f, Types&&... args);
+
+    template <int NR, class... Types>
+    inline WasmiResult
+    call(FuncInfo const& f, std::vector<wasm_val_t>& in);
+
+    template <int NR, class... Types>
+    inline WasmiResult
+    call(FuncInfo const& f, std::vector<wasm_val_t>& in, std::int32_t p, Types&&... args);
+
+    template <int NR, class... Types>
+    inline WasmiResult
+    call(FuncInfo const& f, std::vector<wasm_val_t>& in, std::int64_t p, Types&&... args);
+
+    template <int NR, class... Types>
+    inline WasmiResult
+    call(FuncInfo const& f, std::vector<wasm_val_t>& in, uint8_t const* d, int32_t sz, Types&&... args);
+
+    template <int NR, class... Types>
+    inline WasmiResult
+    call(FuncInfo const& f, std::vector<wasm_val_t>& in, Bytes const& p, Types&&... args);
+};
+
+}  // namespace xrpl

src/xrpld/app/wasm/detail/HostFuncImpl.cpp

@@ -0,0 +1,44 @@
+#include <xrpld/app/wasm/HostFuncImpl.h>
+
+#include <xrpl/protocol/STBitString.h>
+#include <xrpl/protocol/digest.h>
+
+namespace xrpl {
+
+// =========================================================
+// SECTION: WRITE FUNCTION
+// =========================================================
+
+Expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::updateData(Slice const& data)
+{
+    if (data.size() > maxWasmDataLength)
+    {
+        return Unexpected(HostFunctionError::DATA_FIELD_TOO_LARGE);
+    }
+    data_ = Bytes(data.begin(), data.end());
+    return data_->size();
+}
+
+// =========================================================
+// SECTION: UTILS
+// =========================================================
+
+Expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::checkSignature(Slice const& message, Slice const& signature, Slice const& pubkey)
+{
+    if (!publicKeyType(pubkey))
+        return Unexpected(HostFunctionError::INVALID_PARAMS);
+
+    PublicKey const pk(pubkey);
+    return verify(pk, message, signature);
+}
+
+Expected<Hash, HostFunctionError>
+WasmHostFunctionsImpl::computeSha512HalfHash(Slice const& data)
+{
+    auto const hash = sha512Half(data);
+    return hash;
+}
+
+}  // namespace xrpl

src/xrpld/app/wasm/detail/HostFuncImplFloat.cpp

@@ -0,0 +1,548 @@
+#include <xrpld/app/wasm/HostFuncImpl.h>
+
+#include <xrpl/protocol/STBitString.h>
+#include <xrpl/protocol/digest.h>
+
+#ifdef _DEBUG
+// #define DEBUG_OUTPUT 1
+#endif
+
+namespace xrpl {
+
+namespace wasm_float {
+
+namespace detail {
+
+class Number2 : public Number
+{
+protected:
+    static Bytes const floatNull;
+    static unsigned constexpr encodedFloatSize = 8;
+    static int32_t constexpr encodedMantissaBits = 54;
+    static int32_t constexpr encodedExponentBits = 8;
+
+    static_assert(wasmMinExponent < 0);
+
+    static uint64_t constexpr maxEncodedMantissa = (1ull << (encodedMantissaBits + 1)) - 1;
+
+    bool good_;
+
+public:
+    Number2(Slice const& data) : Number(), good_(false)
+    {
+        if (data.size() != encodedFloatSize)
+            return;
+
+        if (std::ranges::equal(floatNull, data))
+        {
+            good_ = true;
+            return;
+        }
+
+        uint64_t const v = SerialIter(data).get64();
+        if (!(v & STAmount::cIssuedCurrency))
+            return;
+
+        int32_t const e = static_cast<int32_t>((v >> encodedMantissaBits) & 0xFFull);
+        int32_t const decodedExponent = e + wasmMinExponent - 1;  // e - 97
+        if (decodedExponent < wasmMinExponent || decodedExponent > wasmMaxExponent)
+            return;
+
+        int64_t const neg = (v & STAmount::cPositive) ? 1 : -1;
+        int64_t const m = neg * static_cast<int64_t>(v & ((1ull << encodedMantissaBits) - 1));
+        if (!m)
+            return;
+
+        Number x(makeNumber(m, decodedExponent));
+        if (m != x.mantissa() || decodedExponent != x.exponent())
+            return;  // not canonical
+        *static_cast<Number*>(this) = x;
+
+        good_ = true;
+    }
+
+    template <class T>
+    Number2(T mantissa = 0, int32_t exponent = 0) : Number(), good_(false)
+    {
+        if (!mantissa)
+        {
+            good_ = true;
+            return;
+        }
+
+        auto const n = makeNumber(mantissa, exponent);
+        auto const e = n.exponent();
+        if (e < wasmMinExponent)
+        {
+            good_ = true;  // value is zero(as in Numbers behavior)
+            return;
+        }
+
+        if (e > wasmMaxExponent)
+            return;
+
+        *static_cast<Number*>(this) = n;
+        good_ = true;
+    }
+
+    Number2(Number const& n) : Number2(n.mantissa(), n.exponent())  // ensure Number canonized
+    {
+    }
+
+    static Number
+    makeNumber(int64_t mantissa, int32_t exponent)
+    {
+        if (mantissa < 0)
+            return Number(true, -static_cast<uint64_t>(mantissa), exponent, Number::normalized());
+        return Number(false, mantissa, exponent, Number::normalized());
+    }
+
+    static Number
+    makeNumber(uint64_t mantissa, int32_t exponent)
+    {
+        return Number(false, mantissa, exponent, Number::normalized());
+    }
+
+    operator bool() const
+    {
+        return good_;
+    }
+
+    Expected<Bytes, HostFunctionError>
+    toBytes() const
+    {
+        if (!good_)
+            return Unexpected(HostFunctionError::FLOAT_COMPUTATION_ERROR);
+
+        auto const m = mantissa();
+        auto const e = exponent();
+
+        uint64_t v = m >= 0 ? STAmount::cPositive : 0;
+        v |= STAmount::cIssuedCurrency;
+
+        uint64_t const absM = std::abs(m);
+        if (!absM)
+        {
+            return floatNull;
+        }
+        else if (absM > maxEncodedMantissa)
+        {
+            return Unexpected(HostFunctionError::FLOAT_COMPUTATION_ERROR);  // LCOV_EXCL_LINE
+        }
+        v |= absM;
+
+        if (e > wasmMaxExponent)
+            return Unexpected(HostFunctionError::FLOAT_COMPUTATION_ERROR);
+        else if (e < wasmMinExponent)
+            return floatNull;
+        uint64_t const normExp = e - wasmMinExponent + 1;  //+97
+        v |= normExp << encodedMantissaBits;
+
+        Serializer msg;
+        msg.add64(v);
+        auto const data = msg.getData();
+
+#ifdef DEBUG_OUTPUT
+        std::cout << "m: " << std::setw(20) << mantissa() << ", e: " << std::setw(12) << exponent() << ", hex: ";
+        std::cout << std::hex << std::uppercase << std::setfill('0');
+        for (auto const& c : data)
+            std::cout << std::setw(2) << (unsigned)c << " ";
+        std::cout << std::dec << std::setfill(' ') << std::endl;
+#endif
+
+        return data;
+    }
+};
+
+Bytes const Number2::floatNull = {0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+
+struct FloatState
+{
+    Number::rounding_mode oldMode_;
+    MantissaRange::mantissa_scale oldScale_;
+    bool good_;
+
+    FloatState(int32_t mode) : oldMode_(Number::getround()), oldScale_(Number::getMantissaScale()), good_(false)
+    {
+        if (mode < Number::rounding_mode::to_nearest || mode > Number::rounding_mode::upward)
+            return;
+
+        Number::setround(static_cast<Number::rounding_mode>(mode));
+        Number::setMantissaScale(MantissaRange::mantissa_scale::small);
+        good_ = true;
+    }
+
+    ~FloatState()
+    {
+        Number::setround(oldMode_);
+        Number::setMantissaScale(oldScale_);
+    }
+
+    operator bool() const
+    {
+        return good_;
+    }
+};
+
+}  // namespace detail
+
+std::string
+floatToString(Slice const& data)
+{
+    // set default mode as we don't expect it will be used here
+    detail::FloatState rm(Number::rounding_mode::to_nearest);
+    detail::Number2 const num(data);
+    if (!num)
+    {
+        std::string hex;
+        hex.reserve(data.size() * 2);
+        boost::algorithm::hex(data.begin(), data.end(), std::back_inserter(hex));
+        return "Invalid data: " + hex;
+    }
+
+    auto const s = to_string(num);
+    return s;
+}
+
+Expected<Bytes, HostFunctionError>
+floatFromIntImpl(int64_t x, int32_t mode)
+{
+    try
+    {
+        detail::FloatState rm(mode);
+        if (!rm)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+
+        detail::Number2 num(x);
+        return num.toBytes();
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+    }
+    return Unexpected(HostFunctionError::FLOAT_COMPUTATION_ERROR);
+    // LCOV_EXCL_STOP
+}
+
+Expected<Bytes, HostFunctionError>
+floatFromUintImpl(uint64_t x, int32_t mode)
+{
+    try
+    {
+        detail::FloatState rm(mode);
+        if (!rm)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+
+        detail::Number2 num(x);
+        auto r = num.toBytes();
+        return r;
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+    }
+    return Unexpected(HostFunctionError::FLOAT_COMPUTATION_ERROR);
+    // LCOV_EXCL_STOP
+}
+
+Expected<Bytes, HostFunctionError>
+floatSetImpl(int64_t mantissa, int32_t exponent, int32_t mode)
+{
+    try
+    {
+        detail::FloatState rm(mode);
+        if (!rm)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+        detail::Number2 num(mantissa, exponent);
+        if (!num)
+            return Unexpected(HostFunctionError::FLOAT_COMPUTATION_ERROR);
+        return num.toBytes();
+    }
+    catch (...)
+    {
+    }
+    return Unexpected(HostFunctionError::FLOAT_COMPUTATION_ERROR);
+}
+
+Expected<int32_t, HostFunctionError>
+floatCompareImpl(Slice const& x, Slice const& y)
+{
+    try
+    {
+        // set default mode as we don't expect it will be used here
+        detail::FloatState rm(Number::rounding_mode::to_nearest);
+        detail::Number2 xx(x);
+        if (!xx)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+        detail::Number2 yy(y);
+        if (!yy)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+        return xx < yy ? 2 : (xx == yy ? 0 : 1);
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+    }
+    return Unexpected(HostFunctionError::FLOAT_COMPUTATION_ERROR);
+    // LCOV_EXCL_STOP
+}
+
+Expected<Bytes, HostFunctionError>
+floatAddImpl(Slice const& x, Slice const& y, int32_t mode)
+{
+    try
+    {
+        detail::FloatState rm(mode);
+        if (!rm)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+
+        detail::Number2 xx(x);
+        if (!xx)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+        detail::Number2 yy(y);
+        if (!yy)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+        detail::Number2 res = xx + yy;
+
+        return res.toBytes();
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+    }
+    return Unexpected(HostFunctionError::FLOAT_COMPUTATION_ERROR);
+    // LCOV_EXCL_STOP
+}
+
+Expected<Bytes, HostFunctionError>
+floatSubtractImpl(Slice const& x, Slice const& y, int32_t mode)
+{
+    try
+    {
+        detail::FloatState rm(mode);
+        if (!rm)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+        detail::Number2 xx(x);
+        if (!xx)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+        detail::Number2 yy(y);
+        if (!yy)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+        detail::Number2 res = xx - yy;
+
+        return res.toBytes();
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+    }
+    return Unexpected(HostFunctionError::FLOAT_COMPUTATION_ERROR);
+    // LCOV_EXCL_STOP
+}
+
+Expected<Bytes, HostFunctionError>
+floatMultiplyImpl(Slice const& x, Slice const& y, int32_t mode)
+{
+    try
+    {
+        detail::FloatState rm(mode);
+        if (!rm)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+        detail::Number2 xx(x);
+        if (!xx)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+        detail::Number2 yy(y);
+        if (!yy)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+        detail::Number2 res = xx * yy;
+
+        return res.toBytes();
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+    }
+    return Unexpected(HostFunctionError::FLOAT_COMPUTATION_ERROR);
+    // LCOV_EXCL_STOP
+}
+
+Expected<Bytes, HostFunctionError>
+floatDivideImpl(Slice const& x, Slice const& y, int32_t mode)
+{
+    try
+    {
+        detail::FloatState rm(mode);
+        if (!rm)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+        detail::Number2 xx(x);
+        if (!xx)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+        detail::Number2 yy(y);
+        if (!yy)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+        detail::Number2 res = xx / yy;
+
+        return res.toBytes();
+    }
+    catch (...)
+    {
+    }
+    return Unexpected(HostFunctionError::FLOAT_COMPUTATION_ERROR);
+}
+
+Expected<Bytes, HostFunctionError>
+floatRootImpl(Slice const& x, int32_t n, int32_t mode)
+{
+    try
+    {
+        if (n < 1)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+
+        detail::FloatState rm(mode);
+        if (!rm)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+
+        detail::Number2 xx(x);
+        if (!xx)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+
+        detail::Number2 res(root(xx, n));
+
+        return res.toBytes();
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+    }
+    return Unexpected(HostFunctionError::FLOAT_COMPUTATION_ERROR);
+    // LCOV_EXCL_STOP
+}
+
+Expected<Bytes, HostFunctionError>
+floatPowerImpl(Slice const& x, int32_t n, int32_t mode)
+{
+    try
+    {
+        if ((n < 0) || (n > wasmMaxExponent))
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+
+        detail::FloatState rm(mode);
+        if (!rm)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+
+        detail::Number2 xx(x);
+        if (!xx)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+        if (xx == Number() && !n)
+            return Unexpected(HostFunctionError::INVALID_PARAMS);
+
+        detail::Number2 res(power(xx, n, 1));
+
+        return res.toBytes();
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+    }
+    return Unexpected(HostFunctionError::FLOAT_COMPUTATION_ERROR);
+    // LCOV_EXCL_STOP
+}
+
+Expected<Bytes, HostFunctionError>
+floatLogImpl(Slice const& x, int32_t mode)
+{
+    try
+    {
+        detail::FloatState rm(mode);
+        if (!rm)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+
+        detail::Number2 xx(x);
+        if (!xx)
+            return Unexpected(HostFunctionError::FLOAT_INPUT_MALFORMED);
+
+        detail::Number2 res(log10(xx));
+
+        return res.toBytes();
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+    }
+    return Unexpected(HostFunctionError::FLOAT_COMPUTATION_ERROR);
+    // LCOV_EXCL_STOP
+}
+
+}  // namespace wasm_float
+
+// =========================================================
+// ACTUAL HOST FUNCTIONS
+// =========================================================
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::floatFromInt(int64_t x, int32_t mode)
+{
+    return wasm_float::floatFromIntImpl(x, mode);
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::floatFromUint(uint64_t x, int32_t mode)
+{
+    return wasm_float::floatFromUintImpl(x, mode);
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::floatSet(int64_t mantissa, int32_t exponent, int32_t mode)
+{
+    return wasm_float::floatSetImpl(mantissa, exponent, mode);
+}
+
+Expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::floatCompare(Slice const& x, Slice const& y)
+{
+    return wasm_float::floatCompareImpl(x, y);
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::floatAdd(Slice const& x, Slice const& y, int32_t mode)
+{
+    return wasm_float::floatAddImpl(x, y, mode);
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::floatSubtract(Slice const& x, Slice const& y, int32_t mode)
+{
+    return wasm_float::floatSubtractImpl(x, y, mode);
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::floatMultiply(Slice const& x, Slice const& y, int32_t mode)
+{
+    return wasm_float::floatMultiplyImpl(x, y, mode);
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::floatDivide(Slice const& x, Slice const& y, int32_t mode)
+{
+    return wasm_float::floatDivideImpl(x, y, mode);
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::floatRoot(Slice const& x, int32_t n, int32_t mode)
+{
+    return wasm_float::floatRootImpl(x, n, mode);
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::floatPower(Slice const& x, int32_t n, int32_t mode)
+{
+    return wasm_float::floatPowerImpl(x, n, mode);
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::floatLog(Slice const& x, int32_t mode)
+{
+    return wasm_float::floatLogImpl(x, mode);
+}
+
+}  // namespace xrpl

src/xrpld/app/wasm/detail/HostFuncImplGetter.cpp

@@ -0,0 +1,408 @@
+#include <xrpld/app/wasm/HostFuncImpl.h>
+
+#include <xrpl/protocol/STBitString.h>
+#include <xrpl/protocol/digest.h>
+
+namespace xrpl {
+
+typedef std::variant<STBase const*, uint256 const*> FieldValue;
+
+namespace detail {
+
+template <class T>
+Bytes
+getIntBytes(STBase const* obj)
+{
+    static_assert(std::is_integral<T>::value, "Only integral types");
+
+    auto const& num(static_cast<STInteger<T> const*>(obj));
+    T const data = adjustWasmEndianess(num->value());
+    auto const* b = reinterpret_cast<uint8_t const*>(&data);
+    auto const* e = reinterpret_cast<uint8_t const*>(&data + 1);
+    return Bytes{b, e};
+}
+
+static Expected<Bytes, HostFunctionError>
+getAnyFieldData(STBase const* obj)
+{
+    if (!obj)
+        return Unexpected(HostFunctionError::FIELD_NOT_FOUND);
+
+    auto const stype = obj->getSType();
+    switch (stype)
+    {
+        // LCOV_EXCL_START
+        case STI_UNKNOWN:
+        case STI_NOTPRESENT:
+            return Unexpected(HostFunctionError::FIELD_NOT_FOUND);
+            break;
+        // LCOV_EXCL_STOP
+        case STI_OBJECT:
+        case STI_ARRAY:
+        case STI_VECTOR256:
+            return Unexpected(HostFunctionError::NOT_LEAF_FIELD);
+            break;
+        case STI_ACCOUNT: {
+            auto const* account(static_cast<STAccount const*>(obj));
+            auto const& data = account->value();
+            return Bytes{data.begin(), data.end()};
+        }
+        break;
+        case STI_AMOUNT:
+            // will be processed by serializer
+            break;
+        case STI_ISSUE: {
+            auto const* issue(static_cast<STIssue const*>(obj));
+            Asset const& asset(issue->value());
+            // XRP and IOU will be processed by serializer
+            if (asset.holds<MPTIssue>())
+            {
+                // MPT
+                auto const& mptIssue = asset.get<MPTIssue>();
+                auto const& mptID = mptIssue.getMptID();
+                return Bytes{mptID.cbegin(), mptID.cend()};
+            }
+        }
+        break;
+        case STI_VL: {
+            auto const* vl(static_cast<STBlob const*>(obj));
+            auto const& data = vl->value();
+            return Bytes{data.begin(), data.end()};
+        }
+        break;
+        case STI_UINT16: {
+            return getIntBytes<std::uint16_t>(obj);
+        }
+        break;
+        case STI_UINT32: {
+            return getIntBytes<std::uint32_t>(obj);
+        }
+        // LCOV_EXCL_START
+        case STI_UINT64: {
+            return getIntBytes<std::uint64_t>(obj);
+        }
+        break;
+        case STI_INT32: {
+            return getIntBytes<std::int32_t>(obj);
+        }
+        break;
+        case STI_INT64: {
+            return getIntBytes<std::int64_t>(obj);
+        }
+        // LCOV_EXCL_STOP
+        break;
+        case STI_UINT256: {
+            auto const* uint256Obj(static_cast<STUInt256 const*>(obj));
+            auto const& data = uint256Obj->value();
+            return Bytes{data.begin(), data.end()};
+        }
+        break;
+        default:
+            break;  // default to serializer
+    }
+
+    Serializer msg;
+    obj->add(msg);
+    auto const data = msg.getData();
+
+    return data;
+}
+
+static Expected<Bytes, HostFunctionError>
+getAnyFieldData(FieldValue const& variantObj)
+{
+    if (STBase const* const* obj = std::get_if<STBase const*>(&variantObj))
+    {
+        return getAnyFieldData(*obj);
+    }
+    else if (uint256 const* const* u = std::get_if<uint256 const*>(&variantObj))
+    {
+        return Bytes((*u)->begin(), (*u)->end());
+    }
+
+    return Unexpected(HostFunctionError::INTERNAL);  // LCOV_EXCL_LINE
+}
+
+static inline bool
+noField(STBase const* field)
+{
+    return !field || (STI_NOTPRESENT == field->getSType()) || (STI_UNKNOWN == field->getSType());
+}
+
+static Expected<FieldValue, HostFunctionError>
+locateField(STObject const& obj, Slice const& locator)
+{
+    if (locator.empty() || (locator.size() & 3))  // must be multiple of 4
+        return Unexpected(HostFunctionError::LOCATOR_MALFORMED);
+
+    static_assert(maxWasmParamLength % sizeof(int32_t) == 0);
+    int32_t locBuf[maxWasmParamLength / sizeof(int32_t)];
+    int32_t const* locPtr = &locBuf[0];
+    int32_t const locSize = locator.size() / sizeof(int32_t);
+
+    {
+        uintptr_t const p = reinterpret_cast<uintptr_t>(locator.data());
+        if (p & (alignof(int32_t) - 1))  // unaligned
+            memcpy(&locBuf[0], locator.data(), locator.size());
+        else
+            locPtr = reinterpret_cast<int32_t const*>(locator.data());
+    }
+
+    STBase const* field = nullptr;
+    auto const& knownSFields = SField::getKnownCodeToField();
+
+    {
+        int32_t const sfieldCode = adjustWasmEndianess(locPtr[0]);
+        auto const it = knownSFields.find(sfieldCode);
+        if (it == knownSFields.end())
+            return Unexpected(HostFunctionError::INVALID_FIELD);
+
+        auto const& fname(*it->second);
+        field = obj.peekAtPField(fname);
+        if (noField(field))
+            return Unexpected(HostFunctionError::FIELD_NOT_FOUND);
+    }
+
+    for (int i = 1; i < locSize; ++i)
+    {
+        int32_t const sfieldCode = adjustWasmEndianess(locPtr[i]);
+
+        if (STI_ARRAY == field->getSType())
+        {
+            auto const* arr = static_cast<STArray const*>(field);
+            if (sfieldCode >= arr->size())
+                return Unexpected(HostFunctionError::INDEX_OUT_OF_BOUNDS);
+            field = &(arr->operator[](sfieldCode));
+        }
+        else if (STI_OBJECT == field->getSType())
+        {
+            auto const* o = static_cast<STObject const*>(field);
+
+            auto const it = knownSFields.find(sfieldCode);
+            if (it == knownSFields.end())
+                return Unexpected(HostFunctionError::INVALID_FIELD);
+
+            auto const& fname(*it->second);
+            field = o->peekAtPField(fname);
+        }
+        else if (STI_VECTOR256 == field->getSType())
+        {
+            auto const* v = static_cast<STVector256 const*>(field);
+            if (sfieldCode >= v->size())
+                return Unexpected(HostFunctionError::INDEX_OUT_OF_BOUNDS);
+            return FieldValue(&(v->operator[](sfieldCode)));
+        }
+        else  // simple field must be the last one
+        {
+            return Unexpected(HostFunctionError::LOCATOR_MALFORMED);
+        }
+
+        if (noField(field))
+            return Unexpected(HostFunctionError::FIELD_NOT_FOUND);
+    }
+
+    return FieldValue(field);
+}
+
+static inline Expected<int32_t, HostFunctionError>
+getArrayLen(FieldValue const& variantField)
+{
+    if (STBase const* const* field = std::get_if<STBase const*>(&variantField))
+    {
+        if ((*field)->getSType() == STI_VECTOR256)
+            return static_cast<STVector256 const*>(*field)->size();
+        if ((*field)->getSType() == STI_ARRAY)
+            return static_cast<STArray const*>(*field)->size();
+    }
+    // uint256 is not an array so that variant should still return NO_ARRAY
+
+    return Unexpected(HostFunctionError::NO_ARRAY);  // LCOV_EXCL_LINE
+}
+
+}  // namespace detail
+
+Expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::cacheLedgerObj(uint256 const& objId, int32_t cacheIdx)
+{
+    auto const& keylet = keylet::unchecked(objId);
+    if (cacheIdx < 0 || cacheIdx > MAX_CACHE)
+        return Unexpected(HostFunctionError::SLOT_OUT_RANGE);
+
+    if (cacheIdx == 0)
+    {
+        for (cacheIdx = 0; cacheIdx < MAX_CACHE; ++cacheIdx)
+            if (!cache[cacheIdx])
+                break;
+    }
+    else
+    {
+        cacheIdx--;  // convert to 0-based index
+    }
+
+    if (cacheIdx >= MAX_CACHE)
+        return Unexpected(HostFunctionError::SLOTS_FULL);
+
+    cache[cacheIdx] = ctx.view().read(keylet);
+    if (!cache[cacheIdx])
+        return Unexpected(HostFunctionError::LEDGER_OBJ_NOT_FOUND);
+    return cacheIdx + 1;  // return 1-based index
+}
+
+// Subsection: top level getters
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::getTxField(SField const& fname)
+{
+    return detail::getAnyFieldData(ctx.tx.peekAtPField(fname));
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::getCurrentLedgerObjField(SField const& fname)
+{
+    auto const sle = getCurrentLedgerObj();
+    if (!sle.has_value())
+        return Unexpected(sle.error());
+    return detail::getAnyFieldData(sle.value()->peekAtPField(fname));
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::getLedgerObjField(int32_t cacheIdx, SField const& fname)
+{
+    auto const normalizedIdx = normalizeCacheIndex(cacheIdx);
+    if (!normalizedIdx.has_value())
+        return Unexpected(normalizedIdx.error());
+    return detail::getAnyFieldData(cache[normalizedIdx.value()]->peekAtPField(fname));
+}
+
+// Subsection: nested getters
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::getTxNestedField(Slice const& locator)
+{
+    auto const r = detail::locateField(ctx.tx, locator);
+    if (!r)
+        return Unexpected(r.error());
+
+    return detail::getAnyFieldData(r.value());
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::getCurrentLedgerObjNestedField(Slice const& locator)
+{
+    auto const sle = getCurrentLedgerObj();
+    if (!sle.has_value())
+        return Unexpected(sle.error());
+
+    auto const r = detail::locateField(*sle.value(), locator);
+    if (!r)
+        return Unexpected(r.error());
+
+    return detail::getAnyFieldData(r.value());
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::getLedgerObjNestedField(int32_t cacheIdx, Slice const& locator)
+{
+    auto const normalizedIdx = normalizeCacheIndex(cacheIdx);
+    if (!normalizedIdx.has_value())
+        return Unexpected(normalizedIdx.error());
+
+    auto const r = detail::locateField(*cache[normalizedIdx.value()], locator);
+    if (!r)
+        return Unexpected(r.error());
+
+    return detail::getAnyFieldData(r.value());
+}
+
+// Subsection: array length getters
+
+Expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::getTxArrayLen(SField const& fname)
+{
+    if (fname.fieldType != STI_ARRAY && fname.fieldType != STI_VECTOR256)
+        return Unexpected(HostFunctionError::NO_ARRAY);
+
+    auto const* field = ctx.tx.peekAtPField(fname);
+    if (detail::noField(field))
+        return Unexpected(HostFunctionError::FIELD_NOT_FOUND);
+
+    return detail::getArrayLen(field);
+}
+
+Expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::getCurrentLedgerObjArrayLen(SField const& fname)
+{
+    if (fname.fieldType != STI_ARRAY && fname.fieldType != STI_VECTOR256)
+        return Unexpected(HostFunctionError::NO_ARRAY);
+
+    auto const sle = getCurrentLedgerObj();
+    if (!sle.has_value())
+        return Unexpected(sle.error());
+
+    auto const* field = sle.value()->peekAtPField(fname);
+    if (detail::noField(field))
+        return Unexpected(HostFunctionError::FIELD_NOT_FOUND);
+
+    return detail::getArrayLen(field);
+}
+
+Expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::getLedgerObjArrayLen(int32_t cacheIdx, SField const& fname)
+{
+    if (fname.fieldType != STI_ARRAY && fname.fieldType != STI_VECTOR256)
+        return Unexpected(HostFunctionError::NO_ARRAY);
+
+    auto const normalizedIdx = normalizeCacheIndex(cacheIdx);
+    if (!normalizedIdx.has_value())
+        return Unexpected(normalizedIdx.error());
+
+    auto const* field = cache[normalizedIdx.value()]->peekAtPField(fname);
+    if (detail::noField(field))
+        return Unexpected(HostFunctionError::FIELD_NOT_FOUND);
+
+    return detail::getArrayLen(field);
+}
+
+// Subsection: nested array length getters
+
+Expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::getTxNestedArrayLen(Slice const& locator)
+{
+    auto const r = detail::locateField(ctx.tx, locator);
+    if (!r)
+        return Unexpected(r.error());
+
+    auto const& field = r.value();
+    return detail::getArrayLen(field);
+}
+
+Expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::getCurrentLedgerObjNestedArrayLen(Slice const& locator)
+{
+    auto const sle = getCurrentLedgerObj();
+    if (!sle.has_value())
+        return Unexpected(sle.error());
+    auto const r = detail::locateField(*sle.value(), locator);
+    if (!r)
+        return Unexpected(r.error());
+
+    auto const& field = r.value();
+    return detail::getArrayLen(field);
+}
+
+Expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::getLedgerObjNestedArrayLen(int32_t cacheIdx, Slice const& locator)
+{
+    auto const normalizedIdx = normalizeCacheIndex(cacheIdx);
+    if (!normalizedIdx.has_value())
+        return Unexpected(normalizedIdx.error());
+
+    auto const r = detail::locateField(*cache[normalizedIdx.value()], locator);
+    if (!r)
+        return Unexpected(r.error());
+
+    auto const& field = r.value();
+    return detail::getArrayLen(field);
+}
+
+}  // namespace xrpl

src/xrpld/app/wasm/detail/HostFuncImplKeylet.cpp

@@ -0,0 +1,204 @@
+#include <xrpld/app/wasm/HostFuncImpl.h>
+
+#include <xrpl/protocol/STBitString.h>
+#include <xrpl/protocol/digest.h>
+
+namespace xrpl {
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::accountKeylet(AccountID const& account)
+{
+    if (!account)
+        return Unexpected(HostFunctionError::INVALID_ACCOUNT);
+    auto const keylet = keylet::account(account);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::ammKeylet(Asset const& issue1, Asset const& issue2)
+{
+    if (issue1 == issue2)
+        return Unexpected(HostFunctionError::INVALID_PARAMS);
+
+    // note: this should be removed with the MPT DEX amendment
+    if (issue1.holds<MPTIssue>() || issue2.holds<MPTIssue>())
+        return Unexpected(HostFunctionError::INVALID_PARAMS);
+
+    auto const keylet = keylet::amm(issue1, issue2);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::checkKeylet(AccountID const& account, std::uint32_t seq)
+{
+    if (!account)
+        return Unexpected(HostFunctionError::INVALID_ACCOUNT);
+    auto const keylet = keylet::check(account, seq);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::credentialKeylet(AccountID const& subject, AccountID const& issuer, Slice const& credentialType)
+{
+    if (!subject || !issuer)
+        return Unexpected(HostFunctionError::INVALID_ACCOUNT);
+
+    if (credentialType.empty() || credentialType.size() > maxCredentialTypeLength)
+        return Unexpected(HostFunctionError::INVALID_PARAMS);
+
+    auto const keylet = keylet::credential(subject, issuer, credentialType);
+
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::didKeylet(AccountID const& account)
+{
+    if (!account)
+        return Unexpected(HostFunctionError::INVALID_ACCOUNT);
+    auto const keylet = keylet::did(account);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::delegateKeylet(AccountID const& account, AccountID const& authorize)
+{
+    if (!account || !authorize)
+        return Unexpected(HostFunctionError::INVALID_ACCOUNT);
+    if (account == authorize)
+        return Unexpected(HostFunctionError::INVALID_PARAMS);
+    auto const keylet = keylet::delegate(account, authorize);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::depositPreauthKeylet(AccountID const& account, AccountID const& authorize)
+{
+    if (!account || !authorize)
+        return Unexpected(HostFunctionError::INVALID_ACCOUNT);
+    if (account == authorize)
+        return Unexpected(HostFunctionError::INVALID_PARAMS);
+    auto const keylet = keylet::depositPreauth(account, authorize);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::escrowKeylet(AccountID const& account, std::uint32_t seq)
+{
+    if (!account)
+        return Unexpected(HostFunctionError::INVALID_ACCOUNT);
+    auto const keylet = keylet::escrow(account, seq);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::lineKeylet(AccountID const& account1, AccountID const& account2, Currency const& currency)
+{
+    if (!account1 || !account2)
+        return Unexpected(HostFunctionError::INVALID_ACCOUNT);
+    if (account1 == account2)
+        return Unexpected(HostFunctionError::INVALID_PARAMS);
+    if (currency.isZero())
+        return Unexpected(HostFunctionError::INVALID_PARAMS);
+
+    auto const keylet = keylet::line(account1, account2, currency);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::mptIssuanceKeylet(AccountID const& issuer, std::uint32_t seq)
+{
+    if (!issuer)
+        return Unexpected(HostFunctionError::INVALID_ACCOUNT);
+
+    auto const keylet = keylet::mptIssuance(seq, issuer);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::mptokenKeylet(MPTID const& mptid, AccountID const& holder)
+{
+    if (!mptid)
+        return Unexpected(HostFunctionError::INVALID_PARAMS);
+    if (!holder)
+        return Unexpected(HostFunctionError::INVALID_ACCOUNT);
+
+    auto const keylet = keylet::mptoken(mptid, holder);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::nftOfferKeylet(AccountID const& account, std::uint32_t seq)
+{
+    if (!account)
+        return Unexpected(HostFunctionError::INVALID_ACCOUNT);
+    auto const keylet = keylet::nftoffer(account, seq);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::offerKeylet(AccountID const& account, std::uint32_t seq)
+{
+    if (!account)
+        return Unexpected(HostFunctionError::INVALID_ACCOUNT);
+    auto const keylet = keylet::offer(account, seq);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::oracleKeylet(AccountID const& account, std::uint32_t documentId)
+{
+    if (!account)
+        return Unexpected(HostFunctionError::INVALID_ACCOUNT);
+    auto const keylet = keylet::oracle(account, documentId);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::paychanKeylet(AccountID const& account, AccountID const& destination, std::uint32_t seq)
+{
+    if (!account || !destination)
+        return Unexpected(HostFunctionError::INVALID_ACCOUNT);
+    if (account == destination)
+        return Unexpected(HostFunctionError::INVALID_PARAMS);
+    auto const keylet = keylet::payChan(account, destination, seq);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::permissionedDomainKeylet(AccountID const& account, std::uint32_t seq)
+{
+    if (!account)
+        return Unexpected(HostFunctionError::INVALID_ACCOUNT);
+    auto const keylet = keylet::permissionedDomain(account, seq);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::signersKeylet(AccountID const& account)
+{
+    if (!account)
+        return Unexpected(HostFunctionError::INVALID_ACCOUNT);
+    auto const keylet = keylet::signers(account);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::ticketKeylet(AccountID const& account, std::uint32_t seq)
+{
+    if (!account)
+        return Unexpected(HostFunctionError::INVALID_ACCOUNT);
+    auto const keylet = keylet::ticket(account, seq);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::vaultKeylet(AccountID const& account, std::uint32_t seq)
+{
+    if (!account)
+        return Unexpected(HostFunctionError::INVALID_ACCOUNT);
+    auto const keylet = keylet::vault(account, seq);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+}  // namespace xrpl

src/xrpld/app/wasm/detail/HostFuncImplLedgerHeader.cpp

@@ -0,0 +1,50 @@
+#include <xrpld/app/misc/AmendmentTable.h>
+#include <xrpld/app/wasm/HostFuncImpl.h>
+
+#include <xrpl/protocol/digest.h>
+
+namespace xrpl {
+
+// =========================================================
+// SECTION: LEDGER HEADER FUNCTIONS
+// =========================================================
+
+Expected<std::uint32_t, HostFunctionError>
+WasmHostFunctionsImpl::getLedgerSqn()
+{
+    return ctx.view().seq();
+}
+
+Expected<std::uint32_t, HostFunctionError>
+WasmHostFunctionsImpl::getParentLedgerTime()
+{
+    return ctx.view().parentCloseTime().time_since_epoch().count();
+}
+
+Expected<Hash, HostFunctionError>
+WasmHostFunctionsImpl::getParentLedgerHash()
+{
+    return ctx.view().header().parentHash;
+}
+
+Expected<std::uint32_t, HostFunctionError>
+WasmHostFunctionsImpl::getBaseFee()
+{
+    return ctx.view().fees().base.drops();
+}
+
+Expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::isAmendmentEnabled(uint256 const& amendmentId)
+{
+    return ctx.view().rules().enabled(amendmentId);
+}
+
+Expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::isAmendmentEnabled(std::string_view const& amendmentName)
+{
+    auto const& table = ctx.app.getAmendmentTable();
+    auto const amendment = table.find(std::string(amendmentName));
+    return ctx.view().rules().enabled(amendment);
+}
+
+}  // namespace xrpl

src/xrpld/app/wasm/detail/HostFuncImplNFT.cpp

@@ -0,0 +1,68 @@
+#include <xrpld/app/tx/detail/NFTokenUtils.h>
+#include <xrpld/app/wasm/HostFuncImpl.h>
+
+#include <xrpl/protocol/STBitString.h>
+#include <xrpl/protocol/digest.h>
+
+namespace xrpl {
+
+// =========================================================
+// SECTION: NFT UTILS
+// =========================================================
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::getNFT(AccountID const& account, uint256 const& nftId)
+{
+    if (!account)
+        return Unexpected(HostFunctionError::INVALID_ACCOUNT);
+
+    if (!nftId)
+        return Unexpected(HostFunctionError::INVALID_PARAMS);
+
+    auto obj = nft::findToken(ctx.view(), account, nftId);
+    if (!obj)
+        return Unexpected(HostFunctionError::LEDGER_OBJ_NOT_FOUND);
+
+    auto objUri = obj->at(~sfURI);
+    if (!objUri)
+        return Unexpected(HostFunctionError::FIELD_NOT_FOUND);
+
+    Slice const s = objUri->value();
+    return Bytes(s.begin(), s.end());
+}
+
+Expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::getNFTIssuer(uint256 const& nftId)
+{
+    auto const issuer = nft::getIssuer(nftId);
+    if (!issuer)
+        return Unexpected(HostFunctionError::INVALID_PARAMS);
+
+    return Bytes{issuer.begin(), issuer.end()};
+}
+
+Expected<std::uint32_t, HostFunctionError>
+WasmHostFunctionsImpl::getNFTTaxon(uint256 const& nftId)
+{
+    return nft::toUInt32(nft::getTaxon(nftId));
+}
+
+Expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::getNFTFlags(uint256 const& nftId)
+{
+    return nft::getFlags(nftId);
+}
+
+Expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::getNFTTransferFee(uint256 const& nftId)
+{
+    return nft::getTransferFee(nftId);
+}
+
+Expected<std::uint32_t, HostFunctionError>
+WasmHostFunctionsImpl::getNFTSerial(uint256 const& nftId)
+{
+    return nft::getSerial(nftId);
+}
+
+}  // namespace xrpl

src/xrpld/app/wasm/detail/HostFuncImplTrace.cpp

@@ -0,0 +1,60 @@
+#include <xrpld/app/wasm/HostFuncImpl.h>
+
+#include <xrpl/protocol/STBitString.h>
+#include <xrpl/protocol/digest.h>
+
+#ifdef _DEBUG
+// #define DEBUG_OUTPUT 1
+#endif
+
+namespace xrpl {
+
+Expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::trace(std::string_view const& msg, Slice const& data, bool asHex)
+{
+    if (!asHex)
+    {
+        log(msg, [&data] { return std::string_view(reinterpret_cast<char const*>(data.data()), data.size()); });
+    }
+    else
+    {
+        log(msg, [&data] {
+            std::string hex;
+            hex.reserve(data.size() * 2);
+            boost::algorithm::hex(data.begin(), data.end(), std::back_inserter(hex));
+            return hex;
+        });
+    }
+
+    return 0;
+}
+
+Expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::traceNum(std::string_view const& msg, int64_t data)
+{
+    log(msg, [data] { return data; });
+    return 0;
+}
+
+Expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::traceAccount(std::string_view const& msg, AccountID const& account)
+{
+    log(msg, [&account] { return toBase58(account); });
+    return 0;
+}
+
+Expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::traceFloat(std::string_view const& msg, Slice const& data)
+{
+    log(msg, [&data] { return wasm_float::floatToString(data); });
+    return 0;
+}
+
+Expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::traceAmount(std::string_view const& msg, STAmount const& amount)
+{
+    log(msg, [&amount] { return amount.getFullText(); });
+    return 0;
+}
+
+}  // namespace xrpl

src/xrpld/app/wasm/detail/WasmVM.cpp

@@ -0,0 +1,202 @@
+#ifdef _DEBUG
+// #define DEBUG_OUTPUT 1
+#endif
+
+#include <xrpld/app/wasm/HostFunc.h>
+#include <xrpld/app/wasm/HostFuncWrapper.h>
+#include <xrpld/app/wasm/WasmiVM.h>
+
+#include <xrpl/basics/Log.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/LedgerFormats.h>
+
+#include <memory>
+
+namespace xrpl {
+
+static void
+setCommonHostFunctions(HostFunctions* hfs, ImportVec& i)
+{
+    // clang-format off
+    WASM_IMPORT_FUNC2(i, getLedgerSqn, "get_ledger_sqn", hfs,                                                   60);
+    WASM_IMPORT_FUNC2(i, getParentLedgerTime, "get_parent_ledger_time", hfs,                                    60);
+    WASM_IMPORT_FUNC2(i, getParentLedgerHash, "get_parent_ledger_hash", hfs,                                    60);
+    WASM_IMPORT_FUNC2(i, getBaseFee, "get_base_fee", hfs,                                                       60);
+    WASM_IMPORT_FUNC2(i, isAmendmentEnabled, "amendment_enabled", hfs,                                         100);
+
+    WASM_IMPORT_FUNC2(i, cacheLedgerObj, "cache_ledger_obj", hfs,                                            5'000);
+    WASM_IMPORT_FUNC2(i, getTxField, "get_tx_field", hfs,                                                       70);
+    WASM_IMPORT_FUNC2(i, getCurrentLedgerObjField, "get_current_ledger_obj_field", hfs,                         70);
+    WASM_IMPORT_FUNC2(i, getLedgerObjField, "get_ledger_obj_field", hfs,                                        70);
+    WASM_IMPORT_FUNC2(i, getTxNestedField, "get_tx_nested_field", hfs,                                         110);
+    WASM_IMPORT_FUNC2(i, getCurrentLedgerObjNestedField, "get_current_ledger_obj_nested_field", hfs,           110);
+    WASM_IMPORT_FUNC2(i, getLedgerObjNestedField, "get_ledger_obj_nested_field", hfs,                          110);
+    WASM_IMPORT_FUNC2(i, getTxArrayLen, "get_tx_array_len", hfs,                                                40);
+    WASM_IMPORT_FUNC2(i, getCurrentLedgerObjArrayLen, "get_current_ledger_obj_array_len", hfs,                  40);
+    WASM_IMPORT_FUNC2(i, getLedgerObjArrayLen, "get_ledger_obj_array_len", hfs,                                 40);
+    WASM_IMPORT_FUNC2(i, getTxNestedArrayLen, "get_tx_nested_array_len", hfs,                                   70);
+    WASM_IMPORT_FUNC2(i, getCurrentLedgerObjNestedArrayLen, "get_current_ledger_obj_nested_array_len",  hfs,    70);
+    WASM_IMPORT_FUNC2(i, getLedgerObjNestedArrayLen, "get_ledger_obj_nested_array_len", hfs,                    70);
+
+    WASM_IMPORT_FUNC2(i, checkSignature, "check_sig", hfs,                                                     300);
+    WASM_IMPORT_FUNC2(i, computeSha512HalfHash, "compute_sha512_half", hfs,                                   2000);
+
+    WASM_IMPORT_FUNC2(i, accountKeylet, "account_keylet", hfs,                                                 350);
+    WASM_IMPORT_FUNC2(i, ammKeylet, "amm_keylet", hfs,                                                         450);
+    WASM_IMPORT_FUNC2(i, checkKeylet, "check_keylet", hfs,                                                     350);
+    WASM_IMPORT_FUNC2(i, credentialKeylet, "credential_keylet", hfs,                                           350);
+    WASM_IMPORT_FUNC2(i, delegateKeylet, "delegate_keylet", hfs,                                               350);
+    WASM_IMPORT_FUNC2(i, depositPreauthKeylet, "deposit_preauth_keylet", hfs,                                  350);
+    WASM_IMPORT_FUNC2(i, didKeylet, "did_keylet", hfs,                                                         350);
+    WASM_IMPORT_FUNC2(i, escrowKeylet, "escrow_keylet", hfs,                                                   350);
+    WASM_IMPORT_FUNC2(i, lineKeylet, "line_keylet", hfs,                                                       400);
+    WASM_IMPORT_FUNC2(i, mptIssuanceKeylet, "mpt_issuance_keylet", hfs,                                        350);
+    WASM_IMPORT_FUNC2(i, mptokenKeylet, "mptoken_keylet", hfs,                                                 500);
+    WASM_IMPORT_FUNC2(i, nftOfferKeylet, "nft_offer_keylet", hfs,                                              350);
+    WASM_IMPORT_FUNC2(i, offerKeylet, "offer_keylet", hfs,                                                     350);
+    WASM_IMPORT_FUNC2(i, oracleKeylet, "oracle_keylet", hfs,                                                   350);
+    WASM_IMPORT_FUNC2(i, paychanKeylet, "paychan_keylet", hfs,                                                 350);
+    WASM_IMPORT_FUNC2(i, permissionedDomainKeylet, "permissioned_domain_keylet", hfs,                          350);
+    WASM_IMPORT_FUNC2(i, signersKeylet, "signers_keylet", hfs,                                                 350);
+    WASM_IMPORT_FUNC2(i, ticketKeylet, "ticket_keylet", hfs,                                                   350);
+    WASM_IMPORT_FUNC2(i, vaultKeylet, "vault_keylet", hfs,                                                     350);
+
+    WASM_IMPORT_FUNC2(i, getNFT, "get_nft", hfs,                                                              1000);
+    WASM_IMPORT_FUNC2(i, getNFTIssuer, "get_nft_issuer", hfs,                                                   70);
+    WASM_IMPORT_FUNC2(i, getNFTTaxon, "get_nft_taxon", hfs,                                                     60);
+    WASM_IMPORT_FUNC2(i, getNFTFlags, "get_nft_flags", hfs,                                                     60);
+    WASM_IMPORT_FUNC2(i, getNFTTransferFee, "get_nft_transfer_fee", hfs,                                        60);
+    WASM_IMPORT_FUNC2(i, getNFTSerial, "get_nft_serial", hfs,                                                   60);
+
+    WASM_IMPORT_FUNC (i, trace, hfs,                                                                           500);
+    WASM_IMPORT_FUNC2(i, traceNum, "trace_num", hfs,                                                           500);
+    WASM_IMPORT_FUNC2(i, traceAccount, "trace_account", hfs,                                                   500);
+    WASM_IMPORT_FUNC2(i, traceFloat, "trace_opaque_float", hfs,                                                500);
+    WASM_IMPORT_FUNC2(i, traceAmount, "trace_amount", hfs,                                                     500);
+
+    WASM_IMPORT_FUNC2(i, floatFromInt, "float_from_int", hfs,                                                  100);
+    WASM_IMPORT_FUNC2(i, floatFromUint, "float_from_uint", hfs,                                                130);
+    WASM_IMPORT_FUNC2(i, floatSet, "float_set", hfs,                                                           100);
+    WASM_IMPORT_FUNC2(i, floatCompare, "float_compare", hfs,                                                    80);
+    WASM_IMPORT_FUNC2(i, floatAdd, "float_add", hfs,                                                           160);
+    WASM_IMPORT_FUNC2(i, floatSubtract, "float_subtract", hfs,                                                 160);
+    WASM_IMPORT_FUNC2(i, floatMultiply, "float_multiply", hfs,                                                 300);
+    WASM_IMPORT_FUNC2(i, floatDivide, "float_divide", hfs,                                                     300);
+    WASM_IMPORT_FUNC2(i, floatRoot, "float_root", hfs,                                                       5'500);
+    WASM_IMPORT_FUNC2(i, floatPower, "float_pow", hfs,                                                       5'500);
+    WASM_IMPORT_FUNC2(i, floatLog, "float_log", hfs,                                                        12'000);
+    // clang-format on
+}
+
+std::shared_ptr<ImportVec>
+createWasmImport(HostFunctions& hfs)
+{
+    std::shared_ptr<ImportVec> i(std::make_shared<ImportVec>());
+
+    setCommonHostFunctions(&hfs, *i);
+    WASM_IMPORT_FUNC2(*i, updateData, "update_data", &hfs, 1000);
+
+    return i;
+}
+
+Expected<EscrowResult, TER>
+runEscrowWasm(
+    Bytes const& wasmCode,
+    std::shared_ptr<HostFunctions> const& hfs,
+    std::string_view funcName,
+    std::vector<WasmParam> const& params,
+    int64_t gasLimit)
+{
+    //  create VM and set cost limit
+    auto& vm = WasmEngine::instance();
+    // vm.initMaxPages(MAX_PAGES);
+
+    auto const ret = vm.run(wasmCode, funcName, params, createWasmImport(*hfs), hfs, gasLimit, hfs->getJournal());
+
+    // std::cout << "runEscrowWasm, mod size: " << wasmCode.size()
+    //           << ", gasLimit: " << gasLimit << ", funcName: " << funcName;
+
+    if (!ret)
+    {
+#ifdef DEBUG_OUTPUT
+        std::cout << ", error: " << ret.error() << std::endl;
+#endif
+        return Unexpected<TER>(ret.error());
+    }
+
+#ifdef DEBUG_OUTPUT
+    std::cout << ", ret: " << ret->result << ", gas spent: " << ret->cost << std::endl;
+#endif
+    return EscrowResult{ret->result, ret->cost};
+}
+
+NotTEC
+preflightEscrowWasm(
+    Bytes const& wasmCode,
+    std::shared_ptr<HostFunctions> const& hfs,
+    std::string_view funcName,
+    std::vector<WasmParam> const& params)
+{
+    //  create VM and set cost limit
+    auto& vm = WasmEngine::instance();
+    // vm.initMaxPages(MAX_PAGES);
+
+    auto const ret = vm.check(wasmCode, funcName, params, createWasmImport(*hfs), hfs, hfs->getJournal());
+
+    return ret;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+WasmEngine::WasmEngine() : impl(std::make_unique<WasmiEngine>())
+{
+}
+
+WasmEngine&
+WasmEngine::instance()
+{
+    static WasmEngine e;
+    return e;
+}
+
+Expected<WasmResult<int32_t>, TER>
+WasmEngine::run(
+    Bytes const& wasmCode,
+    std::string_view funcName,
+    std::vector<WasmParam> const& params,
+    std::shared_ptr<ImportVec> const& imports,
+    std::shared_ptr<HostFunctions> const& hfs,
+    int64_t gasLimit,
+    beast::Journal j)
+{
+    return impl->run(wasmCode, funcName, params, imports, hfs, gasLimit, j);
+}
+
+NotTEC
+WasmEngine::check(
+    Bytes const& wasmCode,
+    std::string_view funcName,
+    std::vector<WasmParam> const& params,
+    std::shared_ptr<ImportVec> const& imports,
+    std::shared_ptr<HostFunctions> const& hfs,
+    beast::Journal j)
+{
+    return impl->check(wasmCode, funcName, params, imports, hfs, j);
+}
+
+void*
+WasmEngine::newTrap(std::string const& msg)
+{
+    return impl->newTrap(msg);
+}
+
+// LCOV_EXCL_START
+beast::Journal
+WasmEngine::getJournal() const
+{
+    return impl->getJournal();
+}
+// LCOV_EXCL_STOP
+
+}  // namespace xrpl

src/xrpld/app/wasm/detail/WasmiVM.cpp

@@ -0,0 +1,948 @@
+#include <xrpld/app/wasm/WasmiVM.h>
+
+#include <xrpl/basics/Log.h>
+
+#include <memory>
+
+#ifdef _DEBUG
+// #define DEBUG_OUTPUT 1
+#endif
+// #define SHOW_CALL_TIME 1
+
+namespace xrpl {
+
+namespace {
+
+void
+print_wasm_error(std::string_view msg, wasm_trap_t* trap, beast::Journal jlog)
+{
+#ifdef DEBUG_OUTPUT
+    auto& j = std::cerr;
+#else
+    auto j = jlog.warn();
+    if (jlog.active(beast::severities::kWarning))
+#endif
+    {
+        wasm_byte_vec_t error_message WASM_EMPTY_VEC;
+
+        if (trap)
+            wasm_trap_message(trap, &error_message);
+
+        if (error_message.size)
+        {
+            j << "WASMI Error: " << msg << ", " << std::string_view(error_message.data, error_message.size - 1);
+        }
+        else
+            j << "WASMI Error: " << msg;
+
+        if (error_message.size)
+            wasm_byte_vec_delete(&error_message);
+    }
+
+    if (trap)
+        wasm_trap_delete(trap);
+
+#ifdef DEBUG_OUTPUT
+    j << std::endl;
+#endif
+}
+// LCOV_EXCL_STOP
+
+}  // namespace
+
+InstancePtr
+InstanceWrapper::init(StorePtr& s, ModulePtr& m, WasmExternVec& expt, WasmExternVec const& imports, beast::Journal j)
+{
+    wasm_trap_t* trap = nullptr;
+    InstancePtr mi = InstancePtr(wasm_instance_new(s.get(), m.get(), &imports.vec_, &trap), &wasm_instance_delete);
+
+    if (!mi || trap)
+    {
+        print_wasm_error("can't create instance", trap, j);
+        throw std::runtime_error("can't create instance");
+    }
+    wasm_instance_exports(mi.get(), &expt.vec_);
+    return mi;
+}
+
+InstanceWrapper::InstanceWrapper() : instance_(nullptr, &wasm_instance_delete)
+{
+}
+
+// LCOV_EXCL_START
+InstanceWrapper::InstanceWrapper(InstanceWrapper&& o) : instance_(nullptr, &wasm_instance_delete)
+{
+    *this = std::move(o);
+}
+// LCOV_EXCL_STOP
+
+InstanceWrapper::InstanceWrapper(StorePtr& s, ModulePtr& m, WasmExternVec const& imports, beast::Journal j)
+    : store_(s.get()), instance_(init(s, m, exports_, imports, j)), j_(j)
+{
+}
+
+InstanceWrapper&
+InstanceWrapper::operator=(InstanceWrapper&& o)
+{
+    if (this == &o)
+        return *this;  // LCOV_EXCL_LINE
+
+    store_ = o.store_;
+    o.store_ = nullptr;
+    exports_ = std::move(o.exports_);
+    memIdx_ = o.memIdx_;
+    o.memIdx_ = -1;
+    instance_ = std::move(o.instance_);
+
+    j_ = o.j_;
+
+    return *this;
+}
+
+InstanceWrapper::operator bool() const
+{
+    return static_cast<bool>(instance_);
+}
+
+FuncInfo
+InstanceWrapper::getFunc(std::string_view funcName, WasmExporttypeVec const& exportTypes) const
+{
+    wasm_func_t const* f = nullptr;
+    wasm_functype_t const* ft = nullptr;
+
+    if (!instance_)
+        throw std::runtime_error("no instance");  // LCOV_EXCL_LINE
+
+    if (!exportTypes.vec_.size)
+        throw std::runtime_error("no export");  // LCOV_EXCL_LINE
+    if (exportTypes.vec_.size != exports_.vec_.size)
+        throw std::runtime_error("invalid export");  // LCOV_EXCL_LINE
+
+    for (unsigned i = 0; i < exportTypes.vec_.size; ++i)
+    {
+        auto const* expType(exportTypes.vec_.data[i]);
+
+        wasm_name_t const* name = wasm_exporttype_name(expType);
+        wasm_externtype_t const* exnType = wasm_exporttype_type(expType);
+        if (wasm_externtype_kind(exnType) == WASM_EXTERN_FUNC)
+        {
+            if (funcName != std::string_view(name->data, name->size))
+                continue;
+
+            auto const* exn(exports_.vec_.data[i]);
+            if (wasm_extern_kind(exn) != WASM_EXTERN_FUNC)
+                throw std::runtime_error("invalid export");  // LCOV_EXCL_LINE
+
+            ft = wasm_externtype_as_functype_const(exnType);
+            f = wasm_extern_as_func_const(exn);
+            break;
+        }
+    }
+
+    if (!f || !ft)
+        throw std::runtime_error("can't find function <" + std::string(funcName) + ">");
+
+    return {f, ft};
+}
+
+wmem
+InstanceWrapper::getMem() const
+{
+    if (memIdx_ >= 0)
+    {
+        auto* e(exports_.vec_.data[memIdx_]);
+        wasm_memory_t* mem = wasm_extern_as_memory(e);
+        return {reinterpret_cast<std::uint8_t*>(wasm_memory_data(mem)), wasm_memory_data_size(mem)};
+    }
+
+    wasm_memory_t* mem = nullptr;
+    for (int i = 0; i < exports_.vec_.size; ++i)
+    {
+        auto* e(exports_.vec_.data[i]);
+        if (wasm_extern_kind(e) == WASM_EXTERN_MEMORY)
+        {
+            memIdx_ = i;
+            mem = wasm_extern_as_memory(e);
+            break;
+        }
+    }
+
+    if (!mem)
+        return {};  // LCOV_EXCL_LINE
+
+    return {reinterpret_cast<std::uint8_t*>(wasm_memory_data(mem)), wasm_memory_data_size(mem)};
+}
+
+std::int64_t
+InstanceWrapper::getGas() const
+{
+    if (!store_)
+        return -1;  // LCOV_EXCL_LINE
+    std::uint64_t gas = 0;
+    wasm_store_get_fuel(store_, &gas);
+    return static_cast<std::int64_t>(gas);
+}
+
+std::int64_t
+InstanceWrapper::setGas(std::int64_t gas) const
+{
+    if (!store_)
+        return -1;  // LCOV_EXCL_LINE
+
+    if (gas < 0)
+        gas = std::numeric_limits<decltype(gas)>::max();
+    wasmi_error_t* err = wasm_store_set_fuel(store_, static_cast<std::uint64_t>(gas));
+    if (err)
+    {
+        // LCOV_EXCL_START
+        print_wasm_error("Can't set instance gas", nullptr, j_);
+        wasmi_error_delete(err);
+        return -1;
+        // LCOV_EXCL_STOP
+    }
+
+    return gas;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ModulePtr
+ModuleWrapper::init(StorePtr& s, Bytes const& wasmBin, beast::Journal j)
+{
+    wasm_byte_vec_t const code{wasmBin.size(), (char*)(wasmBin.data())};
+    ModulePtr m = ModulePtr(wasm_module_new(s.get(), &code), &wasm_module_delete);
+    if (!m)
+        throw std::runtime_error("can't create module");
+
+    return m;
+}
+
+// LCOV_EXCL_START
+ModuleWrapper::ModuleWrapper() : module_(nullptr, &wasm_module_delete)
+{
+}
+
+ModuleWrapper::ModuleWrapper(ModuleWrapper&& o) : module_(nullptr, &wasm_module_delete)
+{
+    *this = std::move(o);
+}
+// LCOV_EXCL_STOP
+
+ModuleWrapper::ModuleWrapper(
+    StorePtr& s,
+    Bytes const& wasmBin,
+    bool instantiate,
+    std::shared_ptr<ImportVec> const& imports,
+    beast::Journal j)
+    : module_(init(s, wasmBin, j)), j_(j)
+{
+    wasm_module_exports(module_.get(), &exportTypes_.vec_);
+    auto wimports = buildImports(s, imports);
+    if (instantiate)
+    {
+        addInstance(s, wimports);
+    }
+}
+
+// LCOV_EXCL_START
+ModuleWrapper&
+ModuleWrapper::operator=(ModuleWrapper&& o)
+{
+    if (this == &o)
+        return *this;
+
+    module_ = std::move(o.module_);
+    instanceWrap_ = std::move(o.instanceWrap_);
+    exportTypes_ = std::move(o.exportTypes_);
+    j_ = o.j_;
+
+    return *this;
+}
+
+ModuleWrapper::operator bool() const
+{
+    return instanceWrap_;
+}
+
+// LCOV_EXCL_STOP
+
+static WasmValtypeVec
+makeImpParams(WasmImportFunc const& imp)
+{
+    auto const paramSize = imp.params.size();
+    if (!paramSize)
+        return {};
+
+    WasmValtypeVec v(paramSize);
+
+    for (unsigned i = 0; i < paramSize; ++i)
+    {
+        auto const vt = imp.params[i];
+        switch (vt)
+        {
+            case WT_I32:
+                v.vec_.data[i] = wasm_valtype_new_i32();
+                break;
+            case WT_I64:
+                v.vec_.data[i] = wasm_valtype_new_i64();
+                break;
+                // LCOV_EXCL_START
+            default:
+                throw std::runtime_error("invalid import type");
+                // LCOV_EXCL_STOP
+        }
+    }
+    return v;
+}
+
+static WasmValtypeVec
+makeImpReturn(WasmImportFunc const& imp)
+{
+    if (!imp.result)
+        return {};  // LCOV_EXCL_LINE
+
+    WasmValtypeVec v(1);
+    switch (*imp.result)
+    {
+        case WT_I32:
+            v.vec_.data[0] = wasm_valtype_new_i32();
+            break;
+            // LCOV_EXCL_START
+        case WT_I64:
+            v.vec_.data[0] = wasm_valtype_new_i64();
+            break;
+        default:
+            throw std::runtime_error("invalid return type");
+            // LCOV_EXCL_STOP
+    }
+    return v;
+}
+
+WasmExternVec
+ModuleWrapper::buildImports(StorePtr& s, std::shared_ptr<ImportVec> const& imports)
+{
+    WasmImporttypeVec importTypes;
+    wasm_module_imports(module_.get(), &importTypes.vec_);
+
+    if (!importTypes.vec_.size)
+        return {};
+    if (!imports)
+        throw std::runtime_error("Missing imports");
+
+    WasmExternVec wimports(importTypes.vec_.size);
+
+    unsigned impCnt = 0;
+    for (unsigned i = 0; i < importTypes.vec_.size; ++i)
+    {
+        wasm_importtype_t const* importType = importTypes.vec_.data[i];
+
+        // wasm_name_t const* mn = wasm_importtype_module(importtype);
+        // auto modName = std::string_view(mn->data, mn->num_elems);
+        wasm_name_t const* fn = wasm_importtype_name(importType);
+        auto fieldName = std::string_view(fn->data, fn->size);
+
+        wasm_externkind_t const itype = wasm_externtype_kind(wasm_importtype_type(importType));
+        if ((itype) != WASM_EXTERN_FUNC)
+            throw std::runtime_error("Invalid import type " + std::to_string(itype));  // LCOV_EXCL_LINE
+
+        // for multi-module support
+        // if ((W_ENV != modName) && (W_HOST_LIB != modName))
+        //     continue;
+
+        bool impSet = false;
+        for (auto const& obj : *imports)
+        {
+            auto const& imp = obj.second;
+            if (imp.name != fieldName)
+                continue;
+
+            WasmValtypeVec params(makeImpParams(imp));
+            WasmValtypeVec results(makeImpReturn(imp));
+
+            std::unique_ptr<wasm_functype_t, decltype(&wasm_functype_delete)> ftype(
+                wasm_functype_new(&params.vec_, &results.vec_), &wasm_functype_delete);
+
+            params.release();
+            results.release();
+
+            wasm_func_t* func = wasm_func_new_with_env(
+                s.get(), ftype.get(), reinterpret_cast<wasm_func_callback_with_env_t>(imp.wrap), (void*)&obj, nullptr);
+            if (!func)
+            {
+                // LCOV_EXCL_START
+                throw std::runtime_error("can't create import function " + imp.name);
+                // LCOV_EXCL_STOP
+            }
+
+            wimports.vec_.data[i] = wasm_func_as_extern(func);
+            ++impCnt;
+            impSet = true;
+
+            break;
+        }
+
+        if (!impSet)
+        {
+            print_wasm_error("Import not found: " + std::string(fieldName), nullptr, j_);
+        }
+    }
+
+    if (impCnt != importTypes.vec_.size)
+    {
+        print_wasm_error(
+            std::string("Imports not finished: ") + std::to_string(impCnt) + "/" +
+                std::to_string(importTypes.vec_.size),
+            nullptr,
+            j_);
+        throw std::runtime_error("Missing imports");
+    }
+
+    return wimports;
+}
+
+FuncInfo
+ModuleWrapper::getFunc(std::string_view funcName) const
+{
+    return instanceWrap_.getFunc(funcName, exportTypes_);
+}
+
+wasm_functype_t*
+ModuleWrapper::getFuncType(std::string_view funcName) const
+{
+    for (size_t i = 0; i < exportTypes_.vec_.size; i++)
+    {
+        auto const* exp_type(exportTypes_.vec_.data[i]);
+        wasm_name_t const* name = wasm_exporttype_name(exp_type);
+        wasm_externtype_t const* exn_type = wasm_exporttype_type(exp_type);
+        if (wasm_externtype_kind(exn_type) == WASM_EXTERN_FUNC && funcName == std::string_view(name->data, name->size))
+        {
+            return wasm_externtype_as_functype(const_cast<wasm_externtype_t*>(exn_type));
+        }
+    }
+
+    throw std::runtime_error("can't find function <" + std::string(funcName) + ">");
+}
+
+wmem
+ModuleWrapper::getMem() const
+{
+    return instanceWrap_.getMem();
+}
+
+InstanceWrapper const&
+ModuleWrapper::getInstance(int) const
+{
+    return instanceWrap_;
+}
+
+int
+ModuleWrapper::addInstance(StorePtr& s, WasmExternVec const& imports)
+{
+    instanceWrap_ = {s, module_, imports, j_};
+    return 0;
+}
+
+// int
+// my_module_t::delInstance(int i)
+// {
+//     if (i >= mod_inst.size())
+//         return -1;
+//     if (!mod_inst[i])
+//         mod_inst[i] = my_mod_inst_t();
+//     return i;
+// }
+
+std::int64_t
+ModuleWrapper::getGas()
+{
+    return instanceWrap_ ? instanceWrap_.getGas() : -1;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// void
+// WasmiEngine::clearModules()
+// {
+//     modules.clear();
+//     store.reset();  // to free the memory before creating new store
+//     store = {wasm_store_new(engine.get()), &wasm_store_delete};
+// }
+
+std::unique_ptr<wasm_engine_t, decltype(&wasm_engine_delete)>
+WasmiEngine::init()
+{
+    wasm_config_t* config = wasm_config_new();
+    if (!config)
+        return std::unique_ptr<wasm_engine_t, decltype(&wasm_engine_delete)>{
+            nullptr, &wasm_engine_delete};  // LCOV_EXCL_LINE
+    wasmi_config_consume_fuel_set(config, true);
+    wasmi_config_ignore_custom_sections_set(config, true);
+    wasmi_config_wasm_mutable_globals_set(config, false);
+    wasmi_config_wasm_multi_value_set(config, false);
+    wasmi_config_wasm_sign_extension_set(config, false);
+    wasmi_config_wasm_saturating_float_to_int_set(config, false);
+    wasmi_config_wasm_bulk_memory_set(config, false);
+    wasmi_config_wasm_reference_types_set(config, false);
+    wasmi_config_wasm_tail_call_set(config, false);
+    wasmi_config_wasm_extended_const_set(config, false);
+    wasmi_config_floats_set(config, false);
+    wasmi_config_wasm_multi_memory_set(config, false);
+    wasmi_config_wasm_custom_page_sizes_set(config, false);
+    wasmi_config_wasm_memory64_set(config, false);
+    wasmi_config_wasm_wide_arithmetic_set(config, false);
+
+    return std::unique_ptr<wasm_engine_t, decltype(&wasm_engine_delete)>(
+        wasm_engine_new_with_config(config), &wasm_engine_delete);
+}
+
+WasmiEngine::WasmiEngine() : engine_(init()), store_(nullptr, &wasm_store_delete)
+{
+}
+
+int
+WasmiEngine::addModule(Bytes const& wasmCode, bool instantiate, int64_t gas)
+{
+    moduleWrap_.reset();
+    store_.reset();  // to free the memory before creating new store
+    store_ = {wasm_store_new_with_memory_max_pages(engine_.get(), MAX_PAGES), &wasm_store_delete};
+
+    if (gas < 0)
+        gas = std::numeric_limits<decltype(gas)>::max();
+    wasmi_error_t* err = wasm_store_set_fuel(store_.get(), static_cast<std::uint64_t>(gas));
+    if (err)
+    {
+        // LCOV_EXCL_START
+        print_wasm_error("Error setting gas", nullptr, j_);
+        wasmi_error_delete(err);
+        throw std::runtime_error("can't set gas");
+        // LCOV_EXCL_STOP
+    }
+
+    moduleWrap_ = std::make_unique<ModuleWrapper>(store_, wasmCode, instantiate, imports_, j_);
+
+    if (!moduleWrap_)
+        throw std::runtime_error("can't create module wrapper");  // LCOV_EXCL_LINE
+
+    return moduleWrap_ ? 0 : -1;
+}
+
+// int
+// WasmiEngine::addInstance()
+// {
+//     return module->addInstance(store.get());
+// }
+
+FuncInfo
+WasmiEngine::getFunc(std::string_view funcName)
+{
+    return moduleWrap_->getFunc(funcName);
+}
+
+std::vector<wasm_val_t>
+WasmiEngine::convertParams(std::vector<WasmParam> const& params)
+{
+    std::vector<wasm_val_t> v;
+    v.reserve(params.size());
+    for (auto const& p : params)
+    {
+        switch (p.type)
+        {
+            case WT_I32:
+                v.push_back(WASM_I32_VAL(p.of.i32));
+                break;
+            // LCOV_EXCL_START
+            case WT_I64:
+                v.push_back(WASM_I64_VAL(p.of.i64));
+                break;
+            // LCOV_EXCL_STOP
+            case WT_U8V: {
+                auto mem = getMem();
+                if (!mem.s)
+                    throw std::runtime_error("no memory exported");  // LCOV_EXCL_LINE
+                auto const sz = p.of.u8v.sz;
+                auto const ptr = allocate(sz);
+                memcpy(mem.p + ptr, p.of.u8v.d, sz);
+                v.push_back(WASM_I32_VAL(ptr));
+                v.push_back(WASM_I32_VAL(sz));
+            }
+            break;
+            // LCOV_EXCL_START
+            default:
+                throw std::runtime_error("unknown parameter type: " + std::to_string(p.type));
+                break;
+                // LCOV_EXCL_STOP
+        }
+    }
+
+    return v;
+}
+
+int
+WasmiEngine::compareParamTypes(wasm_valtype_vec_t const* ftp, std::vector<wasm_val_t> const& p)
+{
+    if (ftp->size != p.size())
+        return std::min(ftp->size, p.size());
+
+    for (unsigned i = 0; i < ftp->size; ++i)
+    {
+        auto const t1 = wasm_valtype_kind(ftp->data[i]);
+        auto const t2 = p[i].kind;
+        if (t1 != t2)
+            return i;
+    }
+
+    return -1;
+}
+
+// LCOV_EXCL_START
+void
+WasmiEngine::add_param(std::vector<wasm_val_t>& in, int32_t p)
+{
+    in.emplace_back();
+    auto& el(in.back());
+    memset(&el, 0, sizeof(el));
+    el = WASM_I32_VAL(p);  // WASM_I32;
+}
+
+// LCOV_EXCL_STOP
+
+void
+WasmiEngine::add_param(std::vector<wasm_val_t>& in, int64_t p)
+{
+    in.emplace_back();
+    auto& el(in.back());
+    el = WASM_I64_VAL(p);
+}
+
+template <int NR, class... Types>
+WasmiResult
+WasmiEngine::call(std::string_view func, Types&&... args)
+{
+    // Lookup our export function
+    auto f = getFunc(func);
+    return call<NR>(f, std::forward<Types>(args)...);
+}
+
+template <int NR, class... Types>
+WasmiResult
+WasmiEngine::call(FuncInfo const& f, Types&&... args)
+{
+    std::vector<wasm_val_t> in;
+    return call<NR>(f, in, std::forward<Types>(args)...);
+}
+
+#ifdef SHOW_CALL_TIME
+static inline uint64_t
+usecs()
+{
+    uint64_t x = std::chrono::duration_cast<std::chrono::microseconds>(
+                     std::chrono::high_resolution_clock::now().time_since_epoch())
+                     .count();
+    return x;
+}
+#endif
+
+template <int NR, class... Types>
+WasmiResult
+WasmiEngine::call(FuncInfo const& f, std::vector<wasm_val_t>& in)
+{
+    // wasm_val_t rs[1] = {WASM_I32_VAL(0)};
+    WasmiResult ret(NR);
+    // if (NR)  {   wasm_val_vec_new_uninitialized(&ret, NR);    //
+    // wasm_val_vec_new(&ret, NR, &rs[0]);    // ret = WASM_ARRAY_VEC(rs);    }
+
+    wasm_val_vec_t const inv = in.empty() ? wasm_val_vec_t WASM_EMPTY_VEC : wasm_val_vec_t{in.size(), in.data()};
+
+#ifdef SHOW_CALL_TIME
+    auto const start = usecs();
+#endif
+
+    wasm_trap_t* trap = wasm_func_call(f.first, &inv, &ret.r.vec_);
+
+#ifdef SHOW_CALL_TIME
+    auto const finish = usecs();
+    auto const delta_ms = (finish - start) / 1000;
+    std::cout << "wasm_func_call: " << delta_ms << "ms" << std::endl;
+#endif
+
+    if (trap)
+    {
+        ret.f = true;
+        print_wasm_error("failure to call func", trap, j_);
+    }
+
+    // assert(results[0].kind == WASM_I32);
+    // if (NR) printf("Result P5: %d\n", ret[0].of.i32);
+
+    return ret;
+}
+
+template <int NR, class... Types>
+WasmiResult
+WasmiEngine::call(FuncInfo const& f, std::vector<wasm_val_t>& in, std::int32_t p, Types&&... args)
+{
+    add_param(in, p);
+    return call<NR>(f, in, std::forward<Types>(args)...);
+}
+
+template <int NR, class... Types>
+WasmiResult
+WasmiEngine::call(FuncInfo const& f, std::vector<wasm_val_t>& in, std::int64_t p, Types&&... args)
+{
+    add_param(in, p);
+    return call<NR>(f, in, std::forward<Types>(args)...);
+}
+
+template <int NR, class... Types>
+WasmiResult
+WasmiEngine::call(FuncInfo const& f, std::vector<wasm_val_t>& in, uint8_t const* d, int32_t sz, Types&&... args)
+{
+    auto mem = getMem();
+    if (!mem.s)
+        throw std::runtime_error("no memory exported");  // LCOV_EXCL_LINE
+
+    auto const ptr = allocate(sz);
+    memcpy(mem.p + ptr, d, sz);
+
+    add_param(in, ptr);
+    add_param(in, static_cast<int32_t>(sz));
+    return call<NR>(f, in, std::forward<Types>(args)...);
+}
+
+template <int NR, class... Types>
+WasmiResult
+WasmiEngine::call(FuncInfo const& f, std::vector<wasm_val_t>& in, Bytes const& p, Types&&... args)
+{
+    return call<NR>(f, in, p.data(), p.size(), std::forward<Types>(args)...);
+}
+
+static inline void
+checkImports(ImportVec const& imports, HostFunctions* hfs)
+{
+    for (auto const& obj : imports)
+    {
+        if (hfs != obj.first)
+            Throw<std::runtime_error>("Imports hf unsync");
+    }
+}
+
+Expected<WasmResult<int32_t>, TER>
+WasmiEngine::run(
+    Bytes const& wasmCode,
+    std::string_view funcName,
+    std::vector<WasmParam> const& params,
+    std::shared_ptr<ImportVec> const& imports,
+    std::shared_ptr<HostFunctions> const& hfs,
+    int64_t gas,
+    beast::Journal j)
+{
+    j_ = j;
+
+    if (!wasmCode.empty())
+    {  // save values for reuse
+        imports_ = imports;
+        hfs_ = hfs;
+    }
+
+    try
+    {
+        if (imports_)
+            checkImports(*imports_, hfs.get());
+        return runHlp(wasmCode, funcName, params, gas);
+    }
+    catch (std::exception const& e)
+    {
+        print_wasm_error(std::string("exception: ") + e.what(), nullptr, j_);
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+        print_wasm_error(std::string("exception: unknown"), nullptr, j_);
+    }
+    // LCOV_EXCL_STOP
+    return Unexpected<TER>(tecFAILED_PROCESSING);
+}
+
+Expected<WasmResult<int32_t>, TER>
+WasmiEngine::runHlp(Bytes const& wasmCode, std::string_view funcName, std::vector<WasmParam> const& params, int64_t gas)
+{
+    // currently only 1 module support, possible parallel UT run
+    std::lock_guard<decltype(m_)> lg(m_);
+
+    // Create and instantiate the module.
+    if (!wasmCode.empty())
+    {
+        [[maybe_unused]] int const m = addModule(wasmCode, true, gas);
+    }
+
+    if (!moduleWrap_ || !moduleWrap_->instanceWrap_)
+        throw std::runtime_error("no instance");  // LCOV_EXCL_LINE
+
+    if (hfs_)
+        hfs_->setRT(&getRT());
+
+    // Call main
+    auto const f = getFunc(!funcName.empty() ? funcName : "_start");
+    auto const* ftp = wasm_functype_params(f.second);
+
+    // not const because passed directly to VM function (which accept non
+    // const)
+    auto p = convertParams(params);
+
+    if (int const comp = compareParamTypes(ftp, p); comp >= 0)
+        throw std::runtime_error("invalid parameter type #" + std::to_string(comp));
+
+    auto const res = call<1>(f, p);
+
+    if (res.f)
+        throw std::runtime_error("<" + std::string(funcName) + "> failure");
+    else if (!res.r.vec_.size)
+        throw std::runtime_error("<" + std::string(funcName) + "> return nothing");  // LCOV_EXCL_LINE
+    else if (res.r.vec_.data[0].kind != WASM_I32)
+        throw std::runtime_error(
+            "<" + std::string(funcName) +
+            "> return type mismatch, ret: " + std::to_string(static_cast<int>(res.r.vec_.data[0].kind)));
+
+    if (gas == -1)
+        gas = std::numeric_limits<decltype(gas)>::max();
+    WasmResult<int32_t> const ret{res.r.vec_.data[0].of.i32, gas - moduleWrap_->getGas()};
+
+    // #ifdef DEBUG_OUTPUT
+    //     auto& j = std::cerr;
+    // #else
+    //     auto j = j_.debug();
+    // #endif
+    // j << "WASMI Res: " << ret.result << " cost: " << ret.cost << std::endl;
+
+    return ret;
+}
+
+NotTEC
+WasmiEngine::check(
+    Bytes const& wasmCode,
+    std::string_view funcName,
+    std::vector<WasmParam> const& params,
+    std::shared_ptr<ImportVec> const& imports,
+    std::shared_ptr<HostFunctions> const& hfs,
+    beast::Journal j)
+{
+    j_ = j;
+
+    if (!wasmCode.empty())
+    {
+        imports_ = imports;
+        hfs_ = hfs;
+    }
+
+    try
+    {
+        if (imports_)
+            checkImports(*imports_, hfs_.get());
+        return checkHlp(wasmCode, funcName, params);
+    }
+    catch (std::exception const& e)
+    {
+        print_wasm_error(std::string("exception: ") + e.what(), nullptr, j_);
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+        print_wasm_error(std::string("exception: unknown"), nullptr, j_);
+    }
+    // LCOV_EXCL_STOP
+
+    return temBAD_WASM;
+}
+
+NotTEC
+WasmiEngine::checkHlp(Bytes const& wasmCode, std::string_view funcName, std::vector<WasmParam> const& params)
+{
+    // currently only 1 module support, possible parallel UT run
+    std::lock_guard<decltype(m_)> lg(m_);
+
+    // Create and instantiate the module.
+    if (wasmCode.empty())
+        throw std::runtime_error("empty nodule");
+
+    int const m = addModule(wasmCode, false, -1);
+    if ((m < 0) || !moduleWrap_)
+        throw std::runtime_error("no module");  // LCOV_EXCL_LINE
+
+    // Looking for a func and compare parameter types
+    auto const f = moduleWrap_->getFuncType(!funcName.empty() ? funcName : "_start");
+    auto const* ftp = wasm_functype_params(f);
+    auto const p = convertParams(params);
+
+    if (int const comp = compareParamTypes(ftp, p); comp >= 0)
+        throw std::runtime_error("invalid parameter type #" + std::to_string(comp));
+
+    return tesSUCCESS;
+}
+
+// LCOV_EXCL_START
+std::int64_t
+WasmiEngine::getGas()
+{
+    return moduleWrap_ ? moduleWrap_->getGas() : -1;
+}
+// LCOV_EXCL_STOP
+
+wmem
+WasmiEngine::getMem() const
+{
+    return moduleWrap_ ? moduleWrap_->getMem() : wmem();
+}
+
+InstanceWrapper const&
+WasmiEngine::getRT(int m, int i)
+{
+    if (!moduleWrap_)
+        throw std::runtime_error("no module");
+    return moduleWrap_->getInstance(i);
+}
+
+int32_t
+WasmiEngine::allocate(int32_t sz)
+{
+    if (sz <= 0)
+        throw std::runtime_error("can't allocate memory, " + std::to_string(sz) + " bytes");
+
+    auto res = call<1>(W_ALLOC, sz);
+
+    if (res.f || !res.r.vec_.size || (res.r.vec_.data[0].kind != WASM_I32))
+        throw std::runtime_error("can't allocate memory, " + std::to_string(sz) + " bytes");  // LCOV_EXCL_LINE
+
+    int32_t const p = res.r.vec_.data[0].of.i32;
+    auto const mem = getMem();
+    if (p <= 0 || p + sz > mem.s)
+        throw std::runtime_error("invalid memory allocation, " + std::to_string(sz) + " bytes");
+
+    return p;
+}
+
+wasm_trap_t*
+WasmiEngine::newTrap(std::string const& txt)
+{
+    static char empty[1] = {0};
+    wasm_message_t msg = {1, empty};
+
+    if (!txt.empty())
+        wasm_name_new(&msg, txt.size() + 1, txt.c_str());  // include 0
+
+    wasm_trap_t* trap = wasm_trap_new(store_.get(), &msg);
+
+    if (!txt.empty())
+        wasm_byte_vec_delete(&msg);
+
+    return trap;
+}
+
+// LCOV_EXCL_START
+beast::Journal
+WasmiEngine::getJournal() const
+{
+    return j_;
+}
+// LCOV_EXCL_STOP
+
+}  // namespace xrpl