Merge branch 'ripple/smart-escrow' into ripple/se/supported

Conflict resolution:

- features.macro: kept fixCleanup3_4_0 from develop and kept SmartEscrow at
  Supported::Yes, which is the only thing this branch changes.

.cspell.config.yaml

@@ -7,6 +7,8 @@ ignorePaths:
   - cmake/**
   - LICENSE.md
   - .clang-tidy
+  - src/test/app/wasm_fixtures/**/*.wat
+  - src/test/app/wasm_fixtures/*.c
 language: en
 allowCompoundWords: true # TODO (#6334)
 ignoreRandomStrings: true
@@ -67,6 +69,7 @@ words:
   - Btrfs
   - Buildx
   - canonicality
+  - cdylib
   - canonicalised
   - changespq
   - checkme
@@ -297,6 +300,7 @@ words:
   - STATSDCOLLECTOR
   - stissue
   - stnum
+  - stnumber
   - stobj
   - stobject
   - stpath
@@ -363,6 +367,7 @@ words:
   - wthread
   - xbridge
   - xchain
+  - xfloat
   - ximinez
   - XMACRO
   - xrpkuwait

CMakeLists.txt

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

cfg/xrpld-example.cfg

@@ -1348,6 +1348,39 @@
 #       Example:
 #           owner_reserve = 200000      # 0.2 XRP
 #
+#   gas_limit = <gas>
+#
+#       The gas limit is the maximum amount of gas that can be
+#       consumed by a single transaction. The gas limit is used to prevent
+#       transactions from consuming too many resources.
+#
+#       If this parameter is unspecified, xrpld will use an internal
+#       default. Don't change this without understanding the consequences.
+#
+#       Example:
+#           gas_limit = 1000000      # 1 million gas
+#
+#   bytecode_size_limit = <bytes>
+#
+#       The bytecode size limit is the maximum size of a WASM extension in
+#       bytes. The size limit is used to prevent extensions from consuming
+#       too many resources.
+#
+#       If this parameter is unspecified, xrpld will use an internal
+#       default. Don't change this without understanding the consequences.
+#
+#       Example:
+#           bytecode_size_limit = 100000      # 100 kb
+#
+#   gas_price = <micro-drops>
+#
+#       The gas price is the conversion between WASM gas and its price in drops.
+#
+#       If this parameter is unspecified, xrpld will use an internal
+#       default. Don't change this without understanding the consequences.
+#
+#       Example:
+#           gas_price = 1000000      # 1 drop per gas
 #-------------------------------------------------------------------------------
 #
 # 9. Misc Settings

cmake/XrplCore.cmake

@@ -67,6 +67,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.2#1cb806da49011867778ffb6ac7190fcb%1782392402.122708",
         "xxhash/0.8.3#681d36a0a6111fc56e5e45ea182c19cc%1782392402.420688",
+        "wasmi/1.0.9#1fecdab9b90c96698eb35ea99ca4f5cb%1782307153.343419",
         "sqlite3/3.53.0#324ada52333108388a9a6108bfa96734%1782392403.185447",
         "soci/4.0.3#e726491a03468795453f7c83fc924a96%1782392402.679521",
         "snappy/1.1.10#968fef506ff261592ec30c574d4a7809%1782307151.633168",

conanfile.py

@@ -35,6 +35,7 @@ class Xrpl(ConanFile):
         "nudb/2.0.9",
         "openssl/3.6.3",
         "soci/4.0.3",
+        "wasmi/1.0.9",
         "zlib/1.3.2",
     ]
 
@@ -223,6 +224,7 @@ class Xrpl(ConanFile):
             "soci::soci",
             "secp256k1::secp256k1",
             "sqlite3::sqlite",
+            "wasmi::wasmi",
             "xxhash::xxhash",
             "zlib::zlib",
         ]

include/xrpl/basics/Number.h

@@ -549,8 +549,21 @@ public:
     setround(RoundingMode inMode);
 
     /**
-     * Returns which mantissa scale is currently in use for normalization.
+     * Convert an integer to a RoundingMode, validating that it is in range.
      *
+     * Returns std::nullopt if the value does not correspond to a valid
+     * RoundingMode.
+     */
+    static std::optional<RoundingMode>
+    checkedRoundingMode(int mode) noexcept
+    {
+        if (mode < static_cast<int>(RoundingMode::ToNearest) ||
+            mode > static_cast<int>(RoundingMode::Upward))
+            return std::nullopt;
+        return static_cast<RoundingMode>(mode);
+    }
+
+    /**
      * If you think you need to call this outside of unit tests, no you don't.
      */
     static MantissaRange::MantissaScale

include/xrpl/config/Constants.h

@@ -94,6 +94,7 @@ struct Keys
     static constexpr auto kBbtOptions = "bbt_options";
     static constexpr auto kBgThreads = "bg_threads";
     static constexpr auto kBlockSize = "block_size";
+    static constexpr auto kBytecodeSizeLimit = "bytecode_size_limit";
     static constexpr auto kCacheAge = "cache_age";
     static constexpr auto kCacheMb = "cache_mb";
     static constexpr auto kCacheSize = "cache_size";
@@ -108,6 +109,8 @@ struct Keys
     static constexpr auto kFileSizeMult = "file_size_mult";
     static constexpr auto kFilterBits = "filter_bits";
     static constexpr auto kFilterFull = "filter_full";
+    static constexpr auto kGasLimit = "gas_limit";
+    static constexpr auto kGasPrice = "gas_price";
     static constexpr auto kHardSet = "hard_set";
     static constexpr auto kHighThreads = "high_threads";
     static constexpr auto kHoldTime = "hold_time";

include/xrpl/core/ServiceRegistry.h

@@ -6,6 +6,7 @@
 #include <xrpl/basics/TaggedCache.h>
 #include <xrpl/basics/base_uint.h>
 #include <xrpl/beast/utility/Journal.h>
+#include <xrpl/protocol/Fees.h>
 
 #include <boost/asio.hpp>
 
@@ -246,6 +247,9 @@ public:
     virtual DatabaseCon&
     getWalletDB() = 0;
 
+    [[nodiscard]] virtual Fees
+    getFees() const = 0;
+
     // Temporary: Get the underlying Application for functions that haven't
     // been migrated yet. This should be removed once all code is migrated.
     virtual Application&

include/xrpl/ledger/ApplyViewImpl.h

@@ -13,6 +13,7 @@
 #include <xrpl/protocol/TxMeta.h>
 
 #include <cstddef>
+#include <cstdint>
 #include <functional>
 #include <optional>
 
@@ -68,6 +69,18 @@ public:
         deliver_ = amount;
     }
 
+    void
+    setGasUsed(std::optional<std::uint32_t> const gasUsed)
+    {
+        gasUsed_ = gasUsed;
+    }
+
+    void
+    setVMReturnCode(std::int32_t const vmReturnCode)
+    {
+        vmReturnCode_ = vmReturnCode;
+    }
+
     /**
      * Get the number of modified entries
      */
@@ -88,6 +101,8 @@ public:
 
 private:
     std::optional<STAmount> deliver_;
+    std::optional<std::uint32_t> gasUsed_;
+    std::optional<std::int32_t> vmReturnCode_;
 };
 
 }  // namespace xrpl

include/xrpl/ledger/detail/ApplyStateTable.h

@@ -16,6 +16,7 @@
 #include <xrpl/protocol/XRPAmount.h>
 
 #include <cstddef>
+#include <cstdint>
 #include <functional>
 #include <map>
 #include <optional>
@@ -62,6 +63,8 @@ public:
         TER ter,
         std::optional<STAmount> const& deliver,
         std::optional<uint256 const> const& parentBatchId,
+        std::optional<std::uint32_t> const& gasUsed,
+        std::optional<std::int32_t> const& vmReturnCode,
         bool isDryRun,
         beast::Journal j);
 

include/xrpl/ledger/helpers/EscrowHelpers.h

@@ -25,6 +25,8 @@
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/UintTypes.h>
 
+#include <cstdint>
+
 namespace xrpl {
 
 template <ValidIssueType T>
@@ -272,4 +274,15 @@ escrowUnlockApplyHelper<MPTIssue>(
         journal);
 }
 
+template <class T>
+static int32_t
+calculateAdditionalReserve(T const& finishFunction)
+{
+    if (!finishFunction)
+        return 1;
+    // First 500 bytes included in the normal reserve
+    // Each additional 500 bytes requires an additional reserve
+    return 1 + (finishFunction->size() / 500);
+}
+
 }  // namespace xrpl

include/xrpl/protocol/Fees.h

@@ -10,6 +10,15 @@ namespace xrpl {
 // This was the reference fee units used in the old fee calculation.
 inline constexpr std::uint32_t kFeeUnitsDeprecated = 10;
 
+// Number of micro-drops in one drop.
+constexpr std::uint32_t microDropsPerDrop{1'000'000};
+
+/**
+ * Maximum Feature Extension fee settings.
+ */
+inline constexpr std::uint32_t kMaxGasLimit{2'000'000};
+inline constexpr std::uint32_t kMaxBytecodeSizeLimit{200'000};
+
 /**
  * Reflects the fee settings for a particular ledger.
  *
@@ -33,6 +42,21 @@ struct Fees
      */
     XRPAmount increment{0};
 
+    /**
+     * @brief Gas limit for Feature Extensions (instructions).
+     */
+    std::uint32_t gasLimit{0};
+
+    /**
+     * @brief Bytecode size limit for Feature Extensions (bytes).
+     */
+    std::uint32_t bytecodeSizeLimit{0};
+
+    /**
+     * @brief Price of WASM gas (micro-drops).
+     */
+    std::uint32_t gasPrice{0};
+
     explicit Fees() = default;
     Fees(Fees const&) = default;
     Fees&

include/xrpl/protocol/Indexes.h

@@ -237,6 +237,12 @@ page(Keylet const& root, std::uint64_t const index = 0) noexcept
 Keylet
 escrow(AccountID const& src, SeqProxy const& seq) noexcept;
 
+inline Keylet
+escrow(uint256 const& key) noexcept
+{
+    return {ltESCROW, key};
+}
+
 /**
  * A PaymentChannel
  */

include/xrpl/protocol/Protocol.h

@@ -333,6 +333,16 @@ enum class VaultVersion : uint8_t {
  */
 constexpr std::uint8_t kMaxAssetCheckDepth = 5;
 
+/**
+ * Maximum length of a Data field in Escrow object that can be updated by WASM code.
+ */
+constexpr std::size_t kMaxWasmDataLength = 1 * 1024;  // 1KB
+
+/**
+ * Maximum amount of data transfer across hostfunction<->wasm border.
+ */
+constexpr std::size_t kWasmTransferLimit = 1 << 20;  // 1MB
+
 /**
  * A ledger index.
  */

include/xrpl/protocol/TER.h

@@ -129,8 +129,12 @@ enum TEMcodes : TERUnderlyingType {
     temARRAY_TOO_LARGE,
     temBAD_TRANSFER_FEE,
     temINVALID_INNER_BATCH,
+
     temBAD_MPT,
     temBAD_CIPHERTEXT,
+    temBAD_WASM,
+    temINVALID_BYTECODE,
+    temTEMP_DISABLED,
 };
 
 //------------------------------------------------------------------------------
@@ -179,6 +183,8 @@ enum TEFcodes : TERUnderlyingType {
     tefINVALID_LEDGER_FIX_TYPE,
     tefNO_DST_PARTIAL,
     tefBAD_PATH_COUNT,
+    tefNO_BYTECODE,
+    tefBYTECODE_NOT_INCLUDED,
 };
 
 //------------------------------------------------------------------------------
@@ -370,6 +376,8 @@ enum TECcodes : TERUnderlyingType {
     tecNO_DELEGATE_PERMISSION = 198,
     tecBAD_PROOF = 199,
     tecNO_SPONSOR_PERMISSION = 200,
+    tecOUT_OF_GAS = 201,
+    tecBYTECODE_REJECTED = 202,
 };
 
 //------------------------------------------------------------------------------

include/xrpl/protocol/TxMeta.h

@@ -95,6 +95,12 @@ public:
 
         if (obj.isFieldPresent(sfParentBatchID))
             parentBatchID_ = obj.getFieldH256(sfParentBatchID);
+
+        if (obj.isFieldPresent(sfGasUsed))
+            gasUsed_ = obj.getFieldU32(sfGasUsed);
+
+        if (obj.isFieldPresent(sfVMReturnCode))
+            vmReturnCode_ = obj.getFieldI32(sfVMReturnCode);
     }
 
     [[nodiscard]] std::optional<STAmount> const&
@@ -115,6 +121,30 @@ public:
         parentBatchID_ = id;
     }
 
+    void
+    setGasUsed(std::optional<std::uint32_t> const gasUsed)
+    {
+        gasUsed_ = gasUsed;
+    }
+
+    [[nodiscard]] std::optional<std::uint32_t> const&
+    getGasUsed() const
+    {
+        return gasUsed_;
+    }
+
+    void
+    setVMReturnCode(std::optional<std::int32_t> const vmReturnCode)
+    {
+        vmReturnCode_ = vmReturnCode;
+    }
+
+    [[nodiscard]] std::optional<std::int32_t> const&
+    getVMReturnCode() const
+    {
+        return vmReturnCode_;
+    }
+
 private:
     uint256 transactionID_;
     std::uint32_t ledgerSeq_;
@@ -123,6 +153,8 @@ private:
 
     std::optional<STAmount> deliveredAmount_;
     std::optional<uint256> parentBatchID_;
+    std::optional<std::uint32_t> gasUsed_;
+    std::optional<std::int32_t> vmReturnCode_;
 
     STArray nodes_;
 };

include/xrpl/protocol/detail/features.macro

@@ -16,6 +16,7 @@
 // Keep it sorted in reverse chronological order.
 
 XRPL_FIX    (Cleanup3_4_0,                Supported::Yes, VoteBehavior::DefaultNo)
+XRPL_FEATURE(SmartEscrow,                 Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(Sponsor,                     Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(BatchV1_1,                   Supported::Yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(LendingProtocolV1_1,         Supported::No,  VoteBehavior::DefaultNo)

include/xrpl/protocol/detail/ledger_entries.macro

@@ -309,6 +309,11 @@ LEDGER_ENTRY(ltFEE_SETTINGS, 0x0073, FeeSettings, fee, ({
     {sfBaseFeeDrops,           SoeOptional},
     {sfReserveBaseDrops,       SoeOptional},
     {sfReserveIncrementDrops,  SoeOptional},
+    // Smart Escrow fields
+    {sfGasLimit,               SoeOptional},
+    {sfBytecodeSizeLimit,      SoeOptional},
+    {sfGasPrice,               SoeOptional},
+
     {sfPreviousTxnID,          SoeOptional},
     {sfPreviousTxnLgrSeq,      SoeOptional},
 }))
@@ -339,6 +344,8 @@ LEDGER_ENTRY(ltESCROW, 0x0075, Escrow, escrow, ({
     {sfCondition,            SoeOptional},
     {sfCancelAfter,          SoeOptional},
     {sfFinishAfter,          SoeOptional},
+    {sfBytecode,             SoeOptional},
+    {sfData,                 SoeOptional},
     {sfSourceTag,            SoeOptional},
     {sfDestinationTag,       SoeOptional},
     {sfOwnerNode,            SoeRequired},

include/xrpl/protocol/detail/sfields.macro

@@ -120,6 +120,11 @@ TYPED_SFIELD(sfSponsoringOwnerCount,     UINT32,    71)
 TYPED_SFIELD(sfSponsoringAccountCount,   UINT32,    72)
 TYPED_SFIELD(sfRemainingOwnerCount,      UINT32,    73)
 TYPED_SFIELD(sfSponsorFlags,             UINT32,    74)
+TYPED_SFIELD(sfGasLimit,                 UINT32,    75)
+TYPED_SFIELD(sfBytecodeSizeLimit,        UINT32,    76)
+TYPED_SFIELD(sfGasPrice,                 UINT32,    77)
+TYPED_SFIELD(sfGas,                      UINT32,    78)
+TYPED_SFIELD(sfGasUsed,                  UINT32,    79)
 
 // 64-bit integers (common)
 TYPED_SFIELD(sfIndexNext,                UINT64,     1)
@@ -237,9 +242,10 @@ TYPED_SFIELD(sfTotalValueOutstanding,    NUMBER,     15, SField::kSmdNeedsAsset
 TYPED_SFIELD(sfPeriodicPayment,          NUMBER,     16)
 TYPED_SFIELD(sfManagementFeeOutstanding, NUMBER,     17, SField::kSmdNeedsAsset | SField::kSmdDefault)
 
-// int32
+// 32-bit signed (common)
 TYPED_SFIELD(sfLoanScale,                INT32,      1)
 TYPED_SFIELD(sfRemainingOwnerCountDelta, INT32,      2)
+TYPED_SFIELD(sfVMReturnCode,             INT32,      3)
 
 // currency amount (common)
 TYPED_SFIELD(sfAmount,                   AMOUNT,     1)
@@ -269,7 +275,7 @@ TYPED_SFIELD(sfBaseFeeDrops,             AMOUNT,    22)
 TYPED_SFIELD(sfReserveBaseDrops,         AMOUNT,    23)
 TYPED_SFIELD(sfReserveIncrementDrops,    AMOUNT,    24)
 
-// currency amount (AMM)
+// currency amount (more)
 TYPED_SFIELD(sfLPTokenOut,               AMOUNT,    25)
 TYPED_SFIELD(sfLPTokenIn,                AMOUNT,    26)
 TYPED_SFIELD(sfEPrice,                   AMOUNT,    27)
@@ -329,6 +335,7 @@ TYPED_SFIELD(sfAuditorEncryptedAmount,      VL,     43)
 TYPED_SFIELD(sfAuditorEncryptionKey,        VL,     44)
 TYPED_SFIELD(sfAmountCommitment,            VL,     45)
 TYPED_SFIELD(sfBalanceCommitment,           VL,     46)
+TYPED_SFIELD(sfBytecode,                    VL,     47)
 
 // account (common)
 TYPED_SFIELD(sfAccount,                  ACCOUNT,    1)

include/xrpl/protocol/detail/transactions.macro

@@ -50,11 +50,13 @@ TRANSACTION(ttESCROW_CREATE, 1, EscrowCreate,
     NoPriv,
     ({
     {sfDestination, SoeRequired},
+    {sfDestinationTag, SoeOptional},
     {sfAmount, SoeRequired, SoeMptSupported},
     {sfCondition, SoeOptional},
     {sfCancelAfter, SoeOptional},
     {sfFinishAfter, SoeOptional},
-    {sfDestinationTag, SoeOptional},
+    {sfBytecode, SoeOptional},
+    {sfData,           SoeOptional},
 }))
 
 /** This transaction type completes an existing escrow. */
@@ -71,6 +73,7 @@ TRANSACTION(ttESCROW_FINISH, 2, EscrowFinish,
     {sfFulfillment, SoeOptional},
     {sfCondition, SoeOptional},
     {sfCredentialIDs, SoeOptional},
+    {sfGas, SoeOptional},
 }))
 
 
@@ -1228,6 +1231,10 @@ TRANSACTION(ttFEE, 101, SetFee,
     {sfBaseFeeDrops, SoeOptional},
     {sfReserveBaseDrops, SoeOptional},
     {sfReserveIncrementDrops, SoeOptional},
+    // Smart Escrow fields
+    {sfGasLimit, SoeOptional},
+    {sfBytecodeSizeLimit, SoeOptional},
+    {sfGasPrice, SoeOptional},
 }))
 
 /** This system-generated transaction type is used to update the network's negative UNL

include/xrpl/protocol/jss.h

@@ -252,6 +252,9 @@ JSS(expected_date);                  // out: any (warnings)
 JSS(expected_date_UTC);              // out: any (warnings)
 JSS(expected_ledger_size);           // out: TxQ
 JSS(expiration);                     // out: AccountOffers, AccountChannels, ValidatorList, amm_info
+JSS(gas_limit);                      // out: NetworkOPs
+JSS(bytecode_size_limit);            // out: NetworkOPs
+JSS(gas_price);                      // out: NetworkOPs
 JSS(fail_hard);                      // in: Sign, Submit
 JSS(failed);                         // out: InboundLedger
 JSS(feature);                        // in: Feature

include/xrpl/protocol_autogen/ledger_entries/Escrow.h

@@ -174,6 +174,54 @@ public:
         return this->sle_->isFieldPresent(sfFinishAfter);
     }
 
+    /**
+     * @brief Get sfBytecode (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getBytecode() const
+    {
+        if (hasBytecode())
+            return this->sle_->at(sfBytecode);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfBytecode is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasBytecode() const
+    {
+        return this->sle_->isFieldPresent(sfBytecode);
+    }
+
+    /**
+     * @brief Get sfData (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getData() const
+    {
+        if (hasData())
+            return this->sle_->at(sfData);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfData is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasData() const
+    {
+        return this->sle_->isFieldPresent(sfData);
+    }
+
     /**
      * @brief Get sfSourceTag (SoeOptional)
      * @return The field value, or std::nullopt if not present.
@@ -453,6 +501,28 @@ public:
         return *this;
     }
 
+    /**
+     * @brief Set sfBytecode (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowBuilder&
+    setBytecode(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfBytecode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfData (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowBuilder&
+    setData(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfData] = value;
+        return *this;
+    }
+
     /**
      * @brief Set sfSourceTag (SoeOptional)
      * @return Reference to this builder for method chaining.

include/xrpl/protocol_autogen/ledger_entries/FeeSettings.h

@@ -213,6 +213,78 @@ public:
         return this->sle_->isFieldPresent(sfReserveIncrementDrops);
     }
 
+    /**
+     * @brief Get sfGasLimit (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getGasLimit() const
+    {
+        if (hasGasLimit())
+            return this->sle_->at(sfGasLimit);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfGasLimit is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasGasLimit() const
+    {
+        return this->sle_->isFieldPresent(sfGasLimit);
+    }
+
+    /**
+     * @brief Get sfBytecodeSizeLimit (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getBytecodeSizeLimit() const
+    {
+        if (hasBytecodeSizeLimit())
+            return this->sle_->at(sfBytecodeSizeLimit);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfBytecodeSizeLimit is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasBytecodeSizeLimit() const
+    {
+        return this->sle_->isFieldPresent(sfBytecodeSizeLimit);
+    }
+
+    /**
+     * @brief Get sfGasPrice (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getGasPrice() const
+    {
+        if (hasGasPrice())
+            return this->sle_->at(sfGasPrice);
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfGasPrice is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasGasPrice() const
+    {
+        return this->sle_->isFieldPresent(sfGasPrice);
+    }
+
     /**
      * @brief Get sfPreviousTxnID (SoeOptional)
      * @return The field value, or std::nullopt if not present.
@@ -375,6 +447,39 @@ public:
         return *this;
     }
 
+    /**
+     * @brief Set sfGasLimit (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    FeeSettingsBuilder&
+    setGasLimit(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfGasLimit] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfBytecodeSizeLimit (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    FeeSettingsBuilder&
+    setBytecodeSizeLimit(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfBytecodeSizeLimit] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfGasPrice (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    FeeSettingsBuilder&
+    setGasPrice(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfGasPrice] = value;
+        return *this;
+    }
+
     /**
      * @brief Set sfPreviousTxnID (SoeOptional)
      * @return Reference to this builder for method chaining.

include/xrpl/protocol_autogen/transactions/EscrowCreate.h

@@ -58,6 +58,32 @@ public:
         return this->tx_->at(sfDestination);
     }
 
+    /**
+     * @brief Get sfDestinationTag (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getDestinationTag() const
+    {
+        if (hasDestinationTag())
+        {
+            return this->tx_->at(sfDestinationTag);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfDestinationTag is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasDestinationTag() const
+    {
+        return this->tx_->isFieldPresent(sfDestinationTag);
+    }
+
     /**
      * @brief Get sfAmount (SoeRequired)
      * @note This field supports MPT (Multi-Purpose Token) amounts.
@@ -149,29 +175,55 @@ public:
     }
 
     /**
-     * @brief Get sfDestinationTag (SoeOptional)
+     * @brief Get sfBytecode (SoeOptional)
      * @return The field value, or std::nullopt if not present.
      */
     [[nodiscard]]
-    protocol_autogen::Optional<SF_UINT32::type::value_type>
-    getDestinationTag() const
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getBytecode() const
     {
-        if (hasDestinationTag())
+        if (hasBytecode())
         {
-            return this->tx_->at(sfDestinationTag);
+            return this->tx_->at(sfBytecode);
         }
         return std::nullopt;
     }
 
     /**
-     * @brief Check if sfDestinationTag is present.
+     * @brief Check if sfBytecode is present.
      * @return True if the field is present, false otherwise.
      */
     [[nodiscard]]
     bool
-    hasDestinationTag() const
+    hasBytecode() const
     {
-        return this->tx_->isFieldPresent(sfDestinationTag);
+        return this->tx_->isFieldPresent(sfBytecode);
+    }
+
+    /**
+     * @brief Get sfData (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_VL::type::value_type>
+    getData() const
+    {
+        if (hasData())
+        {
+            return this->tx_->at(sfData);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfData is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasData() const
+    {
+        return this->tx_->isFieldPresent(sfData);
     }
 };
 
@@ -232,6 +284,17 @@ public:
         return *this;
     }
 
+    /**
+     * @brief Set sfDestinationTag (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowCreateBuilder&
+    setDestinationTag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfDestinationTag] = value;
+        return *this;
+    }
+
     /**
      * @brief Set sfAmount (SoeRequired)
      * @note This field supports MPT (Multi-Purpose Token) amounts.
@@ -278,13 +341,24 @@ public:
     }
 
     /**
-     * @brief Set sfDestinationTag (SoeOptional)
+     * @brief Set sfBytecode (SoeOptional)
      * @return Reference to this builder for method chaining.
      */
     EscrowCreateBuilder&
-    setDestinationTag(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    setBytecode(std::decay_t<typename SF_VL::type::value_type> const& value)
     {
-        object_[sfDestinationTag] = value;
+        object_[sfBytecode] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfData (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowCreateBuilder&
+    setData(std::decay_t<typename SF_VL::type::value_type> const& value)
+    {
+        object_[sfData] = value;
         return *this;
     }
 

include/xrpl/protocol_autogen/transactions/EscrowFinish.h

@@ -146,6 +146,32 @@ public:
     {
         return this->tx_->isFieldPresent(sfCredentialIDs);
     }
+
+    /**
+     * @brief Get sfGas (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getGas() const
+    {
+        if (hasGas())
+        {
+            return this->tx_->at(sfGas);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfGas is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasGas() const
+    {
+        return this->tx_->isFieldPresent(sfGas);
+    }
 };
 
 /**
@@ -249,6 +275,17 @@ public:
         return *this;
     }
 
+    /**
+     * @brief Set sfGas (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    EscrowFinishBuilder&
+    setGas(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfGas] = value;
+        return *this;
+    }
+
     /**
      * @brief Build and return the EscrowFinish wrapper.
      * @param publicKey The public key for signing.

include/xrpl/protocol_autogen/transactions/SetFee.h

@@ -254,6 +254,84 @@ public:
     {
         return this->tx_->isFieldPresent(sfReserveIncrementDrops);
     }
+
+    /**
+     * @brief Get sfGasLimit (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getGasLimit() const
+    {
+        if (hasGasLimit())
+        {
+            return this->tx_->at(sfGasLimit);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfGasLimit is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasGasLimit() const
+    {
+        return this->tx_->isFieldPresent(sfGasLimit);
+    }
+
+    /**
+     * @brief Get sfBytecodeSizeLimit (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getBytecodeSizeLimit() const
+    {
+        if (hasBytecodeSizeLimit())
+        {
+            return this->tx_->at(sfBytecodeSizeLimit);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfBytecodeSizeLimit is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasBytecodeSizeLimit() const
+    {
+        return this->tx_->isFieldPresent(sfBytecodeSizeLimit);
+    }
+
+    /**
+     * @brief Get sfGasPrice (SoeOptional)
+     * @return The field value, or std::nullopt if not present.
+     */
+    [[nodiscard]]
+    protocol_autogen::Optional<SF_UINT32::type::value_type>
+    getGasPrice() const
+    {
+        if (hasGasPrice())
+        {
+            return this->tx_->at(sfGasPrice);
+        }
+        return std::nullopt;
+    }
+
+    /**
+     * @brief Check if sfGasPrice is present.
+     * @return True if the field is present, false otherwise.
+     */
+    [[nodiscard]]
+    bool
+    hasGasPrice() const
+    {
+        return this->tx_->isFieldPresent(sfGasPrice);
+    }
 };
 
 /**
@@ -386,6 +464,39 @@ public:
         return *this;
     }
 
+    /**
+     * @brief Set sfGasLimit (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    SetFeeBuilder&
+    setGasLimit(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfGasLimit] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfBytecodeSizeLimit (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    SetFeeBuilder&
+    setBytecodeSizeLimit(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfBytecodeSizeLimit] = value;
+        return *this;
+    }
+
+    /**
+     * @brief Set sfGasPrice (SoeOptional)
+     * @return Reference to this builder for method chaining.
+     */
+    SetFeeBuilder&
+    setGasPrice(std::decay_t<typename SF_UINT32::type::value_type> const& value)
+    {
+        object_[sfGasPrice] = value;
+        return *this;
+    }
+
     /**
      * @brief Build and return the SetFee wrapper.
      * @param publicKey The public key for signing.

include/xrpl/tx/ApplyContext.h

@@ -15,6 +15,7 @@
 #include <xrpl/protocol/XRPAmount.h>
 
 #include <cstddef>
+#include <cstdint>
 #include <functional>
 #include <optional>
 #include <utility>
@@ -95,6 +96,24 @@ public:
         view_->deliver(amount);
     }
 
+    /**
+     * Sets the gas used in the metadata
+     */
+    void
+    setGasUsed(std::uint32_t const gasUsed)
+    {
+        gasUsed_ = gasUsed;
+    }
+
+    /**
+     * Sets the gas used in the metadata
+     */
+    void
+    setVMReturnCode(std::int32_t const vmReturnCode)
+    {
+        vmReturnCode_ = vmReturnCode;
+    }
+
     /**
      * Discard changes and start fresh.
      */
@@ -163,6 +182,8 @@ private:
 
     // The ID of the batch transaction we are executing under, if set.
     std::optional<uint256 const> parentBatchId_;
+    std::optional<std::uint32_t> gasUsed_;
+    std::optional<std::int32_t> vmReturnCode_;
 };
 
 }  // namespace xrpl

include/xrpl/tx/transactors/escrow/EscrowCreate.h

@@ -20,15 +20,21 @@ public:
     {
     }
 
-    static TxConsequences
-    makeTxConsequences(PreflightContext const& ctx);
-
     static bool
     checkExtraFeatures(PreflightContext const& ctx);
 
+    static TxConsequences
+    makeTxConsequences(PreflightContext const& ctx);
+
+    static XRPAmount
+    calculateBaseFee(ReadView const& view, STTx const& tx);
+
     static NotTEC
     preflight(PreflightContext const& ctx);
 
+    static NotTEC
+    preflightSigValidated(PreflightContext const& ctx);
+
     static TER
     preclaim(PreclaimContext const& ctx);
 

include/xrpl/tx/wasm/HostFunc.h

@@ -0,0 +1,500 @@
+#pragma once
+
+#include <xrpl/basics/Slice.h>
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/basics/contract.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Asset.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/UintTypes.h>
+#include <xrpl/tx/wasm/WasmCommon.h>
+
+#include <cstdint>
+#include <expected>
+#include <functional>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+
+namespace xrpl {
+
+namespace wasm_float {
+
+std::string
+floatToString(Slice const& data);
+
+std::expected<Bytes, HostFunctionError>
+floatFromIntImpl(int64_t x, int32_t mode);
+
+std::expected<Bytes, HostFunctionError>
+floatFromUintImpl(uint64_t x, int32_t mode);
+
+std::expected<Bytes, HostFunctionError>
+floatFromSTAmountImpl(STAmount const& x, int32_t mode);
+
+std::expected<Bytes, HostFunctionError>
+floatFromSTNumberImpl(STNumber const& x, int32_t mode);
+
+std::expected<int64_t, HostFunctionError>
+floatToIntImpl(Slice const& x, int32_t mode);
+
+std::expected<FloatPair, HostFunctionError>
+floatToMantExpImpl(Slice const& x);
+
+std::expected<Bytes, HostFunctionError>
+floatFromMantExpImpl(int64_t mantissa, int32_t exponent, int32_t mode);
+
+std::expected<int32_t, HostFunctionError>
+floatCompareImpl(Slice const& x, Slice const& y);
+
+std::expected<Bytes, HostFunctionError>
+floatAddImpl(Slice const& x, Slice const& y, int32_t mode);
+
+std::expected<Bytes, HostFunctionError>
+floatSubtractImpl(Slice const& x, Slice const& y, int32_t mode);
+
+std::expected<Bytes, HostFunctionError>
+floatMultiplyImpl(Slice const& x, Slice const& y, int32_t mode);
+
+std::expected<Bytes, HostFunctionError>
+floatDivideImpl(Slice const& x, Slice const& y, int32_t mode);
+
+std::expected<Bytes, HostFunctionError>
+floatRootImpl(Slice const& x, int32_t n, int32_t mode);
+
+std::expected<Bytes, HostFunctionError>
+floatPowerImpl(Slice const& x, int32_t n, int32_t mode);
+
+}  // namespace wasm_float
+
+// Intended to work only through wasm runtime. Don't call them directly, except with unit tests
+class HostFunctions
+{
+protected:
+    RTOptRef rt_;
+    beast::Journal j_;
+
+public:
+    HostFunctions(beast::Journal j = beast::Journal{beast::Journal::getNullSink()}) : j_(j)
+    {
+    }
+
+    void
+    setRT(WasmRuntimeWrapper& rt)
+    {
+        rt_ = rt;
+    }
+
+    void
+    resetRT()
+    {
+        rt_ = std::nullopt;
+    }
+
+    [[nodiscard]] WasmRuntimeWrapper&
+    getRT() const
+    {
+        if (!rt_)
+            Throw<std::logic_error>("Wasm runtime not set");
+        return rt_->get();
+    }
+
+    [[nodiscard]] beast::Journal
+    getJournal() const
+    {
+        return j_;
+    }
+
+    // LCOV_EXCL_START
+
+    [[nodiscard]] virtual bool
+    checkSelf() const
+    {
+        return true;
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<std::uint32_t, HostFunctionError>
+    getLedgerSqn() const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<std::uint32_t, HostFunctionError>
+    getParentLedgerTime() const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Hash, HostFunctionError>
+    getParentLedgerHash() const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<uint32_t, HostFunctionError>
+    getBaseFee() const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
+    isAmendmentEnabled(uint256 const& amendmentId) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
+    isAmendmentEnabled(std::string_view const& amendmentName) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    virtual std::expected<int32_t, HostFunctionError>
+    cacheLedgerObj(uint256 const& objId, int32_t cacheIdx)
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    getTxField(SField const& fname) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    getCurrentLedgerObjField(SField const& fname) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    getLedgerObjField(int32_t cacheIdx, SField const& fname) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    getTxNestedField(FieldLocator const& locator) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    getCurrentLedgerObjNestedField(FieldLocator const& locator) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    getLedgerObjNestedField(int32_t cacheIdx, FieldLocator const& locator) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
+    getTxArrayLen(SField const& fname) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
+    getCurrentLedgerObjArrayLen(SField const& fname) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
+    getLedgerObjArrayLen(int32_t cacheIdx, SField const& fname) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
+    getTxNestedArrayLen(FieldLocator const& locator) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
+    getCurrentLedgerObjNestedArrayLen(FieldLocator const& locator) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
+    getLedgerObjNestedArrayLen(int32_t cacheIdx, FieldLocator const& locator) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    virtual std::expected<int32_t, HostFunctionError>
+    updateData(Slice const& data)
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
+    checkSignature(Slice const& message, Slice const& signature, Slice const& pubkey) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Hash, HostFunctionError>
+    computeSha512HalfHash(Slice const& data) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    accountKeylet(AccountID const& account) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    ammKeylet(Asset const& issue1, Asset const& issue2) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    checkKeylet(AccountID const& account, std::uint32_t seq) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    credentialKeylet(AccountID const& subject, AccountID const& issuer, Slice const& credentialType)
+        const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    didKeylet(AccountID const& account) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    delegateKeylet(AccountID const& account, AccountID const& authorize) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    depositPreauthKeylet(AccountID const& account, AccountID const& authorize) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    escrowKeylet(AccountID const& account, std::uint32_t seq) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    trustLineKeylet(AccountID const& account1, AccountID const& account2, Currency const& currency)
+        const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    mptokenIssuanceKeylet(AccountID const& issuer, std::uint32_t seq) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    mptokenKeylet(MPTID const& mptid, AccountID const& holder) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    nftokenOfferKeylet(AccountID const& account, std::uint32_t seq) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    offerKeylet(AccountID const& account, std::uint32_t seq) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    oracleKeylet(AccountID const& account, std::uint32_t docId) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    paychannelKeylet(AccountID const& account, AccountID const& destination, std::uint32_t seq)
+        const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    permissionedDomainKeylet(AccountID const& account, std::uint32_t seq) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    signerListKeylet(AccountID const& account) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    ticketKeylet(AccountID const& account, std::uint32_t seq) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    vaultKeylet(AccountID const& account, std::uint32_t seq) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    getNFT(AccountID const& account, uint256 const& nftId) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    getNFTIssuer(uint256 const& nftId) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<std::uint32_t, HostFunctionError>
+    getNFTTaxon(uint256 const& nftId) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
+    getNFTFlags(uint256 const& nftId) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
+    getNFTTransferFee(uint256 const& nftId) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<std::uint32_t, HostFunctionError>
+    getNFTSequence(uint256 const& nftId) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    // A no-op rather than Unimplemented: trace only writes to the local log.
+    // trace_wrap has already rendered the guest's buffer into `data`.
+    virtual void
+    trace(std::string_view const& msg, std::string_view const& data) const
+    {
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    floatFromInt(int64_t x, int32_t mode) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    floatFromUint(uint64_t x, int32_t mode) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    floatFromSTAmount(STAmount const& x, int32_t mode) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    floatFromSTNumber(STNumber const& x, int32_t mode) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int64_t, HostFunctionError>
+    floatToInt(Slice const& x, int32_t mode) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<FloatPair, HostFunctionError>
+    floatToMantExp(Slice const& x) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    floatFromMantExp(int64_t mantissa, int32_t exponent, int32_t mode) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<int32_t, HostFunctionError>
+    floatCompare(Slice const& x, Slice const& y) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    floatAdd(Slice const& x, Slice const& y, int32_t mode) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    floatSubtract(Slice const& x, Slice const& y, int32_t mode) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    floatMultiply(Slice const& x, Slice const& y, int32_t mode) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    floatDivide(Slice const& x, Slice const& y, int32_t mode) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    floatRoot(Slice const& x, int32_t n, int32_t mode) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] [[nodiscard]] virtual std::expected<Bytes, HostFunctionError>
+    floatPower(Slice const& x, int32_t n, int32_t mode) const
+    {
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    virtual ~HostFunctions() = default;
+    // LCOV_EXCL_STOP
+};
+
+using HFRef = std::reference_wrapper<HostFunctions>;
+
+}  // namespace xrpl

include/xrpl/tx/wasm/HostFuncImpl.h

@@ -0,0 +1,290 @@
+#pragma once
+
+#include <xrpl/basics/Slice.h>
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/core/ServiceRegistry.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Asset.h>
+#include <xrpl/protocol/Keylet.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STAmount.h>
+#include <xrpl/protocol/UintTypes.h>
+#include <xrpl/tx/ApplyContext.h>
+#include <xrpl/tx/wasm/HostFunc.h>
+#include <xrpl/tx/wasm/WasmCommon.h>
+
+#include <algorithm>
+#include <array>
+#include <cstdint>
+#include <expected>
+#include <memory>
+#include <optional>
+#include <string_view>
+
+namespace xrpl {
+
+// Intended to work only through wasm runtime. Don't call them directly, except with unit tests
+class WasmHostFunctionsImpl : public HostFunctions
+{
+    ApplyContext& ctx_;
+
+    Keylet leKey_;
+    mutable std::optional<std::shared_ptr<SLE const>> currentLedgerObj_;
+
+    static int constexpr maxCache = 256;
+    std::array<std::shared_ptr<SLE const>, maxCache> cache_;
+
+    std::optional<Bytes> data_;
+
+public:
+    std::expected<std::shared_ptr<SLE const>, HostFunctionError>
+    getCurrentLedgerObj() const
+    {
+        if (!currentLedgerObj_)
+            currentLedgerObj_ = ctx_.view().read(leKey_);
+        if (*currentLedgerObj_)
+            return *currentLedgerObj_;
+        return std::unexpected(HostFunctionError::LedgerObjNotFound);
+    }
+
+    std::expected<int32_t, HostFunctionError>
+    normalizeCacheIndex(int32_t cacheIdx) const
+    {
+        --cacheIdx;
+        if (cacheIdx < 0 || cacheIdx >= maxCache)
+            return std::unexpected(HostFunctionError::SlotOutRange);
+        if (!cache_[cacheIdx])
+            return std::unexpected(HostFunctionError::EmptySlot);
+        return cacheIdx;
+    }
+
+    template <typename F>
+    void
+    log(std::string_view const& msg, F&& dataFn) const
+    {
+#ifdef DEBUG_OUTPUT
+        auto& j = std::cerr;
+#else
+        if (!getJournal().active(beast::Severity::Trace))
+            return;
+        auto j = getJournal().trace();
+#endif
+        j << "WasmTrace[" << toShortString(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)
+    {
+    }
+
+    bool
+    checkSelf() const override
+    {
+        return !currentLedgerObj_ && !data_ &&
+            std::ranges::none_of(cache_, [](auto const& p) { return !!p; });
+    }
+
+    std::optional<Bytes> const&
+    getData() const
+    {
+        return data_;
+    }
+
+    std::expected<std::uint32_t, HostFunctionError>
+    getLedgerSqn() const override;
+
+    std::expected<std::uint32_t, HostFunctionError>
+    getParentLedgerTime() const override;
+
+    std::expected<Hash, HostFunctionError>
+    getParentLedgerHash() const override;
+
+    std::expected<std::uint32_t, HostFunctionError>
+    getBaseFee() const override;
+
+    std::expected<int32_t, HostFunctionError>
+    isAmendmentEnabled(uint256 const& amendmentId) const override;
+
+    std::expected<int32_t, HostFunctionError>
+    isAmendmentEnabled(std::string_view const& amendmentName) const override;
+
+    std::expected<int32_t, HostFunctionError>
+    cacheLedgerObj(uint256 const& objId, int32_t cacheIdx) override;
+
+    std::expected<Bytes, HostFunctionError>
+    getTxField(SField const& fname) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    getCurrentLedgerObjField(SField const& fname) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    getLedgerObjField(int32_t cacheIdx, SField const& fname) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    getTxNestedField(FieldLocator const& locator) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    getCurrentLedgerObjNestedField(FieldLocator const& locator) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    getLedgerObjNestedField(int32_t cacheIdx, FieldLocator const& locator) const override;
+
+    std::expected<int32_t, HostFunctionError>
+    getTxArrayLen(SField const& fname) const override;
+
+    std::expected<int32_t, HostFunctionError>
+    getCurrentLedgerObjArrayLen(SField const& fname) const override;
+
+    std::expected<int32_t, HostFunctionError>
+    getLedgerObjArrayLen(int32_t cacheIdx, SField const& fname) const override;
+
+    std::expected<int32_t, HostFunctionError>
+    getTxNestedArrayLen(FieldLocator const& locator) const override;
+
+    std::expected<int32_t, HostFunctionError>
+    getCurrentLedgerObjNestedArrayLen(FieldLocator const& locator) const override;
+
+    std::expected<int32_t, HostFunctionError>
+    getLedgerObjNestedArrayLen(int32_t cacheIdx, FieldLocator const& locator) const override;
+
+    std::expected<int32_t, HostFunctionError>
+    updateData(Slice const& data) override;
+
+    std::expected<int32_t, HostFunctionError>
+    checkSignature(Slice const& message, Slice const& signature, Slice const& pubkey)
+        const override;
+
+    std::expected<Hash, HostFunctionError>
+    computeSha512HalfHash(Slice const& data) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    accountKeylet(AccountID const& account) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    ammKeylet(Asset const& issue1, Asset const& issue2) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    checkKeylet(AccountID const& account, std::uint32_t seq) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    credentialKeylet(AccountID const& subject, AccountID const& issuer, Slice const& credentialType)
+        const override;
+
+    std::expected<Bytes, HostFunctionError>
+    didKeylet(AccountID const& account) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    delegateKeylet(AccountID const& account, AccountID const& authorize) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    depositPreauthKeylet(AccountID const& account, AccountID const& authorize) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    escrowKeylet(AccountID const& account, std::uint32_t seq) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    trustLineKeylet(AccountID const& account1, AccountID const& account2, Currency const& currency)
+        const override;
+
+    std::expected<Bytes, HostFunctionError>
+    mptokenIssuanceKeylet(AccountID const& issuer, std::uint32_t seq) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    mptokenKeylet(MPTID const& mptid, AccountID const& holder) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    nftokenOfferKeylet(AccountID const& account, std::uint32_t seq) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    offerKeylet(AccountID const& account, std::uint32_t seq) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    oracleKeylet(AccountID const& account, std::uint32_t docId) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    paychannelKeylet(AccountID const& account, AccountID const& destination, std::uint32_t seq)
+        const override;
+
+    std::expected<Bytes, HostFunctionError>
+    permissionedDomainKeylet(AccountID const& account, std::uint32_t seq) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    signerListKeylet(AccountID const& account) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    ticketKeylet(AccountID const& account, std::uint32_t seq) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    vaultKeylet(AccountID const& account, std::uint32_t seq) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    getNFT(AccountID const& account, uint256 const& nftId) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    getNFTIssuer(uint256 const& nftId) const override;
+
+    std::expected<std::uint32_t, HostFunctionError>
+    getNFTTaxon(uint256 const& nftId) const override;
+
+    std::expected<int32_t, HostFunctionError>
+    getNFTFlags(uint256 const& nftId) const override;
+
+    std::expected<int32_t, HostFunctionError>
+    getNFTTransferFee(uint256 const& nftId) const override;
+
+    std::expected<std::uint32_t, HostFunctionError>
+    getNFTSequence(uint256 const& nftId) const override;
+
+    void
+    trace(std::string_view const& msg, std::string_view const& data) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    floatFromInt(int64_t x, int32_t mode) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    floatFromUint(uint64_t x, int32_t mode) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    floatFromSTAmount(STAmount const& x, int32_t mode) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    floatFromSTNumber(STNumber const& x, int32_t mode) const override;
+
+    std::expected<int64_t, HostFunctionError>
+    floatToInt(Slice const& x, int32_t mode) const override;
+
+    std::expected<FloatPair, HostFunctionError>
+    floatToMantExp(Slice const& x) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    floatFromMantExp(int64_t mantissa, int32_t exponent, int32_t mode) const override;
+
+    std::expected<int32_t, HostFunctionError>
+    floatCompare(Slice const& x, Slice const& y) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    floatAdd(Slice const& x, Slice const& y, int32_t mode) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    floatSubtract(Slice const& x, Slice const& y, int32_t mode) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    floatMultiply(Slice const& x, Slice const& y, int32_t mode) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    floatDivide(Slice const& x, Slice const& y, int32_t mode) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    floatRoot(Slice const& x, int32_t n, int32_t mode) const override;
+
+    std::expected<Bytes, HostFunctionError>
+    floatPower(Slice const& x, int32_t n, int32_t mode) const override;
+};
+
+}  // namespace xrpl

include/xrpl/tx/wasm/HostFuncWrapper.h

@@ -0,0 +1,244 @@
+#pragma once
+
+#include <xrpl/tx/wasm/HostFunc.h>
+
+#include <wasm.h>
+
+#include <cstdint>
+
+namespace xrpl {
+
+#define WASM_CB_PARAMS_LIST void *env, wasm_val_vec_t const *params, wasm_val_vec_t *results
+#define WASM_SECONDARY_CB_PARAMS_LIST \
+    HostFunctions &hf, wasm_val_vec_t const *params, wasm_val_vec_t *results
+
+wasm_trap_t* HostFuncMain_wrap(WASM_CB_PARAMS_LIST);
+
+using getLedgerSqn_proto = int32_t(uint8_t*, int32_t);
+wasm_trap_t* getLedgerSqn_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using getParentLedgerTime_proto = int32_t(uint8_t*, int32_t);
+wasm_trap_t* getParentLedgerTime_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using getParentLedgerHash_proto = int32_t(uint8_t*, int32_t);
+wasm_trap_t* getParentLedgerHash_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using getBaseFee_proto = int32_t(uint8_t*, int32_t);
+wasm_trap_t* getBaseFee_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using isAmendmentEnabled_proto = int32_t(uint8_t const*, int32_t);
+wasm_trap_t* isAmendmentEnabled_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using cacheLedgerObj_proto = int32_t(uint8_t const*, int32_t, int32_t);
+wasm_trap_t* cacheLedgerObj_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using getTxField_proto = int32_t(int32_t, uint8_t*, int32_t);
+wasm_trap_t* getTxField_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using getCurrentLedgerObjField_proto = int32_t(int32_t, uint8_t*, int32_t);
+wasm_trap_t* getCurrentLedgerObjField_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using getLedgerObjField_proto = int32_t(int32_t, int32_t, uint8_t*, int32_t);
+wasm_trap_t* getLedgerObjField_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using getTxNestedField_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* getTxNestedField_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using getCurrentLedgerObjNestedField_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* getCurrentLedgerObjNestedField_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using getLedgerObjNestedField_proto = int32_t(int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* getLedgerObjNestedField_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using getTxArrayLen_proto = int32_t(int32_t);
+wasm_trap_t* getTxArrayLen_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using getCurrentLedgerObjArrayLen_proto = int32_t(int32_t);
+wasm_trap_t* getCurrentLedgerObjArrayLen_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using getLedgerObjArrayLen_proto = int32_t(int32_t, int32_t);
+wasm_trap_t* getLedgerObjArrayLen_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using getTxNestedArrayLen_proto = int32_t(uint8_t const*, int32_t);
+wasm_trap_t* getTxNestedArrayLen_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using getCurrentLedgerObjNestedArrayLen_proto = int32_t(uint8_t const*, int32_t);
+wasm_trap_t* getCurrentLedgerObjNestedArrayLen_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using getLedgerObjNestedArrayLen_proto = int32_t(int32_t, uint8_t const*, int32_t);
+wasm_trap_t* getLedgerObjNestedArrayLen_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using updateData_proto = int32_t(uint8_t const*, int32_t);
+wasm_trap_t* updateData_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+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(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using computeSha512HalfHash_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* computeSha512HalfHash_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using accountKeylet_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* accountKeylet_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using ammKeylet_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* ammKeylet_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using checkKeylet_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* checkKeylet_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+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(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using delegateKeylet_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* delegateKeylet_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using depositPreauthKeylet_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* depositPreauthKeylet_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using didKeylet_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* didKeylet_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using escrowKeylet_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* escrowKeylet_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using trustLineKeylet_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* trustLineKeylet_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using mptokenIssuanceKeylet_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* mptokenIssuanceKeylet_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using mptokenKeylet_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* mptokenKeylet_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using nftokenOfferKeylet_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* nftokenOfferKeylet_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using offerKeylet_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* offerKeylet_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using oracleKeylet_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* oracleKeylet_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using paychannelKeylet_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* paychannelKeylet_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using permissionedDomainKeylet_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* permissionedDomainKeylet_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using signerListKeylet_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* signerListKeylet_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using ticketKeylet_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* ticketKeylet_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using vaultKeylet_proto =
+    int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* vaultKeylet_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using getNFT_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* getNFT_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using getNFTIssuer_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* getNFTIssuer_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using getNFTTaxon_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* getNFTTaxon_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using getNFTFlags_proto = int32_t(uint8_t const*, int32_t);
+wasm_trap_t* getNFTFlags_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using getNFTTransferFee_proto = int32_t(uint8_t const*, int32_t);
+wasm_trap_t* getNFTTransferFee_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using getNFTSequence_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* getNFTSequence_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+// trace(msg_ptr, msg_len, data_type, data_ptr, data_len); data_type is a
+// TraceDataType.
+using trace_proto = void(uint8_t const*, int32_t, int32_t, uint8_t const*, int32_t);
+wasm_trap_t* trace_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using floatFromInt_proto = int32_t(int64_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t* floatFromInt_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using floatFromUint_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t* floatFromUint_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using floatFromSTAmount_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t* floatFromSTAmount_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using floatFromSTNumber_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t* floatFromSTNumber_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using floatToInt_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t* floatToInt_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using floatToMantExp_proto = int32_t(uint8_t const*, int32_t, uint8_t*, int32_t, uint8_t*, int32_t);
+wasm_trap_t* floatToMantExp_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using floatFromMantExp_proto = int32_t(int64_t, int32_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t* floatFromMantExp_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using floatCompare_proto = int32_t(uint8_t const*, int32_t, uint8_t const*, int32_t);
+wasm_trap_t* floatCompare_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+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(WASM_SECONDARY_CB_PARAMS_LIST);
+
+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(WASM_SECONDARY_CB_PARAMS_LIST);
+
+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(WASM_SECONDARY_CB_PARAMS_LIST);
+
+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(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using floatRoot_proto = int32_t(uint8_t const*, int32_t, int32_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t* floatRoot_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+using floatPower_proto = int32_t(uint8_t const*, int32_t, int32_t, uint8_t*, int32_t, int32_t);
+wasm_trap_t* floatPower_wrap(WASM_SECONDARY_CB_PARAMS_LIST);
+
+}  // namespace xrpl

include/xrpl/tx/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
+  `std::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
+`escrowFunctionName` (currently `"escrow_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 std::expected<ReturnType, HostFunctionError>
+myNewFunction(ParamType1 param1, ParamType2 param2)
+{
+    return std::unexpected(HostFunctionError::INTERNAL);
+}
+```
+
+### 2. Add to HostFuncImpl.h (Declaration)
+
+Add the method override declaration in `WasmHostFunctionsImpl`:
+
+```cpp
+std::expected<ReturnType, HostFunctionError>
+myNewFunction(ParamType1 param1, ParamType2 param2) override;
+```
+
+### 3. Implement in detail/HostFuncImpl\*.cpp
+
+Add the implementation in the appropriate file:
+
+```cpp
+std::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.

include/xrpl/tx/wasm/WasmCommon.h

@@ -0,0 +1,253 @@
+#pragma once
+
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/basics/contract.h>
+#include <xrpl/protocol/TER.h>
+
+#include <bit>
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <optional>
+#include <stdexcept>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+namespace xrpl {
+
+using Bytes = std::vector<std::uint8_t>;
+using Hash = xrpl::uint256;
+using FloatPair = std::pair<int64_t, int32_t>;
+
+// Error signals that cross the wasm boundary as trap messages (the C API has no
+// trap code). WasmiEngine::call maps them to TER: hfErrInternal -> tecINTERNAL,
+// hfErrOutOfGas / wasmi's OutOfFuel -> tecOUT_OF_GAS, anything else ->
+// tecFAILED_PROCESSING.
+//
+// Matched as substrings, not by equality: the C API returns the Rust Debug form
+// of the error, e.g. `Error { kind: Message("HfInternal") }` or
+// `Error { kind: TrapCode(OutOfFuel) }`.
+std::string_view inline constexpr hfErrInternal = "HfInternal";
+std::string_view inline constexpr hfErrOutOfGas = "HfOutOfGas";
+std::string_view inline constexpr wasmiTrapOutOfFuel = "OutOfFuel";
+
+// Guest ABI, mirrored in the wasm stdlib: append only, never renumber. Starts at
+// 1 so a zeroed data_type is rejected rather than treated as Int64.
+enum class TraceDataType : std::int32_t {
+    Int64 = 1,
+    Uint64,
+    Xfloat,
+    Account,
+    Amount,
+    AsHex,   // raw bytes, hex-encoded by the host before printing
+    AsText,  // bytes printed verbatim as text
+};
+
+enum class HostFunctionError : int32_t {
+    Unimplemented = -1,
+    FieldNotFound = -2,
+    BufferTooSmall = -3,
+    NoArray = -4,
+    NotLeafField = -5,
+    LocatorMalformed = -6,
+    SlotOutRange = -7,
+    SlotsFull = -8,
+    EmptySlot = -9,
+    LedgerObjNotFound = -10,
+    OutOfTransferLimit = -11,
+    DataFieldTooLarge = -12,
+    PointerOutOfBounds = -13,
+    NoMemExported = -14,
+    InvalidParams = -15,
+    InvalidAccount = -16,
+    InvalidField = -17,
+    IndexOutOfBounds = -18,
+    FloatInputMalformed = -19,
+    FloatComputationError = -20,
+};
+
+enum class WasmTypes { WtI32, WtI64 };
+
+struct Wmem
+{
+    std::uint8_t* p = nullptr;
+    std::size_t s = 0;
+
+    Wmem() = default;
+    Wmem(void* ptr, std::size_t size) : p(reinterpret_cast<std::uint8_t*>(ptr)), s(size)
+    {
+    }
+};
+
+template <typename T>
+struct WasmResult
+{
+    T result;
+    int64_t cost;
+};
+using EscrowResult = WasmResult<int32_t>;
+
+// Engine error when wasm does not run to completion. `cost` is the gas consumed
+// when meaningful (tecOUT_OF_GAS / tecFAILED_PROCESSING; caller writes it to tx
+// metadata); std::nullopt for tecINTERNAL and malformed input (no gas reported).
+struct WasmTER
+{
+    TER ter;
+    std::optional<int64_t> cost;
+};
+
+class FieldLocator
+{
+    int32_t const* ptr_ = nullptr;
+    uint32_t size_ = 0;
+    std::vector<int32_t> buf_;
+
+public:
+    FieldLocator(std::vector<int32_t>&& buf)
+        : ptr_(&buf[0]), size_(buf.size()), buf_(std::move(buf))
+    {
+    }
+
+    FieldLocator(int32_t const* ptr, uint32_t const size) : ptr_(ptr), size_(size)
+    {
+    }
+
+    FieldLocator(FieldLocator const&) = delete;
+    FieldLocator&
+    operator=(FieldLocator const&) = delete;
+    FieldLocator(FieldLocator&&) = default;
+    FieldLocator&
+    operator=(FieldLocator&&) = default;
+
+    int32_t
+    operator[](unsigned i) const
+    {
+        if (i >= size_)
+            Throw<std::runtime_error>("index out of bounds");
+        return ptr_[i];
+    }
+
+    [[nodiscard]] uint32_t
+    size() const
+    {
+        return size_;
+    }
+
+    [[nodiscard]] int32_t const*
+    data() const
+    {
+        return ptr_;
+    }
+
+    [[nodiscard]] bool
+    empty() const
+    {
+        return size_ == 0;
+    }
+};
+
+class WasmRuntimeWrapper
+{
+public:
+    virtual ~WasmRuntimeWrapper() = default;
+
+    virtual Wmem
+    getMem() = 0;
+
+    virtual std::int64_t
+    getGas() = 0;
+
+    virtual std::int64_t
+    setGas(std::int64_t gas) = 0;
+
+    virtual std::int64_t
+    getTransferLimit() = 0;
+
+    virtual std::int64_t
+    setTransferLimit(std::int64_t transferLimit) = 0;
+};
+using RTOptRef = std::optional<std::reference_wrapper<WasmRuntimeWrapper>>;
+
+struct WasmParam
+{
+    // We are not supporting float/double
+
+    WasmTypes type = WasmTypes::WtI32;
+    union
+    {
+        std::int32_t i32;
+        std::int64_t i64 = 0;
+    } of;
+};
+
+template <class... Types>
+inline void
+wasmParamsHlp(std::vector<WasmParam>& v, std::int32_t p, Types&&... args)
+{
+    v.push_back({.type = WasmTypes::WtI32, .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 = WasmTypes::WtI64, .of = {.i64 = p}});
+    wasmParamsHlp(v, std::forward<Types>(args)...);
+}
+
+inline void
+wasmParamsHlp(std::vector<WasmParam>& v)
+{
+}
+
+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)>
+constexpr T
+adjustWasmEndianessHlp(T x)
+{
+    static_assert(std::is_integral_v<T>, "Only integral types");
+    if constexpr (Size > 1)
+    {
+        using U = std::make_unsigned_t<T>;
+        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)>
+constexpr T
+adjustWasmEndianess(T x)
+{
+    // LCOV_EXCL_START
+    static_assert(std::is_integral_v<T>, "Only integral types");
+    if constexpr (std::endian::native == std::endian::big)
+    {
+        return adjustWasmEndianessHlp(x);
+    }
+    return x;
+    // LCOV_EXCL_STOP
+}
+
+constexpr int32_t
+hfErrorToInt(HostFunctionError e)
+{
+    return static_cast<int32_t>(e);
+}
+
+}  // namespace xrpl

include/xrpl/tx/wasm/WasmImportsHelper.h

@@ -0,0 +1,126 @@
+#pragma once
+
+#include <xrpl/tx/wasm/HostFunc.h>
+#include <xrpl/tx/wasm/WasmCommon.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 <wasm.h>
+
+#include <cstdint>
+#include <optional>
+#include <string_view>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace bft = boost::function_types;
+
+namespace xrpl {
+
+using wasmSecondaryCbFuncType =
+    wasm_trap_t*(HostFunctions&, wasm_val_vec_t const*, wasm_val_vec_t*);
+
+struct WasmImportFunc
+{
+    std::string_view name;
+    std::optional<WasmTypes> result;
+    std::vector<WasmTypes> params;
+
+    wasmSecondaryCbFuncType* wrap = nullptr;
+    uint32_t gas = 0;
+};
+
+using WasmUserData = std::pair<HFRef, WasmImportFunc>;
+// string - import function name
+using ImportVec = std::unordered_map<std::string_view, WasmUserData>;
+
+template <int N, int C, typename Mpl>
+void
+WasmImpArgs(WasmImportFunc& e)
+{
+    if constexpr (N < C)
+    {
+        using at = boost::mpl::at_c<Mpl, N>::type;
+        if constexpr (std::is_pointer_v<at> || std::is_same_v<at, std::int32_t>)
+        {
+            e.params.push_back(WasmTypes::WtI32);
+        }
+        else if constexpr (std::is_same_v<at, std::int64_t>)
+        {
+            e.params.push_back(WasmTypes::WtI64);
+        }
+        else
+        {
+            static_assert(std::is_pointer_v<at>, "Unsupported argument type");
+        }
+
+        return WasmImpArgs<N + 1, C, Mpl>(e);
+    }
+}
+
+template <typename>
+inline constexpr bool wasmDependentFalse = false;
+
+template <typename Rt>
+void
+WasmImpRet(WasmImportFunc& e)
+{
+    if constexpr (std::is_pointer_v<Rt> || std::is_same_v<Rt, std::int32_t>)
+    {
+        e.result = WasmTypes::WtI32;
+    }
+    else if constexpr (std::is_same_v<Rt, std::int64_t>)
+    {
+        e.result = WasmTypes::WtI64;
+    }
+    else if constexpr (std::is_void_v<Rt>)
+    {
+        e.result.reset();
+    }
+    else
+    {
+        static_assert(wasmDependentFalse<Rt>, "Unsupported return type");
+    }
+}
+
+template <typename F>
+void
+WasmImpFuncHelper(WasmImportFunc& e)
+{
+    using rt = bft::result_type<F>::type;
+    using pt = 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));
+}
+
+// imp_name - string literal, must have static lifetime
+template <typename F>
+void
+WasmImpFunc(
+    ImportVec& v,
+    std::string_view impName,
+    wasmSecondaryCbFuncType* fWrap,
+    HostFunctions& hf,
+    uint32_t gas = 0)
+{
+    WasmImportFunc e;
+    e.name = impName;
+    e.wrap = fWrap;
+    e.gas = gas;
+    WasmImpFuncHelper<F>(e);
+    v.emplace(impName, std::make_pair(HFRef(hf), std::move(e)));
+}
+
+#define WASM_IMPORT_FUNC(v, f, ...) WasmImpFunc<f##_proto>(v, #f, &f##_wrap, ##__VA_ARGS__)
+
+// n - string literal name, must have static lifetime
+#define WASM_IMPORT_FUNC2(v, f, n, ...) WasmImpFunc<f##_proto>(v, n, &f##_wrap, ##__VA_ARGS__)
+
+}  // namespace xrpl

include/xrpl/tx/wasm/WasmVM.h

@@ -0,0 +1,97 @@
+#pragma once
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/protocol/TER.h>
+#include <xrpl/tx/wasm/HostFunc.h>
+#include <xrpl/tx/wasm/WasmCommon.h>
+#include <xrpl/tx/wasm/WasmImportsHelper.h>
+
+#include <cstdint>
+#include <expected>
+#include <memory>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace xrpl {
+
+std::string_view inline constexpr wEnv = "env";
+std::string_view inline constexpr wHostLib = "host_lib";
+std::string_view inline constexpr wMem = "memory";
+std::string_view inline constexpr wStore = "store";
+std::string_view inline constexpr wLoad = "load";
+std::string_view inline constexpr wSize = "size";
+std::string_view inline constexpr wAlloc = "allocate";
+std::string_view inline constexpr wDealloc = "deallocate";
+std::string_view inline constexpr wProcExit = "proc_exit";
+
+std::string_view inline constexpr escrowFunctionName = "escrow_finish";
+
+uint32_t inline constexpr maxPages = 128;  // 8MB = 64KB*128
+
+class WasmiEngine;
+
+class WasmEngine
+{
+    std::unique_ptr<WasmiEngine> const impl_;
+
+    WasmEngine();
+
+public:
+    WasmEngine(WasmEngine const&) = delete;
+    WasmEngine(WasmEngine&&) = delete;
+    WasmEngine&
+    operator=(WasmEngine const&) = delete;
+    WasmEngine&
+    operator=(WasmEngine&&) = delete;
+
+    static WasmEngine&
+    instance();
+
+    std::expected<WasmResult<int32_t>, WasmTER>
+    run(Bytes const& wasmCode,
+        HostFunctions& hfs,
+        int64_t gasLimit,
+        std::string_view funcName = {},
+        std::vector<WasmParam> const& params = {},
+        ImportVec const& imports = {},
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()});
+
+    NotTEC
+    check(
+        Bytes const& wasmCode,
+        HostFunctions& hfs,
+        std::string_view funcName,
+        std::vector<WasmParam> const& params = {},
+        ImportVec const& imports = {},
+        beast::Journal j = beast::Journal{beast::Journal::getNullSink()});
+
+    // Host functions helper functionality
+    void*
+    newTrap(std::string const& txt = std::string());
+
+    [[nodiscard]] beast::Journal
+    getJournal() const;
+};
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ImportVec
+createWasmImport(HostFunctions& hfs);
+
+std::expected<EscrowResult, WasmTER>
+runEscrowWasm(
+    Bytes const& wasmCode,
+    HostFunctions& hfs,
+    int64_t gasLimit,
+    std::string_view funcName = escrowFunctionName,
+    std::vector<WasmParam> const& params = {});
+
+NotTEC
+preflightEscrowWasm(
+    Bytes const& wasmCode,
+    HostFunctions& hfs,
+    std::string_view funcName = escrowFunctionName,
+    std::vector<WasmParam> const& params = {});
+
+}  // namespace xrpl

include/xrpl/tx/wasm/WasmiVM.h

@@ -0,0 +1,462 @@
+#pragma once
+
+#include <xrpl/basics/contract.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/protocol/Protocol.h>
+#include <xrpl/protocol/TER.h>
+#include <xrpl/tx/wasm/HostFunc.h>
+#include <xrpl/tx/wasm/WasmCommon.h>
+#include <xrpl/tx/wasm/WasmImportsHelper.h>
+#include <xrpl/tx/wasm/WasmVM.h>
+
+#include <wasm.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <expected>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+namespace xrpl {
+
+template <class T, void (*Create)(T*, size_t), void (*Destroy)(T*)>
+class WasmVec
+{
+    using TD = std::remove_pointer_t<decltype(T::data)>;
+    T vec_;
+
+public:
+    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;
+    }
+
+    T*
+    get()
+    {
+        return &vec_;
+    }
+
+    [[nodiscard]] T const*
+    get() const
+    {
+        return &vec_;
+    }
+
+    TD&
+    operator[](size_t i)
+    {
+        if (i >= vec_.size)
+            Throw<std::runtime_error>("Out of bound");
+        return vec_.data[i];
+    }
+
+    TD const&
+    operator[](size_t i) const
+    {
+        if (i >= vec_.size)
+            Throw<std::runtime_error>("Out of bound");
+        return vec_.data[i];
+    }
+
+    [[nodiscard]] size_t
+    size() const
+    {
+        return vec_.size;
+    }
+
+    [[nodiscard]] bool
+    empty() const
+    {
+        return vec_.size == 0u;
+    }
+};
+
+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;
+    // Set iff the call trapped. Holds the TER the trap was classified into
+    // (tecINTERNAL / tecOUT_OF_GAS / tecFAILED_PROCESSING); see
+    // WasmiEngine::call. std::nullopt means the call returned normally.
+    std::optional<TER> ter;
+
+    WasmiResult(unsigned n = 0) : r(n)
+    {
+    }
+
+    WasmiResult() = delete;
+    ~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*>;
+
+class InstanceWrapper
+{
+    wasm_store_t* store_ = nullptr;
+    WasmExternVec exports_;
+    mutable int memIdx_ = -1;
+    InstancePtr instance_;
+    beast::Journal j_ = beast::Journal(beast::Journal::getNullSink());
+    std::int64_t transferLimit_ = kWasmTransferLimit;
+
+private:
+    static InstancePtr
+    init(
+        StorePtr& s,
+        ModulePtr& m,
+        WasmExternVec& expt,
+        WasmExternVec const& imports,
+        beast::Journal j);
+
+public:
+    InstanceWrapper() : instance_(nullptr, &wasm_instance_delete) {};
+
+    InstanceWrapper(InstanceWrapper const&) = delete;
+
+    InstanceWrapper(InstanceWrapper&& o) : instance_(nullptr, &wasm_instance_delete)
+    {
+        *this = std::move(o);  // LCOV_EXCL_LINE
+    }
+
+    InstanceWrapper(StorePtr& s, ModulePtr& m, WasmExternVec const& imports, beast::Journal j)
+        : store_(s.get()), instance_(init(s, m, exports_, imports, j)), j_(j)
+    {
+    }
+
+    InstanceWrapper&
+    operator=(InstanceWrapper&& o);
+
+    InstanceWrapper&
+    operator=(InstanceWrapper const&) = delete;
+
+    operator bool() const
+    {
+        return static_cast<bool>(instance_);
+    }
+
+    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;
+
+    std::int64_t
+    getTransferLimit() const;
+
+    std::int64_t
+    setTransferLimit(std::int64_t);
+};
+
+class ModuleWrapper
+{
+    ModulePtr module_;
+    InstanceWrapper instanceWrap_;
+    WasmExporttypeVec exportTypes_;
+    beast::Journal j_ = beast::Journal(beast::Journal::getNullSink());
+
+public:
+    // LCOV_EXCL_START
+    ModuleWrapper() : module_(nullptr, &wasm_module_delete)
+    {
+    }
+
+    ModuleWrapper(ModuleWrapper&& o) : module_(nullptr, &wasm_module_delete)
+    {
+        *this = std::move(o);
+    }
+    // LCOV_EXCL_STOP
+
+    ModuleWrapper&
+    operator=(ModuleWrapper&& o);
+    ModuleWrapper(
+        StorePtr& s,
+        Bytes const& wasmBin,
+        bool instantiate,
+        ImportVec const& imports,
+        beast::Journal j);
+    ~ModuleWrapper() = default;
+
+    operator bool() const
+    {
+        return instanceWrap_;
+    }
+
+    FuncInfo
+    getFunc(std::string_view funcName) const
+    {
+        return instanceWrap_.getFunc(funcName, exportTypes_);
+    }
+
+    wasm_functype_t const*
+    getFuncType(std::string_view funcName) const;
+
+    Wmem
+    getMem() const
+    {
+        return instanceWrap_.getMem();
+    }
+
+    InstanceWrapper&
+    getInstance(int i = 0)
+    {
+        return instanceWrap_;
+    }
+
+    InstanceWrapper const&
+    getInstance(int i = 0) const
+    {
+        return instanceWrap_;
+    }
+
+    int
+    addInstance(StorePtr& s, WasmExternVec const& imports)
+    {
+        instanceWrap_ = {s, module_, imports, j_};
+        return 0;
+    }
+
+    std::int64_t
+    getGas() const
+    {
+        return instanceWrap_ ? instanceWrap_.getGas() : -1;
+    }
+
+private:
+    static ModulePtr
+    init(StorePtr& s, Bytes const& wasmBin, beast::Journal j);
+
+    WasmExternVec
+    buildImports(StorePtr& s, ImportVec const& imports) const;
+};
+
+class WasmiEngine
+{
+    EnginePtr engine_;
+    StorePtr store_;
+    std::unique_ptr<ModuleWrapper> moduleWrap_;
+    beast::Journal j_ = beast::Journal(beast::Journal::getNullSink());
+
+    std::mutex m_;  // 1 instance mutex
+
+public:
+    WasmiEngine() : engine_(init()), store_(nullptr, &wasm_store_delete)
+    {
+    }
+
+    ~WasmiEngine() = default;
+
+    static EnginePtr
+    init();
+
+    std::expected<WasmResult<int32_t>, WasmTER>
+    run(Bytes const& wasmCode,
+        HostFunctions& hfs,
+        int64_t gas,
+        std::string_view funcName,
+        std::vector<WasmParam> const& params,
+        ImportVec const& imports,
+        beast::Journal j);
+
+    NotTEC
+    check(
+        Bytes const& wasmCode,
+        HostFunctions& hfs,
+        std::string_view funcName,
+        std::vector<WasmParam> const& params,
+        ImportVec const& imports,
+        beast::Journal j);
+
+    [[nodiscard]] std::int64_t
+    getGas() const
+    {
+        return moduleWrap_ ? moduleWrap_->getGas() : -1;  // LCOV_EXCL_LINE
+    }
+
+    // Host functions helper functionality
+    wasm_trap_t*
+    newTrap(std::string const& msg);
+
+    // LCOV_EXCL_START
+    [[nodiscard]] beast::Journal
+    getJournal() const
+    {
+        return j_;
+    }
+    // LCOV_EXCL_STOP
+
+private:
+    [[nodiscard]] InstanceWrapper&
+    getRT(int m = 0, int i = 0) const
+    {
+        if (!moduleWrap_)
+            Throw<std::runtime_error>("no module");
+        return moduleWrap_->getInstance(i);
+    }
+
+    [[nodiscard]] Wmem
+    getMem() const
+    {
+        return moduleWrap_ ? moduleWrap_->getMem() : Wmem();
+    }
+
+    std::expected<WasmResult<int32_t>, WasmTER>
+    runHlp(
+        Bytes const& wasmCode,
+        HostFunctions& hfs,
+        int64_t gas,
+        std::string_view funcName,
+        std::vector<WasmParam> const& params,
+        ImportVec const& imports,
+        beast::Journal j);
+
+    NotTEC
+    checkHlp(
+        Bytes const& wasmCode,
+        HostFunctions& hfs,
+        std::string_view funcName,
+        std::vector<WasmParam> const& params,
+        ImportVec const& imports,
+        beast::Journal j);
+
+    int
+    addModule(Bytes const& wasmCode, bool instantiate, ImportVec const& imports, 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 = {});
+
+    [[nodiscard]] FuncInfo
+    getFunc(std::string_view funcName) const
+    {
+        return moduleWrap_->getFunc(funcName);
+    }
+
+    static 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
+    addParam(std::vector<wasm_val_t>& in, int32_t p);
+    static void
+    addParam(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/libxrpl/ledger/ApplyStateTable.cpp

@@ -113,6 +113,8 @@ ApplyStateTable::apply(
     TER ter,
     std::optional<STAmount> const& deliver,
     std::optional<uint256 const> const& parentBatchId,
+    std::optional<std::uint32_t> const& gasUsed,
+    std::optional<std::int32_t> const& vmReturnCode,
     bool isDryRun,
     beast::Journal j)
 {
@@ -127,6 +129,8 @@ ApplyStateTable::apply(
 
         meta.setDeliveredAmount(deliver);
         meta.setParentBatchID(parentBatchId);
+        meta.setGasUsed(gasUsed);
+        meta.setVMReturnCode(vmReturnCode);
 
         Mods newMod;
         for (auto& item : items_)

src/libxrpl/ledger/ApplyViewImpl.cpp

@@ -30,7 +30,7 @@ ApplyViewImpl::apply(
     bool isDryRun,
     beast::Journal j)
 {
-    return items_.apply(to, tx, ter, deliver_, parentBatchId, isDryRun, j);
+    return items_.apply(to, tx, ter, deliver_, parentBatchId, gasUsed_, vmReturnCode_, isDryRun, j);
 }
 
 std::size_t

src/libxrpl/ledger/Ledger.cpp

@@ -198,6 +198,12 @@ Ledger::Ledger(
                 sle->at(sfReserveIncrement) = *f;
             sle->at(sfReferenceFeeUnits) = kFeeUnitsDeprecated;
         }
+        if (std::ranges::find(amendments, featureSmartEscrow) != amendments.end())
+        {
+            sle->at(sfGasLimit) = fees.gasLimit;
+            sle->at(sfBytecodeSizeLimit) = fees.bytecodeSizeLimit;
+            sle->at(sfGasPrice) = fees.gasPrice;
+        }
         rawInsert(sle);
     }
 
@@ -564,6 +570,7 @@ Ledger::setup()
         {
             bool oldFees = false;
             bool newFees = false;
+            bool extensionFees = false;
             {
                 auto const baseFee = sle->at(~sfBaseFee);
                 auto const reserveBase = sle->at(~sfReserveBase);
@@ -580,6 +587,7 @@ Ledger::setup()
                 auto const baseFeeXRP = sle->at(~sfBaseFeeDrops);
                 auto const reserveBaseXRP = sle->at(~sfReserveBaseDrops);
                 auto const reserveIncrementXRP = sle->at(~sfReserveIncrementDrops);
+
                 auto assign = [&ret](XRPAmount& dest, std::optional<STAmount> const& src) {
                     if (src)
                     {
@@ -598,6 +606,22 @@ Ledger::setup()
                 assign(fees_.increment, reserveIncrementXRP);
                 newFees = baseFeeXRP || reserveBaseXRP || reserveIncrementXRP;
             }
+            {
+                auto const gasLimit = sle->at(~sfGasLimit);
+                auto const bytecodeSizeLimit = sle->at(~sfBytecodeSizeLimit);
+                auto const gasPrice = sle->at(~sfGasPrice);
+
+                auto assign = [](std::uint32_t& dest, std::optional<std::uint32_t> const& src) {
+                    if (src)
+                    {
+                        dest = src.value();
+                    }
+                };
+                assign(fees_.gasLimit, gasLimit);
+                assign(fees_.bytecodeSizeLimit, bytecodeSizeLimit);
+                assign(fees_.gasPrice, gasPrice);
+                extensionFees = gasLimit || bytecodeSizeLimit || gasPrice;
+            }
             if (oldFees && newFees)
             {
                 // Should be all of one or the other, but not both
@@ -608,6 +632,12 @@ Ledger::setup()
                 // Can't populate the new fees before the amendment is enabled
                 ret = false;
             }
+            if (!rules_.enabled(featureSmartEscrow) && extensionFees)
+            {
+                // Can't populate the extension fees before the amendment is
+                // enabled
+                ret = false;
+            }
         }
     }
     catch (SHAMapMissingNode const&)

src/libxrpl/protocol/STValidation.cpp

@@ -59,6 +59,10 @@ STValidation::validationFormat()
         {sfBaseFeeDrops,          SoeOptional},
         {sfReserveBaseDrops,      SoeOptional},
         {sfReserveIncrementDrops, SoeOptional},
+        // featureSmartEscrow
+        {sfGasLimit,               SoeOptional},
+        {sfBytecodeSizeLimit,      SoeOptional},
+        {sfGasPrice,               SoeOptional},
     };
     // clang-format on
 

src/libxrpl/protocol/TER.cpp

@@ -108,6 +108,8 @@ transResults()
         MAKE_ERROR(tecPRECISION_LOSS,                "The amounts used by the transaction cannot interact."),
         MAKE_ERROR(tecBAD_PROOF,                     "Proof cannot be verified"),
         MAKE_ERROR(tecNO_SPONSOR_PERMISSION,         "Sponsor has not authorized this transaction."),
+        MAKE_ERROR(tecOUT_OF_GAS,                    "The WASM code ran out of gas during execution."),
+        MAKE_ERROR(tecBYTECODE_REJECTED,             "The custom WASM code that was run rejected your transaction."),
 
         MAKE_ERROR(tefALREADY,                     "The exact transaction was already in this ledger."),
         MAKE_ERROR(tefBAD_ADD_AUTH,                "Not authorized to add account."),
@@ -133,6 +135,8 @@ transResults()
         MAKE_ERROR(tefINVALID_LEDGER_FIX_TYPE,     "The LedgerFixType field has an invalid value."),
         MAKE_ERROR(tefNO_DST_PARTIAL,              "Partial payment to create account not allowed."),
         MAKE_ERROR(tefBAD_PATH_COUNT,              "Malformed: Too many paths."),
+        MAKE_ERROR(tefNO_BYTECODE,                 "There is no WASM code to run, but a WASM-specific field was included."),
+        MAKE_ERROR(tefBYTECODE_NOT_INCLUDED,       "WASM code requires a field to be included that was not included."),
 
         MAKE_ERROR(telLOCAL_ERROR,            "Local failure."),
         MAKE_ERROR(telBAD_DOMAIN,             "Domain too long."),
@@ -204,6 +208,9 @@ transResults()
         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_CIPHERTEXT,            "Malformed: Invalid ciphertext."),
+        MAKE_ERROR(temBAD_WASM,                  "Malformed: Provided WASM code is invalid."),
+        MAKE_ERROR(temINVALID_BYTECODE,          "Malformed: Provided WASM code is invalid."),
+        MAKE_ERROR(temTEMP_DISABLED,             "The transaction requires logic that is currently temporarily disabled."),
 
         MAKE_ERROR(terRETRY,                  "Retry transaction."),
         MAKE_ERROR(terFUNDS_SPENT,            "DEPRECATED."),

src/libxrpl/protocol/TxMeta.cpp

@@ -194,6 +194,12 @@ TxMeta::getAsObject() const
     if (parentBatchID_.has_value())
         metaData.setFieldH256(sfParentBatchID, *parentBatchID_);
 
+    if (gasUsed_.has_value())
+        metaData.setFieldU32(sfGasUsed, *gasUsed_);
+
+    if (vmReturnCode_.has_value())
+        metaData.setFieldI32(sfVMReturnCode, *vmReturnCode_);
+
     return metaData;
 }
 

src/libxrpl/tx/ApplyContext.cpp

@@ -58,6 +58,18 @@ ApplyContext::discard()
 std::optional<TxMeta>
 ApplyContext::apply(TER ter)
 {
+    // tecINTERNAL reports an xrpld bug, not a result: nothing the VM recorded
+    // before we hit it belongs in the metadata.
+    if (ter != tecINTERNAL)
+    {
+        if (vmReturnCode_.has_value())
+        {
+            // NOLINTNEXTLINE(bugprone-unchecked-optional-access) view_ emplaced in constructor
+            view_->setVMReturnCode(*vmReturnCode_);
+        }
+        // NOLINTNEXTLINE(bugprone-unchecked-optional-access) view_ emplaced in constructor
+        view_->setGasUsed(gasUsed_);
+    }
     // NOLINTNEXTLINE(bugprone-unchecked-optional-access) view_ emplaced in constructor
     return view_->apply(base_, tx, ter, parentBatchId_, (flags_ & TapDryRun) != 0u, journal);
 }

src/libxrpl/tx/Transactor.cpp

@@ -1284,6 +1284,23 @@ removeDeletedTrustLines(
     }
 }
 
+static void
+modifyWasmDataFields(
+    ApplyView& view,
+    std::vector<std::pair<uint256, SLE::const_pointer>> const& wasmObjects,
+    beast::Journal viewJ)
+{
+    for (auto const& [index, after] : wasmObjects)
+    {
+        if (auto const sle = view.peek(keylet::escrow(index)))
+        {
+            auto const data = after->getFieldVL(sfData);
+            sle->setFieldVL(sfData, data);
+            view.update(sle);
+        }
+    }
+}
+
 /**
  * Reset the context, discarding any changes made and adjust the fee.
  *
@@ -1451,6 +1468,10 @@ Transactor::processPersistentChanges(TER result, XRPAmount fee)
             types.insert(ltNFTOKEN_OFFER);
             types.insert(ltCREDENTIAL);
         }
+        else if (ter == tecBYTECODE_REJECTED)
+        {
+            types.insert(ltESCROW);
+        }
         return types;
     };
 
@@ -1460,10 +1481,11 @@ Transactor::processPersistentChanges(TER result, XRPAmount fee)
     auto const typesToCollect = typesForResult(result);
 
     std::map<LedgerEntryType, std::vector<uint256>> deletedObjects;
+    std::map<LedgerEntryType, std::vector<std::pair<uint256, SLE::const_pointer>>> modifiedObjects;
     if (!typesToCollect.empty())
     {
         ctx_.visit(
-            [&typesToCollect, &deletedObjects](
+            [&typesToCollect, &deletedObjects, &modifiedObjects](
                 uint256 const& index, bool isDelete, SLE::const_ref before, SLE::const_ref after) {
                 if (isDelete)
                 {
@@ -1487,6 +1509,16 @@ Transactor::processPersistentChanges(TER result, XRPAmount fee)
                         }
                     }
                 }
+                else if (after)
+                {
+                    // Collect modified escrows so that data written by a
+                    // rejected WASM execution can be re-applied after the
+                    // context is reset.
+                    auto const type = after->getType();
+                    if (typesToCollect.contains(type) && type == ltESCROW &&
+                        after->isFieldPresent(sfData))
+                        modifiedObjects[type].emplace_back(index, after);
+                }
             });
     }
 
@@ -1533,6 +1565,24 @@ Transactor::processPersistentChanges(TER result, XRPAmount fee)
                     // LCOV_EXCL_STOP
             }
         }
+        for (auto const& [type, ids] : modifiedObjects)
+        {
+            if (ids.empty() || !typesToApply.contains(type))
+                continue;
+            switch (type)
+            {
+                case ltESCROW:
+                    modifyWasmDataFields(view(), ids, viewJ);
+                    break;
+                // LCOV_EXCL_START
+                default:
+                    UNREACHABLE(
+                        "xrpl::Transactor::processPersistentChanges() : "
+                        "unexpected type");
+                    break;
+                    // LCOV_EXCL_STOP
+            }
+        }
     }
 
     return {result, fee, isTecClaim(result)};
@@ -1652,7 +1702,8 @@ Transactor::operator()()
     }
     else if (
         (result == tecOVERSIZE) || (result == tecKILLED) || (result == tecINCOMPLETE) ||
-        (result == tecEXPIRED) || (isTecClaimHardFail(result, view().flags())))
+        (result == tecEXPIRED) || (result == tecBYTECODE_REJECTED) ||
+        (isTecClaimHardFail(result, view().flags())))
     {
         std::tie(result, fee, applied) = processPersistentChanges(result, fee);
     }

src/libxrpl/tx/transactors/escrow/EscrowCancel.cpp

@@ -212,7 +212,8 @@ EscrowCancel::doApply()
         }
     }
 
-    decreaseOwnerCountForObject(ctx_.view(), sle, slep, 1, ctx_.journal);
+    auto const reserveToSubtract = calculateAdditionalReserve((*slep)[~sfBytecode]);
+    decreaseOwnerCountForObject(ctx_.view(), sle, slep, reserveToSubtract, ctx_.journal);
 
     // Remove escrow from ledger
     ctx_.view().erase(slep);

src/libxrpl/tx/transactors/escrow/EscrowCreate.cpp

@@ -6,9 +6,11 @@
 #include <xrpl/conditions/Condition.h>
 #include <xrpl/core/ServiceRegistry.h>
 #include <xrpl/ledger/ApplyView.h>
+#include <xrpl/ledger/ReadView.h>
 #include <xrpl/ledger/View.h>
 #include <xrpl/ledger/helpers/AccountRootHelpers.h>
 #include <xrpl/ledger/helpers/DirectoryHelpers.h>
+#include <xrpl/ledger/helpers/EscrowHelpers.h>
 #include <xrpl/ledger/helpers/MPTokenHelpers.h>
 #include <xrpl/ledger/helpers/RippleStateHelpers.h>
 #include <xrpl/ledger/helpers/SponsorHelpers.h>
@@ -32,6 +34,8 @@
 #include <xrpl/protocol/XRPAmount.h>
 #include <xrpl/tx/Transactor.h>
 #include <xrpl/tx/applySteps.h>
+#include <xrpl/tx/wasm/HostFunc.h>
+#include <xrpl/tx/wasm/WasmVM.h>
 
 #include <memory>
 #include <system_error>
@@ -88,8 +92,13 @@ EscrowCreate::checkExtraFeatures(PreflightContext const& ctx)
     // Only require featureMPTokensV1 when the escrow amount is an MPT and
     // fixCleanup3_2_0 is active; XRP/IOU escrows are unaffected by this gate.
     if (ctx.rules.enabled(fixCleanup3_2_0) && ctx.tx[sfAmount].holds<MPTIssue>())
-        return ctx.rules.enabled(featureMPTokensV1);
-    return true;
+    {
+        if (!ctx.rules.enabled(featureMPTokensV1))
+            return false;
+    }
+
+    return (!ctx.tx.isFieldPresent(sfBytecode) && !ctx.tx.isFieldPresent(sfData)) ||
+        ctx.rules.enabled(featureSmartEscrow);
 }
 
 template <ValidIssueType T>
@@ -124,6 +133,19 @@ escrowCreatePreflightHelper<MPTIssue>(PreflightContext const& ctx)
     return tesSUCCESS;
 }
 
+XRPAmount
+EscrowCreate::calculateBaseFee(ReadView const& view, STTx const& tx)
+{
+    XRPAmount txnFees{Transactor::calculateBaseFee(view, tx)};
+    if (tx.isFieldPresent(sfBytecode))
+    {
+        // 10 base fees for the transaction (1 is in
+        // `Transactor::calculateBaseFee`), plus 5 drops per byte
+        txnFees += 9 * view.fees().base + 5 * tx[sfBytecode].size();
+    }
+    return txnFees;
+}
+
 NotTEC
 EscrowCreate::preflight(PreflightContext const& ctx)
 {
@@ -155,12 +177,19 @@ EscrowCreate::preflight(PreflightContext const& ctx)
         ctx.tx[sfCancelAfter] <= ctx.tx[sfFinishAfter])
         return temBAD_EXPIRATION;
 
+    if (ctx.tx.isFieldPresent(sfBytecode) && !ctx.tx.isFieldPresent(sfCancelAfter))
+        return temBAD_EXPIRATION;
+
     // In the absence of a FinishAfter, the escrow can be finished
     // immediately, which can be confusing. When creating an escrow,
     // we want to ensure that either a FinishAfter time is explicitly
     // specified or a completion condition is attached.
-    if (!ctx.tx[~sfFinishAfter] && !ctx.tx[~sfCondition])
+    if (!ctx.tx[~sfFinishAfter] && !ctx.tx[~sfCondition] && !ctx.tx[~sfBytecode])
+    {
+        JLOG(ctx.j.debug()) << "Must have at least one of FinishAfter, "
+                               "Condition, or Bytecode.";
         return temMALFORMED;
+    }
 
     if (auto const cb = ctx.tx[~sfCondition])
     {
@@ -176,6 +205,60 @@ EscrowCreate::preflight(PreflightContext const& ctx)
         }
     }
 
+    if (ctx.tx.isFieldPresent(sfData))
+    {
+        if (!ctx.tx.isFieldPresent(sfBytecode))
+        {
+            JLOG(ctx.j.debug()) << "EscrowCreate with Data requires Bytecode";
+            return temMALFORMED;
+        }
+        auto const data = ctx.tx.getFieldVL(sfData);
+        if (data.size() > kMaxWasmDataLength)
+        {
+            JLOG(ctx.j.debug()) << "EscrowCreate.Data bad size " << data.size();
+            return temMALFORMED;
+        }
+    }
+
+    if (ctx.tx.isFieldPresent(sfBytecode))
+    {
+        auto const fees(ctx.registry.get().getFees());
+        if (fees.bytecodeSizeLimit == 0 || fees.gasLimit == 0)
+        {
+            JLOG(ctx.j.debug()) << "WASM runtime deactivated by fee voting";
+            return temTEMP_DISABLED;
+        }
+
+        auto const code = ctx.tx.getFieldVL(sfBytecode);
+        if (code.empty() || code.size() > fees.bytecodeSizeLimit)
+        {
+            JLOG(ctx.j.debug()) << "EscrowCreate.Bytecode bad size " << code.size();
+            return temMALFORMED;
+        }
+        // actual validity of WASM code happens in `preflightSigValidated`
+        // (after the signature is checked)
+    }
+
+    return tesSUCCESS;
+}
+
+NotTEC
+EscrowCreate::preflightSigValidated(PreflightContext const& ctx)
+{
+    if (ctx.tx.isFieldPresent(sfBytecode))
+    {
+        auto const code = ctx.tx.getFieldVL(sfBytecode);
+        // basic checks happen in `preflight`
+
+        HostFunctions mock(ctx.j);
+        auto const re = preflightEscrowWasm(code, mock, escrowFunctionName);
+        if (!isTesSuccess(re))
+        {
+            JLOG(ctx.j.debug()) << "EscrowCreate.Bytecode bad WASM";
+            return re;
+        }
+    }
+
     return tesSUCCESS;
 }
 
@@ -434,6 +517,7 @@ EscrowCreate::doApply()
 
     // Check reserve and funds availability
     STAmount const amount{ctx_.tx[sfAmount]};
+    auto const reserveToAdd = calculateAdditionalReserve(ctx_.tx[~sfBytecode]);
 
     auto const balance = sle->getFieldAmount(sfBalance).xrp();
     // First check: whoever is on the hook for the new owner increment
@@ -441,8 +525,8 @@ EscrowCreate::doApply()
     // validates the sponsor's reserve + remaining credit. When
     // unsponsored this hits the source branch and validates the
     // source's pre-lock balance against base + (currentOC+1)*increment.
-    if (auto const ret =
-            checkReserve(ctx_.getApplyViewContext(), sle, balance, {.ownerCountDelta = 1}, j_);
+    if (auto const ret = checkReserve(
+            ctx_.getApplyViewContext(), sle, balance, {.ownerCountDelta = reserveToAdd}, j_);
         !isTesSuccess(ret))
         return ret;
 
@@ -486,6 +570,8 @@ EscrowCreate::doApply()
     (*slep)[~sfCancelAfter] = ctx_.tx[~sfCancelAfter];
     (*slep)[~sfFinishAfter] = ctx_.tx[~sfFinishAfter];
     (*slep)[~sfDestinationTag] = ctx_.tx[~sfDestinationTag];
+    (*slep)[~sfBytecode] = ctx_.tx[~sfBytecode];
+    (*slep)[~sfData] = ctx_.tx[~sfData];
 
     if (ctx_.view().rules().enabled(fixIncludeKeyletFields))
     {
@@ -553,7 +639,7 @@ EscrowCreate::doApply()
     }
 
     // increment owner count
-    increaseOwnerCount(ctx_.getApplyViewContext(), sle, 1, ctx_.journal);
+    increaseOwnerCount(ctx_.getApplyViewContext(), sle, reserveToAdd, ctx_.journal);
     addSponsorToLedgerEntry(ctx_.getApplyViewContext(), slep);
     ctx_.view().update(sle);
     return tesSUCCESS;

src/libxrpl/tx/transactors/escrow/EscrowFinish.cpp

@@ -18,9 +18,11 @@
 #include <xrpl/protocol/AccountID.h>
 #include <xrpl/protocol/Concepts.h>
 #include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/Fees.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/Issue.h>
 #include <xrpl/protocol/MPTIssue.h>
+#include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/Rate.h>
 #include <xrpl/protocol/SField.h>
 #include <xrpl/protocol/STAmount.h>
@@ -30,9 +32,16 @@
 #include <xrpl/protocol/TER.h>
 #include <xrpl/protocol/XRPAmount.h>
 #include <xrpl/tx/Transactor.h>
+#include <xrpl/tx/wasm/HostFuncImpl.h>
+#include <xrpl/tx/wasm/WasmVM.h>
 
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
 #include <system_error>
 #include <variant>
+#include <vector>
 
 namespace xrpl {
 
@@ -65,7 +74,13 @@ checkCondition(Slice f, Slice c)
 bool
 EscrowFinish::checkExtraFeatures(PreflightContext const& ctx)
 {
-    return !ctx.tx.isFieldPresent(sfCredentialIDs) || ctx.rules.enabled(featureCredentials);
+    if (ctx.tx.isFieldPresent(sfCredentialIDs) && !ctx.rules.enabled(featureCredentials))
+        return false;
+
+    if (ctx.tx.isFieldPresent(sfGas) && !ctx.rules.enabled(featureSmartEscrow))
+        return false;
+
+    return true;
 }
 
 NotTEC
@@ -77,7 +92,32 @@ EscrowFinish::preflight(PreflightContext const& ctx)
     // If you specify a condition, then you must also specify
     // a fulfillment.
     if (static_cast<bool>(cb) != static_cast<bool>(fb))
+    {
+        JLOG(ctx.j.debug()) << "Condition != Fulfillment";
         return temMALFORMED;
+    }
+
+    if (auto const allowance = ctx.tx[~sfGas]; allowance)
+    {
+        auto const fees(ctx.registry.get().getFees());
+        if (fees.gasLimit == 0)
+        {
+            JLOG(ctx.j.debug()) << "WASM runtime deactivated by fee voting";
+            return temTEMP_DISABLED;
+        }
+        if (*allowance == 0)
+        {
+            return temBAD_LIMIT;
+        }
+        if (*allowance > fees.gasLimit)
+        {
+            JLOG(ctx.j.debug()) << "Gas too large: " << *allowance;
+            return temBAD_LIMIT;
+        }
+    }
+
+    if (auto const err = credentials::checkFields(ctx.tx, ctx.j); !isTesSuccess(err))
+        return err;
 
     return tesSUCCESS;
 }
@@ -111,9 +151,6 @@ EscrowFinish::preflightSigValidated(PreflightContext const& ctx)
         }
     }
 
-    if (auto const err = credentials::checkFields(ctx.tx, ctx.j); !isTesSuccess(err))
-        return err;
-
     return tesSUCCESS;
 }
 
@@ -126,7 +163,15 @@ EscrowFinish::calculateBaseFee(ReadView const& view, STTx const& tx)
     {
         extraFee += view.fees().base * (32 + (fb->size() / 16));
     }
-
+    if (std::optional<uint64_t> const allowance = tx[~sfGas]; allowance)
+    {
+        // The extra fee is the allowance in drops, rounded up to the nearest
+        // whole drop.
+        // Integer math rounds down by default, so we add 1 to round up.
+        uint64_t const allowanceFee =
+            (((*allowance) * view.fees().gasPrice) / microDropsPerDrop) + 1;
+        extraFee += allowanceFee;
+    }
     return Transactor::calculateBaseFee(view, tx) + extraFee;
 }
 
@@ -202,26 +247,51 @@ EscrowFinish::preclaim(PreclaimContext const& ctx)
             return err;
     }
 
-    if (ctx.view.rules().enabled(featureTokenEscrow))
+    if (ctx.view.rules().enabled(featureTokenEscrow) ||
+        ctx.view.rules().enabled(featureSmartEscrow))
     {
+        // this check is done in doApply before this amendment is enabled
         auto const seqProxy = SeqProxy::rawSequence(ctx.tx[sfOfferSequence]);
         auto const k = keylet::escrow(ctx.tx[sfOwner], seqProxy);
         auto const slep = ctx.view.read(k);
         if (!slep)
             return tecNO_TARGET;
 
-        AccountID const dest = (*slep)[sfDestination];
-        STAmount const amount = (*slep)[sfAmount];
-
-        if (!isXRP(amount))
+        if (ctx.view.rules().enabled(featureSmartEscrow))
         {
-            if (auto const ret = std::visit(
-                    [&]<typename T>(T const&) {
-                        return escrowFinishPreclaimHelper<T>(ctx, dest, amount);
-                    },
-                    amount.asset().value());
-                !isTesSuccess(ret))
-                return ret;
+            if (slep->isFieldPresent(sfBytecode))
+            {
+                if (!ctx.tx.isFieldPresent(sfGas))
+                {
+                    JLOG(ctx.j.debug()) << "Bytecode requires Gas";
+                    return tefBYTECODE_NOT_INCLUDED;
+                }
+            }
+            else
+            {
+                if (ctx.tx.isFieldPresent(sfGas))
+                {
+                    JLOG(ctx.j.debug()) << "Bytecode not present, "
+                                           "Gas present";
+                    return tefNO_BYTECODE;
+                }
+            }
+        }
+        if (ctx.view.rules().enabled(featureTokenEscrow))
+        {
+            AccountID const dest = (*slep)[sfDestination];
+            STAmount const amount = (*slep)[sfAmount];
+
+            if (!isXRP(amount))
+            {
+                if (auto const ret = std::visit(
+                        [&]<typename T>(T const&) {
+                            return escrowFinishPreclaimHelper<T>(ctx, dest, amount);
+                        },
+                        amount.asset().value());
+                    !isTesSuccess(ret))
+                    return ret;
+            }
         }
     }
     return tesSUCCESS;
@@ -235,7 +305,8 @@ EscrowFinish::doApply()
     auto const slep = ctx_.view().peek(k);
     if (!slep)
     {
-        if (ctx_.view().rules().enabled(featureTokenEscrow))
+        if (ctx_.view().rules().enabled(featureTokenEscrow) ||
+            ctx_.view().rules().enabled(featureSmartEscrow))
             return tecINTERNAL;  // LCOV_EXCL_LINE
 
         return tecNO_TARGET;
@@ -253,6 +324,20 @@ EscrowFinish::doApply()
     if ((*slep)[~sfCancelAfter] && after(now, (*slep)[sfCancelAfter]))
         return tecNO_PERMISSION;
 
+    AccountID const destID = (*slep)[sfDestination];
+    auto const sled = ctx_.view().peek(keylet::account(destID));
+    if (ctx_.view().rules().enabled(featureSmartEscrow))
+    {
+        // NOTE: Escrow payments cannot be used to fund accounts.
+        if (!sled)
+            return tecNO_DST;
+
+        if (auto err =
+                verifyDepositPreauth(ctx_.tx, ctx_.view(), accountID_, destID, sled, ctx_.journal);
+            !isTesSuccess(err))
+            return err;
+    }
+
     // Check cryptocondition fulfillment
     {
         auto const id = ctx_.tx.getTransactionID();
@@ -306,16 +391,78 @@ EscrowFinish::doApply()
             return tecCRYPTOCONDITION_ERROR;
     }
 
-    // NOTE: Escrow payments cannot be used to fund accounts.
-    AccountID const destID = (*slep)[sfDestination];
-    auto const sled = ctx_.view().peek(keylet::account(destID));
-    if (!sled)
-        return tecNO_DST;
+    if (!ctx_.view().rules().enabled(featureSmartEscrow))
+    {
+        // NOTE: Escrow payments cannot be used to fund accounts.
+        if (!sled)
+            return tecNO_DST;
 
-    if (auto err =
-            verifyDepositPreauth(ctx_.tx, ctx_.view(), accountID_, destID, sled, ctx_.journal);
-        !isTesSuccess(err))
-        return err;
+        if (auto err =
+                verifyDepositPreauth(ctx_.tx, ctx_.view(), accountID_, destID, sled, ctx_.journal);
+            !isTesSuccess(err))
+            return err;
+    }
+
+    // Execute custom release function
+    if ((*slep)[~sfBytecode])
+    {
+        JLOG(j_.trace()) << "The escrow has a finish function, running WASM code...";
+        // WASM execution
+        auto const wasmStr = slep->getFieldVL(sfBytecode);
+        std::vector<uint8_t> const wasm(wasmStr.begin(), wasmStr.end());
+
+        WasmHostFunctionsImpl ledgerDataProvider(ctx_, k);
+
+        if (!ctx_.tx.isFieldPresent(sfGas))
+        {
+            // already checked above, this check is just in case
+            return tecINTERNAL;
+        }
+        std::uint32_t const allowance = ctx_.tx[sfGas];
+        auto const re = runEscrowWasm(wasm, ledgerDataProvider, allowance, escrowFunctionName);
+        JLOG(j_.trace()) << "Escrow WASM ran";
+
+        // Gas consumed, reported in the tx metadata whenever the engine has a
+        // trustworthy number: a completed run, out of gas, or a wasm fault.
+        std::optional<std::int64_t> const cost = re.has_value() ? re->cost : re.error().cost;
+        if (cost.has_value())
+        {
+            // The engine cannot spend more than it was given, and pins the cost
+            // to the allowance when it runs out.
+            if (*cost < 0 || *cost > allowance)
+                return tecINTERNAL;  // LCOV_EXCL_LINE
+            ctx_.setGasUsed(static_cast<std::uint32_t>(*cost));
+        }
+
+        if (!re.has_value())
+        {
+            // No return code, and any data it wrote goes away with the view.
+            JLOG(j_.debug()) << "WASM Failure: " + transHuman(re.error().ter);
+            return re.error().ter;
+        }
+
+        auto const reValue = re->result;
+        JLOG(j_.debug()) << "WASM Success: " + std::to_string(reValue) << ", cost: " << re->cost;
+
+        ctx_.setVMReturnCode(reValue);
+
+        // Only matters on a reject, where the escrow survives:
+        // Transactor::processPersistentChanges replays this after the reset.
+        if (auto const& data = ledgerDataProvider.getData(); data.has_value())
+        {
+            if (data->size() > kMaxWasmDataLength)
+            {
+                // should already be checked in the updateData host function
+                return tecINTERNAL;  // LCOV_EXCL_LINE
+            }
+            slep->setFieldVL(sfData, makeSlice(*data));
+            ctx_.view().update(slep);
+        }
+
+        // 0 or negative is a contract-defined reject code, reported as sfVMReturnCode.
+        if (reValue <= 0)
+            return tecBYTECODE_REJECTED;
+    }
 
     AccountID const account = (*slep)[sfAccount];
 
@@ -343,6 +490,8 @@ EscrowFinish::doApply()
         }
     }
 
+    auto const reserveToSubtract = calculateAdditionalReserve((*slep)[~sfBytecode]);
+
     // With the Sponsor amendment, release the escrow reserve before delivery.
     // Token delivery can auto-create a destination holding, and the same
     // sponsor (or the same account, for a self-escrow) may cover both the
@@ -351,7 +500,7 @@ EscrowFinish::doApply()
     // arithmetic for self-escrows and would break consensus if not gated.
     bool const sponsorEnabled = ctx_.view().rules().enabled(featureSponsor);
     if (sponsorEnabled)
-        decreaseOwnerCountForObject(ctx_.view(), account, slep, 1, ctx_.journal);
+        decreaseOwnerCountForObject(ctx_.view(), account, slep, reserveToSubtract, ctx_.journal);
 
     STAmount const amount = slep->getFieldAmount(sfAmount);
     // Transfer amount to destination
@@ -404,7 +553,7 @@ EscrowFinish::doApply()
 
     // Adjust source owner count (legacy position, pre-Sponsor)
     if (!sponsorEnabled)
-        decreaseOwnerCountForObject(ctx_.view(), account, slep, 1, ctx_.journal);
+        decreaseOwnerCountForObject(ctx_.view(), account, slep, reserveToSubtract, ctx_.journal);
 
     // Remove escrow from ledger
     ctx_.view().erase(slep);

src/libxrpl/tx/transactors/system/Change.cpp

@@ -9,6 +9,7 @@
 #include <xrpl/core/ServiceRegistry.h>
 #include <xrpl/ledger/AmendmentTable.h>
 #include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/Fees.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/Protocol.h>
 #include <xrpl/protocol/PublicKey.h>
@@ -123,6 +124,22 @@ Change::preclaim(PreclaimContext const& ctx)
                     ctx.tx.isFieldPresent(sfReserveIncrementDrops))
                     return temDISABLED;
             }
+            if (ctx.view.rules().enabled(featureSmartEscrow))
+            {
+                if (!ctx.tx.isFieldPresent(sfGasLimit) ||
+                    !ctx.tx.isFieldPresent(sfBytecodeSizeLimit) ||
+                    !ctx.tx.isFieldPresent(sfGasPrice))
+                    return temMALFORMED;
+                if (ctx.tx[sfGasLimit] > kMaxGasLimit ||
+                    ctx.tx[sfBytecodeSizeLimit] > kMaxBytecodeSizeLimit)
+                    return temBAD_FEE;
+            }
+            else
+            {
+                if (ctx.tx.isFieldPresent(sfGasLimit) ||
+                    ctx.tx.isFieldPresent(sfBytecodeSizeLimit) || ctx.tx.isFieldPresent(sfGasPrice))
+                    return temDISABLED;
+            }
             return tesSUCCESS;
         case ttAMENDMENT:
         case ttUNL_MODIFY:
@@ -284,6 +301,12 @@ Change::applyFee()
         set(feeObject, ctx_.tx, sfReserveBase);
         set(feeObject, ctx_.tx, sfReserveIncrement);
     }
+    if (view().rules().enabled(featureSmartEscrow))
+    {
+        set(feeObject, ctx_.tx, sfGasLimit);
+        set(feeObject, ctx_.tx, sfBytecodeSizeLimit);
+        set(feeObject, ctx_.tx, sfGasPrice);
+    }
 
     view().update(feeObject);
 

src/libxrpl/tx/wasm/HostFuncImpl.cpp

@@ -0,0 +1,59 @@
+#include <xrpl/tx/wasm/HostFuncImpl.h>
+
+#include <xrpl/basics/Slice.h>
+#include <xrpl/protocol/Protocol.h>
+#include <xrpl/protocol/PublicKey.h>
+#include <xrpl/protocol/digest.h>
+#include <xrpl/tx/wasm/WasmCommon.h>
+
+#include <cstdint>
+#include <expected>
+#include <string_view>
+
+namespace xrpl {
+
+// =========================================================
+// SECTION: WRITE FUNCTION
+// =========================================================
+
+std::expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::updateData(Slice const& data)
+{
+    if (data.size() > kMaxWasmDataLength)
+        return std::unexpected(HostFunctionError::DataFieldTooLarge);
+
+    data_ = Bytes(data.begin(), data.end());
+    return data_->size();
+}
+
+// =========================================================
+// SECTION: UTILS
+// =========================================================
+
+std::expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::checkSignature(
+    Slice const& message,
+    Slice const& signature,
+    Slice const& pubkey) const
+{
+    if (!publicKeyType(pubkey))
+        return std::unexpected(HostFunctionError::InvalidParams);
+
+    PublicKey const pk(pubkey);
+    return verify(pk, message, signature);
+}
+
+std::expected<Hash, HostFunctionError>
+WasmHostFunctionsImpl::computeSha512HalfHash(Slice const& data) const
+{
+    auto const hash = sha512Half(data);
+    return hash;
+}
+
+void
+WasmHostFunctionsImpl::trace(std::string_view const& msg, std::string_view const& data) const
+{
+    log(msg, [&data] { return data; });
+}
+
+}  // namespace xrpl

src/libxrpl/tx/wasm/HostFuncImplFloat.cpp

@@ -0,0 +1,530 @@
+#include <xrpl/basics/Number.h>
+#include <xrpl/basics/Slice.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STNumber.h>
+#include <xrpl/protocol/Serializer.h>
+#include <xrpl/tx/wasm/HostFunc.h>
+#include <xrpl/tx/wasm/HostFuncImpl.h>
+#include <xrpl/tx/wasm/WasmCommon.h>
+
+#include <boost/algorithm/hex.hpp>
+
+#include <cstdint>
+#include <expected>
+#include <iterator>
+#include <optional>
+#include <string>
+#include <utility>
+
+#ifdef _DEBUG
+// #define DEBUG_OUTPUT 1
+#endif
+
+namespace xrpl {
+
+namespace wasm_float {
+
+namespace detail {
+
+// Decode a serialized STNumber float payload. Returns nullopt if the data is
+// not a well-formed encoding.
+std::optional<Number>
+floatDecode(Slice const& data)
+{
+    static unsigned constexpr encodedFloatSize = 12;
+    if (data.size() != encodedFloatSize)
+        return std::nullopt;
+    try
+    {
+        SerialIter it(data);
+        return STNumber(it, sfNumber).value();
+    }
+    catch (...)
+    {
+        return std::nullopt;
+    }
+}
+
+// Build a Number from a raw mantissa/exponent pair. Returns nullopt if the
+// value cannot be represented, e.g. the exponent is out of range.
+std::optional<Number>
+numberFromMantExp(int64_t mantissa, int32_t exponent)
+{
+    try
+    {
+        return Number(mantissa, exponent);
+    }
+    catch (...)
+    {
+        return std::nullopt;
+    }
+}
+
+// Serialize a Number to the STNumber float encoding.
+std::expected<Bytes, HostFunctionError>
+floatEncode(Number const& n)
+{
+    Serializer msg;
+    STNumber(sfNumber, n).add(msg);
+    auto data = msg.getData();
+
+#ifdef DEBUG_OUTPUT
+    std::cout << "m: " << std::setw(20) << n.mantissa() << ", e: " << std::setw(12) << n.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 std::expected<Bytes, HostFunctionError>(std::move(data));
+}
+
+struct FloatState
+{
+    // Set only when the requested mode is valid; sets the rounding mode on
+    // construction and restores the previous mode on destruction.
+    std::optional<NumberRoundModeGuard> guard;
+
+    explicit FloatState(int32_t mode)
+    {
+        if (auto const rm = Number::checkedRoundingMode(mode))
+            guard.emplace(*rm);
+    }
+
+    explicit
+    operator bool() const
+    {
+        return guard.has_value();
+    }
+};
+
+}  // namespace detail
+
+std::string
+floatToString(Slice const& data)
+{
+    // set default mode as we don't expect it will be used here
+    detail::FloatState const rm(static_cast<int32_t>(Number::RoundingMode::ToNearest));
+    auto const num = detail::floatDecode(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;
+    }
+    return to_string(*num);
+}
+
+std::expected<Bytes, HostFunctionError>
+floatFromIntImpl(int64_t x, int32_t mode)
+{
+    try
+    {
+        detail::FloatState const rm(mode);
+        if (!rm)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+
+        return detail::floatEncode(Number(x));
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+        return std::unexpected(HostFunctionError::FloatComputationError);
+    }
+    // LCOV_EXCL_STOP
+}
+
+std::expected<Bytes, HostFunctionError>
+floatFromUintImpl(uint64_t x, int32_t mode)
+{
+    try
+    {
+        detail::FloatState const rm(mode);
+        if (!rm)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+
+        return detail::floatEncode(Number(x, 0, Number::Normalized{}));
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+        return std::unexpected(HostFunctionError::FloatComputationError);
+    }
+    // LCOV_EXCL_STOP
+}
+
+std::expected<Bytes, HostFunctionError>
+floatFromSTAmountImpl(STAmount const& x, int32_t mode)
+{
+    try
+    {
+        detail::FloatState const rm(mode);
+        if (!rm)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+
+        return detail::floatEncode(static_cast<Number>(x));
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+        return std::unexpected(HostFunctionError::FloatComputationError);
+    }
+    // LCOV_EXCL_STOP
+}
+
+std::expected<Bytes, HostFunctionError>
+floatFromSTNumberImpl(STNumber const& x, int32_t mode)
+{
+    try
+    {
+        detail::FloatState const rm(mode);
+        if (!rm)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+
+        return detail::floatEncode(x.value());
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+        return std::unexpected(HostFunctionError::FloatComputationError);
+    }
+    // LCOV_EXCL_STOP
+}
+
+std::expected<int64_t, HostFunctionError>
+floatToIntImpl(Slice const& x, int32_t mode)
+{
+    try
+    {
+        detail::FloatState const rm(mode);
+        if (!rm)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+
+        auto const num = detail::floatDecode(x);
+        if (!num)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);  // LCOV_EXCL_LINE
+        return static_cast<int64_t>(*num);
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+        return std::unexpected(HostFunctionError::FloatComputationError);
+    }
+    // LCOV_EXCL_STOP
+}
+
+std::expected<FloatPair, HostFunctionError>
+floatToMantExpImpl(Slice const& x)
+{
+    try
+    {
+        detail::FloatState const rm(static_cast<int32_t>(Number::RoundingMode::ToNearest));
+        if (!rm)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+
+        auto const num = detail::floatDecode(x);
+        if (!num)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);  // LCOV_EXCL_LINE
+
+        return FloatPair(num->mantissa(), num->exponent());
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+        return std::unexpected(HostFunctionError::FloatComputationError);
+    }
+    // LCOV_EXCL_STOP
+}
+
+std::expected<Bytes, HostFunctionError>
+floatFromMantExpImpl(int64_t mantissa, int32_t exponent, int32_t mode)
+{
+    try
+    {
+        detail::FloatState const rm(mode);
+        if (!rm)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+        auto const num = detail::numberFromMantExp(mantissa, exponent);
+        if (!num)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+        return detail::floatEncode(*num);
+    }
+    catch (...)
+    {
+        return std::unexpected(HostFunctionError::FloatComputationError);
+    }
+}
+
+std::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 const rm(static_cast<int32_t>(Number::RoundingMode::ToNearest));
+
+        auto const xx = detail::floatDecode(x);
+        if (!xx)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+        auto const yy = detail::floatDecode(y);
+        if (!yy)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+        if (*xx < *yy)
+            return 2;
+        if (*xx == *yy)
+            return 0;
+        return 1;
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+        return std::unexpected(HostFunctionError::FloatComputationError);
+    }
+    // LCOV_EXCL_STOP
+}
+
+std::expected<Bytes, HostFunctionError>
+floatAddImpl(Slice const& x, Slice const& y, int32_t mode)
+{
+    try
+    {
+        detail::FloatState const rm(mode);
+        if (!rm)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+
+        auto const xx = detail::floatDecode(x);
+        if (!xx)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+        auto const yy = detail::floatDecode(y);
+        if (!yy)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+
+        return detail::floatEncode(*xx + *yy);
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+        return std::unexpected(HostFunctionError::FloatComputationError);
+    }
+    // LCOV_EXCL_STOP
+}
+
+std::expected<Bytes, HostFunctionError>
+floatSubtractImpl(Slice const& x, Slice const& y, int32_t mode)
+{
+    try
+    {
+        detail::FloatState const rm(mode);
+        if (!rm)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+        auto const xx = detail::floatDecode(x);
+        if (!xx)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+        auto const yy = detail::floatDecode(y);
+        if (!yy)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+
+        return detail::floatEncode(*xx - *yy);
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+        return std::unexpected(HostFunctionError::FloatComputationError);
+    }
+    // LCOV_EXCL_STOP
+}
+
+std::expected<Bytes, HostFunctionError>
+floatMultiplyImpl(Slice const& x, Slice const& y, int32_t mode)
+{
+    try
+    {
+        detail::FloatState const rm(mode);
+        if (!rm)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+        auto const xx = detail::floatDecode(x);
+        if (!xx)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+        auto const yy = detail::floatDecode(y);
+        if (!yy)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+
+        return detail::floatEncode(*xx * *yy);
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+        return std::unexpected(HostFunctionError::FloatComputationError);
+    }
+    // LCOV_EXCL_STOP
+}
+
+std::expected<Bytes, HostFunctionError>
+floatDivideImpl(Slice const& x, Slice const& y, int32_t mode)
+{
+    try
+    {
+        detail::FloatState const rm(mode);
+        if (!rm)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+        auto const xx = detail::floatDecode(x);
+        if (!xx)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+        auto const yy = detail::floatDecode(y);
+        if (!yy)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+
+        return detail::floatEncode(*xx / *yy);
+    }
+    catch (...)
+    {
+        return std::unexpected(HostFunctionError::FloatComputationError);
+    }
+}
+
+std::expected<Bytes, HostFunctionError>
+floatRootImpl(Slice const& x, int32_t n, int32_t mode)
+{
+    try
+    {
+        if (n < 1)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+
+        detail::FloatState const rm(mode);
+        if (!rm)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+
+        auto const xx = detail::floatDecode(x);
+        if (!xx)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+
+        return detail::floatEncode(root(*xx, n));
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+        return std::unexpected(HostFunctionError::FloatComputationError);
+    }
+    // LCOV_EXCL_STOP
+}
+
+std::expected<Bytes, HostFunctionError>
+floatPowerImpl(Slice const& x, int32_t n, int32_t mode)
+{
+    try
+    {
+        if ((n < 0) || (n > Number::kMaxExponent))
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+
+        detail::FloatState const rm(mode);
+        if (!rm)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+
+        auto const xx = detail::floatDecode(x);
+        if (!xx)
+            return std::unexpected(HostFunctionError::FloatInputMalformed);
+        if (*xx == Number() && (n == 0))
+            return std::unexpected(HostFunctionError::InvalidParams);
+
+        return detail::floatEncode(power(*xx, n, 1));
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+        return std::unexpected(HostFunctionError::FloatComputationError);
+    }
+    // LCOV_EXCL_STOP
+}
+
+}  // namespace wasm_float
+
+// =========================================================
+// ACTUAL HOST FUNCTIONS
+// =========================================================
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::floatFromInt(int64_t x, int32_t mode) const
+{
+    return wasm_float::floatFromIntImpl(x, mode);
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::floatFromUint(uint64_t x, int32_t mode) const
+{
+    return wasm_float::floatFromUintImpl(x, mode);
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::floatFromSTAmount(STAmount const& x, int32_t mode) const
+{
+    return wasm_float::floatFromSTAmountImpl(x, mode);
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::floatFromSTNumber(STNumber const& x, int32_t mode) const
+{
+    return wasm_float::floatFromSTNumberImpl(x, mode);
+}
+
+std::expected<int64_t, HostFunctionError>
+WasmHostFunctionsImpl::floatToInt(Slice const& x, int32_t mode) const
+{
+    return wasm_float::floatToIntImpl(x, mode);
+}
+
+std::expected<FloatPair, HostFunctionError>
+WasmHostFunctionsImpl::floatToMantExp(Slice const& x) const
+{
+    return wasm_float::floatToMantExpImpl(x);
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::floatFromMantExp(int64_t mantissa, int32_t exponent, int32_t mode) const
+{
+    return wasm_float::floatFromMantExpImpl(mantissa, exponent, mode);
+}
+
+std::expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::floatCompare(Slice const& x, Slice const& y) const
+{
+    return wasm_float::floatCompareImpl(x, y);
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::floatAdd(Slice const& x, Slice const& y, int32_t mode) const
+{
+    return wasm_float::floatAddImpl(x, y, mode);
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::floatSubtract(Slice const& x, Slice const& y, int32_t mode) const
+{
+    return wasm_float::floatSubtractImpl(x, y, mode);
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::floatMultiply(Slice const& x, Slice const& y, int32_t mode) const
+{
+    return wasm_float::floatMultiplyImpl(x, y, mode);
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::floatDivide(Slice const& x, Slice const& y, int32_t mode) const
+{
+    return wasm_float::floatDivideImpl(x, y, mode);
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::floatRoot(Slice const& x, int32_t n, int32_t mode) const
+{
+    return wasm_float::floatRootImpl(x, n, mode);
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::floatPower(Slice const& x, int32_t n, int32_t mode) const
+{
+    return wasm_float::floatPowerImpl(x, n, mode);
+}
+
+}  // namespace xrpl

src/libxrpl/tx/wasm/HostFuncImplGetter.cpp

@@ -0,0 +1,400 @@
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/basics/contract.h>
+#include <xrpl/beast/utility/instrumentation.h>
+#include <xrpl/protocol/Asset.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/MPTIssue.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STBase.h>
+#include <xrpl/protocol/STBitString.h>
+#include <xrpl/protocol/STObject.h>
+#include <xrpl/protocol/Serializer.h>
+#include <xrpl/tx/wasm/HostFuncImpl.h>
+#include <xrpl/tx/wasm/WasmCommon.h>
+
+#include <cstdint>
+#include <expected>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <variant>
+
+namespace xrpl {
+
+using FieldValue = std::variant<STBase const*, uint256 const*>;
+
+template <class T>
+Bytes
+getIntBytes(STBase const* obj)
+{
+    static_assert(std::is_integral_v<T>, "Only integral types");
+    XRPL_ASSERT(obj, "getIntBytes null pointer");
+
+    auto const* num(static_cast<STInteger<T> const*>(obj));  // NOLINT
+    T const data = adjustWasmEndianess(num->value());
+    auto const* b = reinterpret_cast<uint8_t const*>(&data);
+    return Bytes{b, b + sizeof(T)};
+}
+
+static std::expected<Bytes, HostFunctionError>
+getAnyFieldData(STBase const* obj)
+{
+    if (obj == nullptr)
+        return std::unexpected(HostFunctionError::FieldNotFound);
+
+    auto const stype = obj->getSType();
+    switch (stype)
+    {
+        // LCOV_EXCL_START
+        case STI_UNKNOWN:
+        case STI_NOTPRESENT:
+            return std::unexpected(HostFunctionError::FieldNotFound);
+            // LCOV_EXCL_STOP
+
+        case STI_OBJECT:
+        case STI_ARRAY:
+        case STI_VECTOR256:
+            return std::unexpected(HostFunctionError::NotLeafField);
+
+        case STI_ACCOUNT: {
+            auto const* account(static_cast<STAccount const*>(obj));  // NOLINT
+            auto const& data = account->value();
+            return Bytes{data.begin(), data.end()};
+        }
+
+        case STI_ISSUE: {
+            auto const* issue(static_cast<STIssue const*>(obj));  // NOLINT
+            Asset const& asset(issue->value());
+            // XRP and IOU will be processed by serializer
+            if (asset.holds<MPTIssue>())
+            {
+                auto const& mptIssue = asset.get<MPTIssue>();
+                auto const& mptID = mptIssue.getMptID();
+                return Bytes{mptID.cbegin(), mptID.cend()};
+            }
+            break;  // Use serializer
+        }
+
+        case STI_VL: {
+            auto const* vl(static_cast<STBlob const*>(obj));  // NOLINT
+            auto const& data = vl->value();
+            return Bytes{data.begin(), data.end()};
+        }
+
+        case STI_UINT16:
+            return getIntBytes<std::uint16_t>(obj);
+
+        case STI_UINT32:
+            return getIntBytes<std::uint32_t>(obj);
+
+        // LCOV_EXCL_START
+        case STI_UINT64:
+            return getIntBytes<std::uint64_t>(obj);
+
+        case STI_INT32:
+            return getIntBytes<std::int32_t>(obj);
+
+        case STI_INT64:
+            return getIntBytes<std::int64_t>(obj);
+            // LCOV_EXCL_STOP
+
+        case STI_UINT256: {
+            auto const* uint256Obj(static_cast<STUInt256 const*>(obj));  // NOLINT
+            auto const& data = uint256Obj->value();
+            return Bytes{data.begin(), data.end()};
+        }
+
+        case STI_AMOUNT:
+        case STI_NUMBER:
+        default:
+            break;  // Use serializer
+    }
+
+    Serializer msg;
+    obj->add(msg);
+    return msg.getData();
+}
+
+static std::expected<Bytes, HostFunctionError>
+getAnyFieldData(FieldValue const& variantObj)
+{
+    if (STBase const* const* obj = std::get_if<STBase const*>(&variantObj))
+        return getAnyFieldData(*obj);
+
+    if (uint256 const* const* u = std::get_if<uint256 const*>(&variantObj))
+        return Bytes((*u)->begin(), (*u)->end());
+
+    // Unreachable: the variant only holds the two alternatives above. If not,
+    // it's an xrpld bug -> tecINTERNAL (thrown, caught by HostFuncMain_wrap).
+    Throw<std::runtime_error>(std::string(hfErrInternal));  // LCOV_EXCL_LINE
+}
+
+static inline bool
+noField(STBase const* field)
+{
+    return (field == nullptr) || (STI_NOTPRESENT == field->getSType()) ||
+        (STI_UNKNOWN == field->getSType());
+}
+
+static std::expected<FieldValue, HostFunctionError>
+locateField(STObject const& obj, FieldLocator const& locator)
+{
+    STBase const* field = nullptr;
+    auto const& knownSFields = SField::getKnownCodeToField();
+
+    {
+        int32_t const sfieldCode = adjustWasmEndianess(locator[0]);
+        auto const it = knownSFields.find(sfieldCode);
+        if (it == knownSFields.end())
+            return std::unexpected(HostFunctionError::InvalidField);
+
+        auto const& fname(*it->second);
+        field = obj.peekAtPField(fname);
+        if (noField(field))
+            return std::unexpected(HostFunctionError::FieldNotFound);
+    }
+
+    for (unsigned i = 1; i < locator.size(); ++i)
+    {
+        int32_t const sfieldCode = adjustWasmEndianess(locator[i]);
+
+        if (STI_ARRAY == field->getSType())
+        {
+            auto const* arr = static_cast<STArray const*>(field);  // NOLINT
+            if (sfieldCode < 0 || std::cmp_greater_equal(sfieldCode, arr->size()))
+                return std::unexpected(HostFunctionError::IndexOutOfBounds);
+            field = &(arr->operator[](sfieldCode));
+        }
+        else if (STI_OBJECT == field->getSType())
+        {
+            auto const* o = static_cast<STObject const*>(field);  // NOLINT
+
+            auto const it = knownSFields.find(sfieldCode);
+            if (it == knownSFields.end())
+                return std::unexpected(HostFunctionError::InvalidField);
+
+            auto const& fname(*it->second);
+            field = o->peekAtPField(fname);
+        }
+        else if (STI_VECTOR256 == field->getSType())
+        {
+            auto const* v = static_cast<STVector256 const*>(field);  // NOLINT
+            if (sfieldCode < 0 || std::cmp_greater_equal(sfieldCode, v->size()))
+                return std::unexpected(HostFunctionError::IndexOutOfBounds);
+            return FieldValue(&(v->operator[](sfieldCode)));
+        }
+        else  // simple field must be the last one
+        {
+            return std::unexpected(HostFunctionError::LocatorMalformed);
+        }
+
+        if (noField(field))
+            return std::unexpected(HostFunctionError::FieldNotFound);
+    }
+
+    return FieldValue(field);
+}
+
+static inline std::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();  // NOLINT
+        if ((*field)->getSType() == STI_ARRAY)
+            return static_cast<STArray const*>(*field)->size();  // NOLINT
+    }
+    // uint256 is not an array so that variant should still return NO_ARRAY
+
+    return std::unexpected(HostFunctionError::NoArray);  // LCOV_EXCL_LINE
+}
+
+std::expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::cacheLedgerObj(uint256 const& objId, int32_t cacheIdx)
+{
+    auto const& keylet = keylet::unchecked(objId);
+    if (cacheIdx < 0 || cacheIdx > maxCache)
+        return std::unexpected(HostFunctionError::SlotOutRange);
+
+    if (cacheIdx == 0)
+    {
+        for (cacheIdx = 0; cacheIdx < maxCache; ++cacheIdx)
+        {
+            if (!cache_[cacheIdx])
+                break;
+        }
+    }
+    else
+    {
+        cacheIdx--;  // convert to 0-based index
+    }
+
+    if (cacheIdx >= maxCache)
+        return std::unexpected(HostFunctionError::SlotsFull);
+
+    cache_[cacheIdx] = ctx_.view().read(keylet);
+    if (!cache_[cacheIdx])
+        return std::unexpected(HostFunctionError::LedgerObjNotFound);
+    return cacheIdx + 1;  // return 1-based index
+}
+
+// Subsection: top level getters
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::getTxField(SField const& fname) const
+{
+    return getAnyFieldData(ctx_.tx.peekAtPField(fname));
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::getCurrentLedgerObjField(SField const& fname) const
+{
+    auto const sle = getCurrentLedgerObj();
+    if (!sle.has_value())
+        return std::unexpected(sle.error());
+    return getAnyFieldData(sle.value()->peekAtPField(fname));
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::getLedgerObjField(int32_t cacheIdx, SField const& fname) const
+{
+    auto const normalizedIdx = normalizeCacheIndex(cacheIdx);
+    if (!normalizedIdx.has_value())
+        return std::unexpected(normalizedIdx.error());
+    return getAnyFieldData(cache_[normalizedIdx.value()]->peekAtPField(fname));
+}
+
+// Subsection: nested getters
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::getTxNestedField(FieldLocator const& locator) const
+{
+    auto const r = locateField(ctx_.tx, locator);
+    if (!r)
+        return std::unexpected(r.error());
+
+    return getAnyFieldData(r.value());
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::getCurrentLedgerObjNestedField(FieldLocator const& locator) const
+{
+    auto const sle = getCurrentLedgerObj();
+    if (!sle.has_value())
+        return std::unexpected(sle.error());
+
+    auto const r = locateField(*sle.value(), locator);
+    if (!r)
+        return std::unexpected(r.error());
+
+    return getAnyFieldData(r.value());
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::getLedgerObjNestedField(int32_t cacheIdx, FieldLocator const& locator) const
+{
+    auto const normalizedIdx = normalizeCacheIndex(cacheIdx);
+    if (!normalizedIdx.has_value())
+        return std::unexpected(normalizedIdx.error());
+
+    auto const r = locateField(*cache_[normalizedIdx.value()], locator);
+    if (!r)
+        return std::unexpected(r.error());
+
+    return getAnyFieldData(r.value());
+}
+
+// Subsection: array length getters
+
+std::expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::getTxArrayLen(SField const& fname) const
+{
+    if (fname.fieldType != STI_ARRAY && fname.fieldType != STI_VECTOR256)
+        return std::unexpected(HostFunctionError::NoArray);
+
+    auto const* field = ctx_.tx.peekAtPField(fname);
+    if (noField(field))
+        return std::unexpected(HostFunctionError::FieldNotFound);
+
+    return getArrayLen(field);
+}
+
+std::expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::getCurrentLedgerObjArrayLen(SField const& fname) const
+{
+    if (fname.fieldType != STI_ARRAY && fname.fieldType != STI_VECTOR256)
+        return std::unexpected(HostFunctionError::NoArray);
+
+    auto const sle = getCurrentLedgerObj();
+    if (!sle.has_value())
+        return std::unexpected(sle.error());
+
+    auto const* field = sle.value()->peekAtPField(fname);
+    if (noField(field))
+        return std::unexpected(HostFunctionError::FieldNotFound);
+
+    return getArrayLen(field);
+}
+
+std::expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::getLedgerObjArrayLen(int32_t cacheIdx, SField const& fname) const
+{
+    if (fname.fieldType != STI_ARRAY && fname.fieldType != STI_VECTOR256)
+        return std::unexpected(HostFunctionError::NoArray);
+
+    auto const normalizedIdx = normalizeCacheIndex(cacheIdx);
+    if (!normalizedIdx.has_value())
+        return std::unexpected(normalizedIdx.error());
+
+    auto const* field = cache_[normalizedIdx.value()]->peekAtPField(fname);
+    if (noField(field))
+        return std::unexpected(HostFunctionError::FieldNotFound);
+
+    return getArrayLen(field);
+}
+
+// Subsection: nested array length getters
+
+std::expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::getTxNestedArrayLen(FieldLocator const& locator) const
+{
+    auto const r = locateField(ctx_.tx, locator);
+    if (!r)
+        return std::unexpected(r.error());
+
+    auto const& field = r.value();
+    return getArrayLen(field);
+}
+
+std::expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::getCurrentLedgerObjNestedArrayLen(FieldLocator const& locator) const
+{
+    auto const sle = getCurrentLedgerObj();
+    if (!sle.has_value())
+        return std::unexpected(sle.error());
+    auto const r = locateField(*sle.value(), locator);
+    if (!r)
+        return std::unexpected(r.error());
+
+    auto const& field = r.value();
+    return getArrayLen(field);
+}
+
+std::expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::getLedgerObjNestedArrayLen(int32_t cacheIdx, FieldLocator const& locator)
+    const
+{
+    auto const normalizedIdx = normalizeCacheIndex(cacheIdx);
+    if (!normalizedIdx.has_value())
+        return std::unexpected(normalizedIdx.error());
+
+    auto const r = locateField(*cache_[normalizedIdx.value()], locator);
+    if (!r)
+        return std::unexpected(r.error());
+
+    auto const& field = r.value();
+    return getArrayLen(field);
+}
+
+}  // namespace xrpl

src/libxrpl/tx/wasm/HostFuncImplKeylet.cpp

@@ -0,0 +1,223 @@
+#include <xrpl/basics/Slice.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Asset.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/MPTIssue.h>
+#include <xrpl/protocol/Protocol.h>
+#include <xrpl/protocol/SeqProxy.h>
+#include <xrpl/protocol/UintTypes.h>
+#include <xrpl/tx/wasm/HostFuncImpl.h>
+#include <xrpl/tx/wasm/WasmCommon.h>
+
+#include <cstdint>
+#include <expected>
+
+namespace xrpl {
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::accountKeylet(AccountID const& account) const
+{
+    if (!account)
+        return std::unexpected(HostFunctionError::InvalidAccount);
+    auto const keylet = keylet::account(account);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::ammKeylet(Asset const& issue1, Asset const& issue2) const
+{
+    if (issue1 == issue2)
+        return std::unexpected(HostFunctionError::InvalidParams);
+
+    // note: this should be removed with the MPT DEX amendment
+    if (issue1.holds<MPTIssue>() || issue2.holds<MPTIssue>())
+        return std::unexpected(HostFunctionError::InvalidParams);
+
+    auto const keylet = keylet::amm(issue1, issue2);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::checkKeylet(AccountID const& account, std::uint32_t seq) const
+{
+    if (!account)
+        return std::unexpected(HostFunctionError::InvalidAccount);
+    auto const keylet = keylet::check(account, SeqProxy::rawSequence(seq));
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::credentialKeylet(
+    AccountID const& subject,
+    AccountID const& issuer,
+    Slice const& credentialType) const
+{
+    if (!subject || !issuer)
+        return std::unexpected(HostFunctionError::InvalidAccount);
+
+    if (credentialType.empty() || credentialType.size() > kMaxCredentialTypeLength)
+        return std::unexpected(HostFunctionError::InvalidParams);
+
+    auto const keylet = keylet::credential(subject, issuer, credentialType);
+
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::didKeylet(AccountID const& account) const
+{
+    if (!account)
+        return std::unexpected(HostFunctionError::InvalidAccount);
+    auto const keylet = keylet::did(account);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::delegateKeylet(AccountID const& account, AccountID const& authorize) const
+{
+    if (!account || !authorize)
+        return std::unexpected(HostFunctionError::InvalidAccount);
+    if (account == authorize)
+        return std::unexpected(HostFunctionError::InvalidParams);
+    auto const keylet = keylet::delegate(account, authorize);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::depositPreauthKeylet(AccountID const& account, AccountID const& authorize)
+    const
+{
+    if (!account || !authorize)
+        return std::unexpected(HostFunctionError::InvalidAccount);
+    if (account == authorize)
+        return std::unexpected(HostFunctionError::InvalidParams);
+    auto const keylet = keylet::depositPreauth(account, authorize);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::escrowKeylet(AccountID const& account, std::uint32_t seq) const
+{
+    if (!account)
+        return std::unexpected(HostFunctionError::InvalidAccount);
+    auto const keylet = keylet::escrow(account, SeqProxy::rawSequence(seq));
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::trustLineKeylet(
+    AccountID const& account1,
+    AccountID const& account2,
+    Currency const& currency) const
+{
+    if (!account1 || !account2)
+        return std::unexpected(HostFunctionError::InvalidAccount);
+    if (account1 == account2)
+        return std::unexpected(HostFunctionError::InvalidParams);
+    if (currency.isZero())
+        return std::unexpected(HostFunctionError::InvalidParams);
+
+    auto const keylet = keylet::trustLine(account1, account2, currency);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::mptokenIssuanceKeylet(AccountID const& issuer, std::uint32_t seq) const
+{
+    if (!issuer)
+        return std::unexpected(HostFunctionError::InvalidAccount);
+
+    auto const keylet = keylet::mptokenIssuance(makeMptID(seq, issuer));
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::mptokenKeylet(MPTID const& mptid, AccountID const& holder) const
+{
+    if (!mptid)
+        return std::unexpected(HostFunctionError::InvalidParams);
+    if (!holder)
+        return std::unexpected(HostFunctionError::InvalidAccount);
+
+    auto const keylet = keylet::mptoken(mptid, holder);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::nftokenOfferKeylet(AccountID const& account, std::uint32_t seq) const
+{
+    if (!account)
+        return std::unexpected(HostFunctionError::InvalidAccount);
+    auto const keylet = keylet::nftokenOffer(account, SeqProxy::rawSequence(seq));
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::offerKeylet(AccountID const& account, std::uint32_t seq) const
+{
+    if (!account)
+        return std::unexpected(HostFunctionError::InvalidAccount);
+    auto const keylet = keylet::offer(account, SeqProxy::rawSequence(seq));
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::oracleKeylet(AccountID const& account, std::uint32_t documentId) const
+{
+    if (!account)
+        return std::unexpected(HostFunctionError::InvalidAccount);
+    auto const keylet = keylet::oracle(account, documentId);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::paychannelKeylet(
+    AccountID const& account,
+    AccountID const& destination,
+    std::uint32_t seq) const
+{
+    if (!account || !destination)
+        return std::unexpected(HostFunctionError::InvalidAccount);
+    if (account == destination)
+        return std::unexpected(HostFunctionError::InvalidParams);
+    auto const keylet = keylet::payChannel(account, destination, SeqProxy::rawSequence(seq));
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::permissionedDomainKeylet(AccountID const& account, std::uint32_t seq) const
+{
+    if (!account)
+        return std::unexpected(HostFunctionError::InvalidAccount);
+    auto const keylet = keylet::permissionedDomain(account, SeqProxy::rawSequence(seq));
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::signerListKeylet(AccountID const& account) const
+{
+    if (!account)
+        return std::unexpected(HostFunctionError::InvalidAccount);
+    auto const keylet = keylet::signerList(account);
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::ticketKeylet(AccountID const& account, std::uint32_t seq) const
+{
+    if (!account)
+        return std::unexpected(HostFunctionError::InvalidAccount);
+    auto const keylet = keylet::ticket(account, SeqProxy::rawTicket(seq));
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::vaultKeylet(AccountID const& account, std::uint32_t seq) const
+{
+    if (!account)
+        return std::unexpected(HostFunctionError::InvalidAccount);
+    auto const keylet = keylet::vault(account, SeqProxy::rawSequence(seq));
+    return Bytes{keylet.key.begin(), keylet.key.end()};
+}
+
+}  // namespace xrpl

src/libxrpl/tx/wasm/HostFuncImplLedgerHeader.cpp

@@ -0,0 +1,55 @@
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/ledger/AmendmentTable.h>
+#include <xrpl/tx/wasm/HostFuncImpl.h>
+#include <xrpl/tx/wasm/WasmCommon.h>
+
+#include <cstdint>
+#include <expected>
+#include <string>
+#include <string_view>
+
+namespace xrpl {
+
+// =========================================================
+// SECTION: LEDGER HEADER FUNCTIONS
+// =========================================================
+
+std::expected<std::uint32_t, HostFunctionError>
+WasmHostFunctionsImpl::getLedgerSqn() const
+{
+    return ctx_.view().seq();
+}
+
+std::expected<std::uint32_t, HostFunctionError>
+WasmHostFunctionsImpl::getParentLedgerTime() const
+{
+    return ctx_.view().parentCloseTime().time_since_epoch().count();
+}
+
+std::expected<Hash, HostFunctionError>
+WasmHostFunctionsImpl::getParentLedgerHash() const
+{
+    return ctx_.view().header().parentHash;
+}
+
+std::expected<std::uint32_t, HostFunctionError>
+WasmHostFunctionsImpl::getBaseFee() const
+{
+    return ctx_.view().fees().base.drops();
+}
+
+std::expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::isAmendmentEnabled(uint256 const& amendmentId) const
+{
+    return ctx_.view().rules().enabled(amendmentId);
+}
+
+std::expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::isAmendmentEnabled(std::string_view const& amendmentName) const
+{
+    auto const& table = ctx_.registry.get().getAmendmentTable();
+    auto const amendment = table.find(std::string(amendmentName));
+    return ctx_.view().rules().enabled(amendment);
+}
+
+}  // namespace xrpl

src/libxrpl/tx/wasm/HostFuncImplNFT.cpp

@@ -0,0 +1,74 @@
+#include <xrpl/basics/Slice.h>
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/ledger/helpers/NFTokenHelpers.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/nft.h>
+#include <xrpl/tx/wasm/HostFuncImpl.h>
+#include <xrpl/tx/wasm/WasmCommon.h>
+
+#include <cstdint>
+#include <expected>
+
+namespace xrpl {
+
+// =========================================================
+// SECTION: NFT UTILS
+// =========================================================
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::getNFT(AccountID const& account, uint256 const& nftId) const
+{
+    if (!account)
+        return std::unexpected(HostFunctionError::InvalidAccount);
+
+    if (!nftId)
+        return std::unexpected(HostFunctionError::InvalidParams);
+
+    auto obj = nft::findToken(ctx_.view(), account, nftId);
+    if (!obj)
+        return std::unexpected(HostFunctionError::LedgerObjNotFound);
+
+    auto objUri = obj->at(~sfURI);
+    if (!objUri)
+        return std::unexpected(HostFunctionError::FieldNotFound);
+
+    Slice const s = objUri->value();
+    return Bytes(s.begin(), s.end());
+}
+
+std::expected<Bytes, HostFunctionError>
+WasmHostFunctionsImpl::getNFTIssuer(uint256 const& nftId) const
+{
+    auto const issuer = nft::getIssuer(nftId);
+    if (!issuer)
+        return std::unexpected(HostFunctionError::InvalidParams);
+
+    return Bytes{issuer.begin(), issuer.end()};
+}
+
+std::expected<std::uint32_t, HostFunctionError>
+WasmHostFunctionsImpl::getNFTTaxon(uint256 const& nftId) const
+{
+    return nft::toUInt32(nft::getTaxon(nftId));
+}
+
+std::expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::getNFTFlags(uint256 const& nftId) const
+{
+    return nft::getFlags(nftId);
+}
+
+std::expected<int32_t, HostFunctionError>
+WasmHostFunctionsImpl::getNFTTransferFee(uint256 const& nftId) const
+{
+    return nft::getTransferFee(nftId);
+}
+
+std::expected<std::uint32_t, HostFunctionError>
+WasmHostFunctionsImpl::getNFTSequence(uint256 const& nftId) const
+{
+    return nft::getSequence(nftId);
+}
+
+}  // namespace xrpl

src/libxrpl/tx/wasm/WasmVM.cpp

@@ -0,0 +1,215 @@
+#include <xrpl/tx/wasm/WasmVM.h>
+
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/protocol/TER.h>
+#include <xrpl/tx/wasm/HostFuncWrapper.h>  // IWYU pragma: keep
+#include <xrpl/tx/wasm/WasmCommon.h>
+#include <xrpl/tx/wasm/WasmImportsHelper.h>
+
+#include <cstdint>
+#include <expected>
+#include <string>
+#include <vector>
+#ifdef _DEBUG
+// #define DEBUG_OUTPUT 1
+#endif
+
+#include <xrpl/tx/wasm/HostFunc.h>
+#include <xrpl/tx/wasm/WasmiVM.h>
+
+#include <memory>
+
+namespace xrpl {
+// WARNING: Per XLS-0102, the host functions registered here form a stable
+// ABI. Their name, semantics, parameters, and return types must NEVER be
+// changed, as there may always be a program that uses it. New host functions
+// may be added and existing gas costs may be adjusted, but every such change
+// must be gated by an amendment.
+// See XLS-0102 §6.5 (Future-Proofing):
+// https://github.com/XRPLF/XRPL-Standards/tree/master/XLS-0102-wasm-vm#65-future-proofing
+static void
+setCommonHostFunctions(HostFunctions& hfs, ImportVec& i)
+{
+    // clang-format off
+    WASM_IMPORT_FUNC2(i, getLedgerSqn, "ldgr_index", hfs,                                                      60);
+    WASM_IMPORT_FUNC2(i, getParentLedgerTime, "parent_ldgr_time", hfs,                                         60);
+    WASM_IMPORT_FUNC2(i, getParentLedgerHash, "parent_ldgr_hash", hfs,                                         60);
+    WASM_IMPORT_FUNC2(i, getBaseFee, "base_fee", hfs,                                                          60);
+    WASM_IMPORT_FUNC2(i, isAmendmentEnabled, "amendment_enabled", hfs,                                        100);
+
+    WASM_IMPORT_FUNC2(i, cacheLedgerObj, "cache_le", hfs,                                                   5'000);
+    WASM_IMPORT_FUNC2(i, getTxField, "tx_field", hfs,                                                          70);
+    WASM_IMPORT_FUNC2(i, getCurrentLedgerObjField, "home_le_field", hfs,                                       70);
+    WASM_IMPORT_FUNC2(i, getLedgerObjField, "le_field", hfs,                                                   70);
+    WASM_IMPORT_FUNC2(i, getTxNestedField, "tx_inner", hfs,                                                   110);
+    WASM_IMPORT_FUNC2(i, getCurrentLedgerObjNestedField, "home_le_inner", hfs,                                110);
+    WASM_IMPORT_FUNC2(i, getLedgerObjNestedField, "le_inner", hfs,                                            110);
+    WASM_IMPORT_FUNC2(i, getTxArrayLen, "tx_arr_len", hfs,                                                     40);
+    WASM_IMPORT_FUNC2(i, getCurrentLedgerObjArrayLen, "home_le_arr_len", hfs,                                  40);
+    WASM_IMPORT_FUNC2(i, getLedgerObjArrayLen, "le_arr_len", hfs,                                              40);
+    WASM_IMPORT_FUNC2(i, getTxNestedArrayLen, "tx_inner_arr_len", hfs,                                         70);
+    WASM_IMPORT_FUNC2(i, getCurrentLedgerObjNestedArrayLen, "home_le_inner_arr_len", hfs,                      70);
+    WASM_IMPORT_FUNC2(i, getLedgerObjNestedArrayLen, "le_inner_arr_len", hfs,                                  70);
+
+    WASM_IMPORT_FUNC2(i, checkSignature, "check_sig", hfs,                                                  35'000);
+    WASM_IMPORT_FUNC2(i, computeSha512HalfHash, "sha512_half", hfs,                                          2'000);
+
+    WASM_IMPORT_FUNC2(i, accountKeylet, "accountroot_id", hfs,                                                350);
+    WASM_IMPORT_FUNC2(i, ammKeylet, "amm_id", hfs,                                                            450);
+    WASM_IMPORT_FUNC2(i, checkKeylet, "check_id", hfs,                                                        350);
+    WASM_IMPORT_FUNC2(i, credentialKeylet, "credential_id", hfs,                                              350);
+    WASM_IMPORT_FUNC2(i, delegateKeylet, "delegate_id", hfs,                                                  350);
+    WASM_IMPORT_FUNC2(i, depositPreauthKeylet, "deposit_preauth_id", hfs,                                     350);
+    WASM_IMPORT_FUNC2(i, didKeylet, "did_id", hfs,                                                            350);
+    WASM_IMPORT_FUNC2(i, escrowKeylet, "escrow_id", hfs,                                                      350);
+    WASM_IMPORT_FUNC2(i, trustLineKeylet, "trustline_id", hfs,                                                     400);
+    WASM_IMPORT_FUNC2(i, mptokenIssuanceKeylet, "mpt_issuance_id", hfs,                                       350);
+    WASM_IMPORT_FUNC2(i, mptokenKeylet, "mptoken_id", hfs,                                                    500);
+    WASM_IMPORT_FUNC2(i, nftokenOfferKeylet, "nft_offer_id", hfs,                                                 350);
+    WASM_IMPORT_FUNC2(i, offerKeylet, "offer_id", hfs,                                                        350);
+    WASM_IMPORT_FUNC2(i, oracleKeylet, "oracle_id", hfs,                                                      350);
+    WASM_IMPORT_FUNC2(i, paychannelKeylet, "paychan_id", hfs,                                                 350);
+    WASM_IMPORT_FUNC2(i, permissionedDomainKeylet, "permissioned_domain_id", hfs,                             350);
+    WASM_IMPORT_FUNC2(i, signerListKeylet, "signers_id", hfs,                                                 350);
+    WASM_IMPORT_FUNC2(i, ticketKeylet, "ticket_id", hfs,                                                      350);
+    WASM_IMPORT_FUNC2(i, vaultKeylet, "vault_id", hfs,                                                        350);
+
+    WASM_IMPORT_FUNC2(i, getNFT, "nft_uri", hfs,                                                            5'000);
+    WASM_IMPORT_FUNC2(i, getNFTIssuer, "nft_issuer", hfs,                                                      70);
+    WASM_IMPORT_FUNC2(i, getNFTTaxon, "nft_taxon", hfs,                                                        60);
+    WASM_IMPORT_FUNC2(i, getNFTFlags, "nft_flags", hfs,                                                        60);
+    WASM_IMPORT_FUNC2(i, getNFTTransferFee, "nft_xfer_fee", hfs,                                               60);
+    WASM_IMPORT_FUNC2(i, getNFTSequence, "nft_serial", hfs,                                                    60);
+
+    WASM_IMPORT_FUNC (i, trace, hfs,                                                                           30);
+
+    WASM_IMPORT_FUNC2(i, floatFromInt, "float_from_int", hfs,                                                 100);
+    WASM_IMPORT_FUNC2(i, floatFromUint, "float_from_uint", hfs,                                               130);
+    WASM_IMPORT_FUNC2(i, floatFromSTAmount, "float_from_stamount", hfs,                                       150);
+    WASM_IMPORT_FUNC2(i, floatFromSTNumber, "float_from_stnumber", hfs,                                       150);
+    WASM_IMPORT_FUNC2(i, floatToInt, "float_to_int", hfs,                                                     130);
+    WASM_IMPORT_FUNC2(i, floatToMantExp, "float_to_mant_exp", hfs,                                            130);
+    WASM_IMPORT_FUNC2(i, floatFromMantExp, "float_from_mant_exp", hfs,                                        100);
+    WASM_IMPORT_FUNC2(i, floatCompare, "float_cmp", hfs,                                                       80);
+    WASM_IMPORT_FUNC2(i, floatAdd, "float_add", hfs,                                                          160);
+    WASM_IMPORT_FUNC2(i, floatSubtract, "float_sub", hfs,                                                     160);
+    WASM_IMPORT_FUNC2(i, floatMultiply, "float_mult", hfs,                                                    300);
+    WASM_IMPORT_FUNC2(i, floatDivide, "float_div", hfs,                                                       300);
+    WASM_IMPORT_FUNC2(i, floatRoot, "float_root", hfs,                                                      5'500);
+    WASM_IMPORT_FUNC2(i, floatPower, "float_pow", hfs,                                                      5'500);
+    // clang-format on
+}
+
+ImportVec
+createWasmImport(HostFunctions& hfs)
+{
+    ImportVec i;
+
+    setCommonHostFunctions(hfs, i);
+    WASM_IMPORT_FUNC2(i, updateData, "set_data", hfs, 1000);
+
+    return i;
+}
+
+std::expected<EscrowResult, WasmTER>
+runEscrowWasm(
+    Bytes const& wasmCode,
+    HostFunctions& hfs,
+    int64_t gasLimit,
+    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.run(wasmCode, hfs, gasLimit, funcName, params, createWasmImport(hfs), hfs.getJournal());
+
+    if (!ret)
+    {
+#ifdef DEBUG_OUTPUT
+        std::cout << ", error: " << ret.error().ter << std::endl;
+#endif
+        // Carries the TER (tecOUT_OF_GAS / tecFAILED_PROCESSING / tecINTERNAL /
+        // temBAD_AMOUNT) and, when meaningful, the gas consumed. The caller is
+        // responsible for writing that gas to tx metadata.
+        return std::unexpected(ret.error());
+    }
+
+#ifdef DEBUG_OUTPUT
+    std::cout << ", ret: " << ret->result << ", gas spent: " << ret->cost << std::endl;
+#endif
+    return EscrowResult{.result = ret->result, .cost = ret->cost};
+}
+
+NotTEC
+preflightEscrowWasm(
+    Bytes const& wasmCode,
+    HostFunctions& hfs,
+    std::string_view funcName,
+    std::vector<WasmParam> const& params)
+{
+    //  create VM and set cost limit
+    auto& vm = WasmEngine::instance();
+    // vm.initMaxPages(MAX_PAGES);
+
+    auto const ret =
+        vm.check(wasmCode, hfs, funcName, params, createWasmImport(hfs), hfs.getJournal());
+
+    return ret;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+WasmEngine::WasmEngine() : impl_(std::make_unique<WasmiEngine>())
+{
+}
+
+WasmEngine&
+WasmEngine::instance()
+{
+    static WasmEngine e;
+    return e;
+}
+
+std::expected<WasmResult<int32_t>, WasmTER>
+WasmEngine::run(
+    Bytes const& wasmCode,
+    HostFunctions& hfs,
+    int64_t gasLimit,
+    std::string_view funcName,
+    std::vector<WasmParam> const& params,
+    ImportVec const& imports,
+    beast::Journal j)
+{
+    return impl_->run(wasmCode, hfs, gasLimit, funcName, params, imports, j);
+}
+
+NotTEC
+WasmEngine::check(
+    Bytes const& wasmCode,
+    HostFunctions& hfs,
+    std::string_view funcName,
+    std::vector<WasmParam> const& params,
+    ImportVec const& imports,
+    beast::Journal j)
+{
+    return impl_->check(wasmCode, hfs, funcName, params, imports, 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/libxrpl/tx/wasm/WasmiVM.cpp

@@ -0,0 +1,958 @@
+#include <xrpl/tx/wasm/WasmiVM.h>
+
+#include <xrpl/basics/contract.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/protocol/TER.h>
+#include <xrpl/tx/wasm/HostFunc.h>
+#include <xrpl/tx/wasm/WasmCommon.h>
+#include <xrpl/tx/wasm/WasmImportsHelper.h>
+#include <xrpl/tx/wasm/WasmVM.h>
+
+#include <wasmi/config.h>
+#include <wasmi/error.h>
+
+#include <wasm.h>
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <exception>
+#include <expected>
+#include <limits>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+#ifdef _DEBUG
+// #define DEBUG_OUTPUT 1
+#endif
+// #define SHOW_CALL_TIME 1
+
+namespace xrpl {
+
+wasm_trap_t*
+HostFuncMain_wrap(void* env, wasm_val_vec_t const* params, wasm_val_vec_t* results);
+
+namespace {
+
+void
+printWasmError(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::Severity::Warning))
+#endif
+    {
+        wasm_byte_vec_t errorMessage WASM_EMPTY_VEC;
+
+        if (trap != nullptr)
+            wasm_trap_message(trap, &errorMessage);
+
+        if (errorMessage.size != 0u)
+        {
+            j << "WASMI Error: " << msg << ", "
+              << std::string_view(errorMessage.data, errorMessage.size - 1);
+        }
+        else
+        {
+            j << "WASMI Error: " << msg;
+        }
+
+        if (errorMessage.size != 0u)
+            wasm_byte_vec_delete(&errorMessage);
+    }
+
+    if (trap != nullptr)
+        wasm_trap_delete(trap);
+
+#ifdef DEBUG_OUTPUT
+    j << std::endl;
+#endif
+}
+// LCOV_EXCL_STOP
+
+// Extract a trap's message into a std::string (the only signal the C API gives
+// for classification; see the trap-signal constants in WasmCommon.h). Does not
+// take ownership of `trap`.
+std::string
+trapMessage(wasm_trap_t* trap)
+{
+    if (trap == nullptr)
+        return {};  // LCOV_EXCL_LINE
+    wasm_byte_vec_t msg WASM_EMPTY_VEC;
+    wasm_trap_message(trap, &msg);
+    std::string out;
+    if (msg.size != 0u)
+    {
+        // wasm_trap_message NUL-terminates, so drop the trailing NUL.
+        out.assign(msg.data, msg.size - 1);
+        wasm_byte_vec_delete(&msg);
+    }
+    return out;
+}
+
+}  // namespace
+
+class WasmiRuntimeWrapper : public WasmRuntimeWrapper
+{
+    InstanceWrapper& iw_;
+
+public:
+    WasmiRuntimeWrapper(InstanceWrapper& iw) : iw_(iw)
+    {
+    }
+
+    Wmem
+    getMem() override
+    {
+        return iw_.getMem();
+    }
+
+    std::int64_t
+    getGas() override
+    {
+        return iw_.getGas();
+    }
+
+    std::int64_t
+    setGas(std::int64_t gas) override
+    {
+        return iw_.setGas(gas);
+    }
+
+    std::int64_t
+    getTransferLimit() override
+    {
+        return iw_.getTransferLimit();
+    }
+
+    std::int64_t
+    setTransferLimit(std::int64_t x) override
+    {
+        return iw_.setTransferLimit(x);
+    }
+};
+
+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.get(), &trap), &wasm_instance_delete);
+
+    if (!mi || (trap != nullptr))
+    {
+        printWasmError("can't create instance", trap, j);
+        Throw<std::runtime_error>("can't create instance");
+    }
+    wasm_instance_exports(mi.get(), expt.get());
+    return mi;
+}
+
+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;
+}
+
+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.empty())
+        Throw<std::runtime_error>("no export");  // LCOV_EXCL_LINE
+    if (exportTypes.size() != exports_.size())
+        Throw<std::runtime_error>("invalid export");  // LCOV_EXCL_LINE
+
+    for (unsigned i = 0; i < exportTypes.size(); ++i)
+    {
+        auto const* expType(exportTypes[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_[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 == nullptr) || (ft == nullptr))
+        Throw<std::runtime_error>("can't find function <" + std::string(funcName) + ">");
+
+    return {f, ft};
+}
+
+Wmem
+InstanceWrapper::getMem() const
+{
+    if (memIdx_ >= 0)
+    {
+        auto* e(exports_[memIdx_]);
+        wasm_memory_t* mem = wasm_extern_as_memory(e);
+        return Wmem(wasm_memory_data(mem), wasm_memory_data_size(mem));
+    }
+
+    wasm_memory_t* mem = nullptr;
+    for (int i = 0; i < exports_.size(); ++i)
+    {
+        auto* e(exports_[i]);
+        if (wasm_extern_kind(e) == WASM_EXTERN_MEMORY)
+        {
+            memIdx_ = i;
+            mem = wasm_extern_as_memory(e);
+            break;
+        }
+    }
+
+    if (mem == nullptr)
+        return {};  // LCOV_EXCL_LINE
+
+    return Wmem(wasm_memory_data(mem), wasm_memory_data_size(mem));
+}
+
+std::int64_t
+InstanceWrapper::getGas() const
+{
+    if (store_ == nullptr)
+        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_ == nullptr)
+        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 != nullptr)
+    {
+        // LCOV_EXCL_START
+        printWasmError("Can't set instance gas", nullptr, j_);
+        wasmi_error_delete(err);
+        return -1;
+        // LCOV_EXCL_STOP
+    }
+
+    return gas;
+}
+
+std::int64_t
+InstanceWrapper::getTransferLimit() const
+{
+    if (store_ == nullptr)
+        return -1;  // LCOV_EXCL_LINE
+
+    return transferLimit_;
+}
+
+std::int64_t
+InstanceWrapper::setTransferLimit(std::int64_t x)
+{
+    if (store_ == nullptr)
+        return -1;  // LCOV_EXCL_LINE
+    if (x < 0)
+    {
+        transferLimit_ = std::numeric_limits<decltype(transferLimit_)>::max();
+    }
+    else
+    {
+        transferLimit_ = x;
+    }
+
+    return transferLimit_;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ModulePtr
+ModuleWrapper::init(StorePtr& s, Bytes const& wasmBin, beast::Journal j)
+{
+    wasm_byte_vec_t const code{
+        .size = wasmBin.size(),
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
+        .data = const_cast<char*>(reinterpret_cast<char const*>(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;
+}
+
+ModuleWrapper::ModuleWrapper(
+    StorePtr& s,
+    Bytes const& wasmBin,
+    bool instantiate,
+    ImportVec const& imports,
+    beast::Journal j)
+    : module_(init(s, wasmBin, j)), j_(j)
+{
+    wasm_module_exports(module_.get(), exportTypes_.get());
+    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;
+}
+
+// LCOV_EXCL_STOP
+
+static WasmValtypeVec
+makeImpParams(WasmImportFunc const& imp)
+{
+    auto const paramSize = imp.params.size();
+    if (paramSize == 0u)
+        return {};
+
+    WasmValtypeVec v(paramSize);
+
+    for (unsigned i = 0; i < paramSize; ++i)
+    {
+        auto const vt = imp.params[i];
+        switch (vt)
+        {
+            case WasmTypes::WtI32:
+                v[i] = wasm_valtype_new_i32();
+                break;
+            case WasmTypes::WtI64:
+                v[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 WasmTypes::WtI32:
+            v[0] = wasm_valtype_new_i32();
+            break;
+            // LCOV_EXCL_START
+        case WasmTypes::WtI64:
+            v[0] = wasm_valtype_new_i64();
+            break;
+        default:
+            throw std::runtime_error("invalid return type");
+            // LCOV_EXCL_STOP
+    }
+    return v;
+}
+
+WasmExternVec
+ModuleWrapper::buildImports(StorePtr& s, ImportVec const& imports) const
+{
+    WasmImporttypeVec importTypes;
+    wasm_module_imports(module_.get(), importTypes.get());
+
+    if (importTypes.empty())
+        return {};
+    if (imports.empty())
+        Throw<std::runtime_error>("Empty imports");
+
+    WasmExternVec wimports(importTypes.size());
+
+    unsigned impCnt = 0;
+    for (unsigned i = 0; i < importTypes.size(); ++i)
+    {
+        wasm_importtype_t const* importType = importTypes[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;
+
+        auto const it = imports.find(fieldName);
+        if (it == imports.end())
+        {
+            printWasmError("Import not found: " + std::string(fieldName), nullptr, j_);
+            continue;  // print all missed import
+        }
+
+        WasmUserData const& obj = it->second;
+        WasmImportFunc const& imp = obj.second;
+
+        WasmValtypeVec params(makeImpParams(imp));
+        WasmValtypeVec results(makeImpReturn(imp));
+
+        std::unique_ptr<wasm_functype_t, decltype(&wasm_functype_delete)> const ftype(
+            wasm_functype_new(params.get(), results.get()), &wasm_functype_delete);
+
+        params.release();
+        results.release();
+
+        wasm_func_t* func =
+            wasm_func_new_with_env(s.get(), ftype.get(), HostFuncMain_wrap, (void*)&obj, nullptr);
+        if (func == nullptr)
+        {
+            Throw<std::runtime_error>(
+                "can't create import function " + std::string(imp.name));  // LCOV_EXCL_LINE
+        }
+
+        wimports[i] = wasm_func_as_extern(func);
+        ++impCnt;
+    }
+
+    if (impCnt != importTypes.size())
+    {
+        printWasmError(
+            std::string("Imports not finished: ") + std::to_string(impCnt) + "/" +
+                std::to_string(importTypes.size()),
+            nullptr,
+            j_);
+        Throw<std::runtime_error>("Missing imports");
+    }
+
+    return wimports;
+}
+
+wasm_functype_t const*
+ModuleWrapper::getFuncType(std::string_view funcName) const
+{
+    for (size_t i = 0; i < exportTypes_.size(); i++)
+    {
+        auto const* expType(exportTypes_[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 &&
+            funcName == std::string_view(name->data, name->size))
+        {
+            return wasm_externtype_as_functype_const(exnType);
+        }
+    }
+
+    throw std::runtime_error("can't find function <" + std::string(funcName) + ">");
+}
+
+// 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;
+// }
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// 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 == nullptr)
+    {
+        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);
+}
+
+int
+WasmiEngine::addModule(
+    Bytes const& wasmCode,
+    bool instantiate,
+    ImportVec const& imports,
+    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(), maxPages), &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 != nullptr)
+    {
+        // LCOV_EXCL_START
+        printWasmError("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());
+// }
+
+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 WasmTypes::WtI32:
+                v.push_back(WASM_I32_VAL(p.of.i32));
+                break;
+            // LCOV_EXCL_START
+            case WasmTypes::WtI64:
+                v.push_back(WASM_I64_VAL(p.of.i64));
+                break;
+            default:
+                throw std::runtime_error(
+                    "unknown parameter type: " + std::to_string(static_cast<int>(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::addParam(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::addParam(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)
+{
+    WasmiResult ret(NR);
+    wasm_val_vec_t const inv = in.empty() ? wasm_val_vec_t WASM_EMPTY_VEC
+                                          : wasm_val_vec_t{.size = in.size(), .data = in.data()};
+
+#ifdef SHOW_CALL_TIME
+    auto const start = usecs();
+#endif
+
+    wasm_trap_t* trap = wasm_func_call(f.first, &inv, ret.r.get());
+
+#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)
+    {
+        // Classify the trap into a TER by matching tokens as substrings of the
+        // message (see the trap-signal constants in WasmCommon.h for why).
+        std::string const msg = trapMessage(trap);
+        auto const has = [&msg](std::string_view token) { return msg.contains(token); };
+        if (has(hfErrInternal))
+        {
+            ret.ter = tecINTERNAL;
+        }
+        else if (has(hfErrOutOfGas) || has(wasmiTrapOutOfFuel))
+        {
+            ret.ter = tecOUT_OF_GAS;
+        }
+        else
+        {
+            ret.ter = tecFAILED_PROCESSING;
+        }
+        printWasmError("failure to call func", trap, j_);
+    }
+
+    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)
+{
+    addParam(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)
+{
+    addParam(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, 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.second.first.get())
+            Throw<std::runtime_error>("Imports hf unsync");
+    }
+}
+
+std::expected<WasmResult<int32_t>, WasmTER>
+WasmiEngine::run(
+    Bytes const& wasmCode,
+    HostFunctions& hfs,
+    int64_t gas,
+    std::string_view funcName,
+    std::vector<WasmParam> const& params,
+    ImportVec const& imports,
+    beast::Journal j)
+{
+    if (gas <= 0)
+        return std::unexpected(WasmTER{.ter = temBAD_AMOUNT, .cost = std::nullopt});
+
+    try
+    {
+        checkImports(imports, &hfs);
+        return runHlp(wasmCode, hfs, gas, funcName, params, imports, j);
+    }
+    catch (std::exception const& e)
+    {
+        printWasmError(std::string("exception: ") + e.what(), nullptr, j);
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+        printWasmError(std::string("exception: unknown"), nullptr, j);
+    }
+    // LCOV_EXCL_STOP
+    // An exception escaping the engine is an xrpld-side fault -> tecINTERNAL,
+    // no gas. Genuine wasm faults don't throw; they surface as traps in runHlp.
+    return std::unexpected(WasmTER{.ter = tecINTERNAL, .cost = std::nullopt});
+}
+
+std::expected<WasmResult<int32_t>, WasmTER>
+WasmiEngine::runHlp(
+    Bytes const& wasmCode,
+    HostFunctions& hfs,
+    int64_t gas,
+    std::string_view funcName,
+    std::vector<WasmParam> const& params,
+    ImportVec const& imports,
+    beast::Journal j)
+{
+    // currently only 1 module support, possible parallel UT run
+    std::scoped_lock const lg(m_);
+    j_ = j;
+
+    if (wasmCode.empty())
+        throw std::runtime_error("empty module");
+    if (!hfs.checkSelf())
+        throw std::runtime_error("hfs isn't clean");
+
+    // Create and instantiate the module.
+    [[maybe_unused]] int const m = addModule(wasmCode, true, imports, gas);
+
+    if (!moduleWrap_ || !moduleWrap_->getInstance())
+        throw std::runtime_error("no instance");  // LCOV_EXCL_LINE
+
+    auto clearRT = [](HostFunctions* p) { p->resetRT(); };
+    std::unique_ptr<HostFunctions, decltype(clearRT)> const clearGuard(&hfs, clearRT);
+    WasmiRuntimeWrapper iw(getRT());
+    hfs.setRT(iw);
+
+    // 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 (gas == -1)
+        gas = std::numeric_limits<decltype(gas)>::max();
+
+    if (res.ter.has_value())
+    {
+        // call() already classified the trap (see WasmiEngine::call).
+        // tecINTERNAL is an xrpld-side bug: report no gas.
+        if (*res.ter == tecINTERNAL)
+            return std::unexpected(WasmTER{.ter = tecINTERNAL, .cost = std::nullopt});
+
+        // Out-of-gas / wasm faults report gas (caller writes it to metadata).
+        // Force fuel to 0 on out-of-gas so cost is the full limit (wasmi leaves
+        // nonzero leftover fuel on its own out-of-fuel trap).
+        if (*res.ter == tecOUT_OF_GAS)
+            iw.setGas(0);
+
+        return std::unexpected(WasmTER{.ter = *res.ter, .cost = gas - moduleWrap_->getGas()});
+    }
+
+    if (res.r.empty())
+    {
+        Throw<std::runtime_error>(
+            "<" + std::string(funcName) + "> return nothing");  // LCOV_EXCL_LINE
+    }
+
+    if (res.r[0].kind != WASM_I32)
+    {
+        Throw<std::runtime_error>(
+            "<" + std::string(funcName) +
+            "> return type mismatch, ret: " + std::to_string(static_cast<int>(res.r[0].kind)));
+    }
+
+    WasmResult<int32_t> const ret{.result = res.r[0].of.i32, .cost = 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,
+    HostFunctions& hfs,
+    std::string_view funcName,
+    std::vector<WasmParam> const& params,
+    ImportVec const& imports,
+    beast::Journal j)
+{
+    try
+    {
+        checkImports(imports, &hfs);
+        return checkHlp(wasmCode, hfs, funcName, params, imports, j);
+    }
+    catch (std::exception const& e)
+    {
+        printWasmError(std::string("exception: ") + e.what(), nullptr, j);
+    }
+    // LCOV_EXCL_START
+    catch (...)
+    {
+        printWasmError(std::string("exception: unknown"), nullptr, j);
+    }
+    // LCOV_EXCL_STOP
+
+    return temINVALID_BYTECODE;
+}
+
+NotTEC
+WasmiEngine::checkHlp(
+    Bytes const& wasmCode,
+    HostFunctions& hfs,
+    std::string_view funcName,
+    std::vector<WasmParam> const& params,
+    ImportVec const& imports,
+    beast::Journal j)
+{
+    // currently only 1 module support, possible parallel UT run
+    std::scoped_lock const lg(m_);
+    j_ = j;
+
+    // Create and instantiate the module.
+    if (wasmCode.empty())
+        throw std::runtime_error("empty module");
+
+    int const m = addModule(wasmCode, false, imports, -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;
+}
+
+wasm_trap_t*
+WasmiEngine::newTrap(std::string const& txt)
+{
+    static char empty[1] = {0};
+    wasm_message_t msg = {.size = 1, .data = 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);  // NOLINT
+
+    if (!txt.empty())
+        wasm_byte_vec_delete(&msg);
+
+    return trap;
+}
+
+}  // namespace xrpl

src/test/app/AMM_test.cpp

@@ -6747,7 +6747,7 @@ private:
         using namespace test::jtx;
 
         auto const testCase = [&](std::string suffix, FeatureBitset features) {
-            testcase("Fail pseudo-account allocation " + suffix);
+            testcase("Pseudo-account allocation failure " + suffix);
             std::string logs;
             Env env{*this, features, std::make_unique<CaptureLogs>(&logs)};
             env.fund(XRP(30'000), gw_, alice_);

src/test/app/Escrow_test.cpp

@@ -1482,7 +1482,7 @@ struct Escrow_test : public beast::unit_test::Suite
         Account const alice{"alice"};
         Account const bob{"bob"};
         Account const carol{"carol"};
-        Account const dillon{"dillon "};
+        Account const dillon{"dillon"};
         Account const zelda{"zelda"};
 
         char const credType[] = "abcde";
@@ -1639,6 +1639,8 @@ public:
         FeatureBitset const all{testableAmendments()};
         testWithFeats(all);
         testWithFeats(all - featureTokenEscrow);
+        testWithFeats(all - featureSmartEscrow);
+        testWithFeats(all - featureTokenEscrow - featureSmartEscrow);
         testTags(all - fixIncludeKeyletFields);
     }
 };

src/test/app/FeeVote_test.cpp

@@ -11,6 +11,7 @@
 #include <xrpl/ledger/Ledger.h>
 #include <xrpl/ledger/OpenView.h>
 #include <xrpl/protocol/Feature.h>
+#include <xrpl/protocol/Fees.h>
 #include <xrpl/protocol/Indexes.h>
 #include <xrpl/protocol/KeyType.h>
 #include <xrpl/protocol/PublicKey.h>
@@ -31,7 +32,9 @@
 #include <limits>
 #include <memory>
 #include <optional>
+#include <source_location>
 #include <string>
+#include <utility>
 #include <vector>
 
 namespace xrpl::test {
@@ -45,10 +48,17 @@ struct FeeSettingsFields
     std::optional<XRPAmount> baseFeeDrops = std::nullopt;
     std::optional<XRPAmount> reserveBaseDrops = std::nullopt;
     std::optional<XRPAmount> reserveIncrementDrops = std::nullopt;
+    std::optional<std::uint32_t> gasLimit = std::nullopt;
+    std::optional<std::uint32_t> bytecodeSizeLimit = std::nullopt;
+    std::optional<std::uint32_t> gasPrice = std::nullopt;
 };
 
 STTx
-createFeeTx(Rules const& rules, std::uint32_t seq, FeeSettingsFields const& fields)
+createFeeTx(
+    Rules const& rules,
+    std::uint32_t seq,
+    FeeSettingsFields const& fields,
+    bool forceAllFields = false)
 {
     auto fill = [&](auto& obj) {
         obj.setAccountID(sfAccount, AccountID());
@@ -76,6 +86,13 @@ createFeeTx(Rules const& rules, std::uint32_t seq, FeeSettingsFields const& fiel
             obj.setFieldU32(
                 sfReferenceFeeUnits, fields.referenceFeeUnits ? *fields.referenceFeeUnits : 0);
         }
+        if (rules.enabled(featureSmartEscrow) || forceAllFields)
+        {
+            obj.setFieldU32(sfGasLimit, fields.gasLimit ? *fields.gasLimit : 0);
+            obj.setFieldU32(
+                sfBytecodeSizeLimit, fields.bytecodeSizeLimit ? *fields.bytecodeSizeLimit : 0);
+            obj.setFieldU32(sfGasPrice, fields.gasPrice ? *fields.gasPrice : 0);
+        }
     };
     return STTx(ttFEE, fill);
 }
@@ -124,6 +141,12 @@ createInvalidFeeTx(
                 obj.setFieldU32(sfReserveIncrement, 50000);
                 obj.setFieldU32(sfReferenceFeeUnits, 10);
             }
+            if (rules.enabled(featureSmartEscrow))
+            {
+                obj.setFieldU32(sfGasLimit, 100 + uniqueValue);
+                obj.setFieldU32(sfBytecodeSizeLimit, 200 + uniqueValue);
+                obj.setFieldU32(sfGasPrice, 300 + uniqueValue);
+            }
         }
         // If missingRequiredFields is true, we don't add the required fields
         // (default behavior)
@@ -131,11 +154,11 @@ createInvalidFeeTx(
     return STTx(ttFEE, fill);
 }
 
-bool
+TER
 applyFeeAndTestResult(jtx::Env& env, OpenView& view, STTx const& tx)
 {
     auto const res = apply(env.app(), view, tx, ApplyFlags::TapNone, env.journal);
-    return isTesSuccess(res.ter);
+    return res.ter;
 }
 
 bool
@@ -186,6 +209,21 @@ verifyFeeObject(
         if (!checkEquality(sfReferenceFeeUnits, expected.referenceFeeUnits))
             return false;
     }
+    if (rules.enabled(featureSmartEscrow))
+    {
+        if (!checkEquality(sfGasLimit, expected.gasLimit.value_or(0)))
+            return false;
+        if (!checkEquality(sfBytecodeSizeLimit, expected.bytecodeSizeLimit.value_or(0)))
+            return false;
+        if (!checkEquality(sfGasPrice, expected.gasPrice.value_or(0)))
+            return false;
+    }
+    else
+    {
+        if (feeObject->isFieldPresent(sfGasLimit) ||
+            feeObject->isFieldPresent(sfBytecodeSizeLimit) || feeObject->isFieldPresent(sfGasPrice))
+            return false;
+    }
 
     return true;
 }
@@ -208,6 +246,7 @@ class FeeVote_test : public beast::unit_test::Suite
     void
     testSetup()
     {
+        testcase("FeeVote setup");
         FeeSetup const defaultSetup;
         {
             // defaults
@@ -216,35 +255,63 @@ class FeeVote_test : public beast::unit_test::Suite
             BEAST_EXPECT(setup.referenceFee == defaultSetup.referenceFee);
             BEAST_EXPECT(setup.accountReserve == defaultSetup.accountReserve);
             BEAST_EXPECT(setup.ownerReserve == defaultSetup.ownerReserve);
+            BEAST_EXPECT(setup.gasLimit == defaultSetup.gasLimit);
+            BEAST_EXPECT(setup.bytecodeSizeLimit == defaultSetup.bytecodeSizeLimit);
+            BEAST_EXPECT(setup.gasPrice == defaultSetup.gasPrice);
         }
         {
             Section config;
             config.append(
-                {"reference_fee = 50", "account_reserve = 1234567", "owner_reserve = 1234"});
+                {"reference_fee = 50",
+                 "account_reserve = 1234567",
+                 "owner_reserve = 1234",
+                 "gas_limit = 100",
+                 "bytecode_size_limit = 200",
+                 "gas_price = 300"});
             auto setup = setupFeeVote(config);
             BEAST_EXPECT(setup.referenceFee == 50);
             BEAST_EXPECT(setup.accountReserve == 1234567);
             BEAST_EXPECT(setup.ownerReserve == 1234);
+            BEAST_EXPECT(setup.gasLimit == 100);
+            BEAST_EXPECT(setup.bytecodeSizeLimit == 200);
+            BEAST_EXPECT(setup.gasPrice == 300);
         }
         {
             Section config;
             config.append(
-                {"reference_fee = blah", "account_reserve = yada", "owner_reserve = foo"});
+                {"reference_fee = blah",
+                 "account_reserve = yada",
+                 "owner_reserve = foo",
+                 "gas_limit = bar",
+                 "bytecode_size_limit = baz",
+                 "gas_price = qux"});
             // Illegal values are ignored, and the defaults left unchanged
             auto setup = setupFeeVote(config);
             BEAST_EXPECT(setup.referenceFee == defaultSetup.referenceFee);
             BEAST_EXPECT(setup.accountReserve == defaultSetup.accountReserve);
             BEAST_EXPECT(setup.ownerReserve == defaultSetup.ownerReserve);
+            BEAST_EXPECT(setup.gasLimit == defaultSetup.gasLimit);
+            BEAST_EXPECT(setup.bytecodeSizeLimit == defaultSetup.bytecodeSizeLimit);
+            BEAST_EXPECT(setup.gasPrice == defaultSetup.gasPrice);
         }
         {
             Section config;
             config.append(
-                {"reference_fee = -50", "account_reserve = -1234567", "owner_reserve = -1234"});
-            // Illegal values are ignored, and the defaults left unchanged
+                {"reference_fee = -50",
+                 "account_reserve = -1234567",
+                 "owner_reserve = -1234",
+                 "gas_limit = -100",
+                 "bytecode_size_limit = -200",
+                 "gas_price = -300"});
+            // Negative gas/bytecode limit values wrap past their maximum and are
+            // ignored. Other uint32_t fields keep the existing behavior.
             auto setup = setupFeeVote(config);
             BEAST_EXPECT(setup.referenceFee == defaultSetup.referenceFee);
             BEAST_EXPECT(setup.accountReserve == static_cast<std::uint32_t>(-1234567));
             BEAST_EXPECT(setup.ownerReserve == static_cast<std::uint32_t>(-1234));
+            BEAST_EXPECT(setup.gasLimit == defaultSetup.gasLimit);
+            BEAST_EXPECT(setup.bytecodeSizeLimit == defaultSetup.bytecodeSizeLimit);
+            BEAST_EXPECT(setup.gasPrice == static_cast<std::uint32_t>(-300));
         }
         {
             auto const big64 = std::to_string(
@@ -253,12 +320,36 @@ class FeeVote_test : public beast::unit_test::Suite
             config.append(
                 {"reference_fee = " + big64,
                  "account_reserve = " + big64,
-                 "owner_reserve = " + big64});
+                 "owner_reserve = " + big64,
+                 "gas_limit = " + big64,
+                 "bytecode_size_limit = " + big64,
+                 "gas_price = " + big64});
             // Illegal values are ignored, and the defaults left unchanged
             auto setup = setupFeeVote(config);
             BEAST_EXPECT(setup.referenceFee == defaultSetup.referenceFee);
             BEAST_EXPECT(setup.accountReserve == defaultSetup.accountReserve);
             BEAST_EXPECT(setup.ownerReserve == defaultSetup.ownerReserve);
+            BEAST_EXPECT(setup.gasLimit == defaultSetup.gasLimit);
+            BEAST_EXPECT(setup.bytecodeSizeLimit == defaultSetup.bytecodeSizeLimit);
+            BEAST_EXPECT(setup.gasPrice == defaultSetup.gasPrice);
+        }
+        {
+            Section config;
+            config.append(
+                {"gas_limit = " + std::to_string(kMaxGasLimit + 1),
+                 "bytecode_size_limit = " + std::to_string(kMaxBytecodeSizeLimit + 1)});
+            auto const setup = setupFeeVote(config);
+            BEAST_EXPECT(setup.gasLimit == defaultSetup.gasLimit);
+            BEAST_EXPECT(setup.bytecodeSizeLimit == defaultSetup.bytecodeSizeLimit);
+        }
+        {
+            Section config;
+            config.append(
+                {"gas_limit = " + std::to_string(kMaxGasLimit),
+                 "bytecode_size_limit = " + std::to_string(kMaxBytecodeSizeLimit)});
+            auto const setup = setupFeeVote(config);
+            BEAST_EXPECT(setup.gasLimit == kMaxGasLimit);
+            BEAST_EXPECT(setup.bytecodeSizeLimit == kMaxBytecodeSizeLimit);
         }
     }
 
@@ -269,7 +360,7 @@ class FeeVote_test : public beast::unit_test::Suite
 
         // Test with XRPFees disabled (legacy format)
         {
-            jtx::Env env(*this, jtx::testableAmendments() - featureXRPFees);
+            jtx::Env env(*this, jtx::testableAmendments() - featureXRPFees - featureSmartEscrow);
             auto ledger = std::make_shared<Ledger>(
                 kCreateGenesis,
                 Rules{env.app().config().features},
@@ -290,7 +381,7 @@ class FeeVote_test : public beast::unit_test::Suite
             auto feeTx = createFeeTx(ledger->rules(), ledger->seq(), fields);
 
             OpenView accum(ledger.get());
-            BEAST_EXPECT(applyFeeAndTestResult(env, accum, feeTx));
+            BEAST_EXPECT(isTesSuccess(applyFeeAndTestResult(env, accum, feeTx)));
             accum.apply(*ledger);
 
             // Verify fee object was created/updated correctly
@@ -299,7 +390,7 @@ class FeeVote_test : public beast::unit_test::Suite
 
         // Test with XRPFees enabled (new format)
         {
-            jtx::Env env(*this, jtx::testableAmendments() | featureXRPFees);
+            jtx::Env env(*this, jtx::testableAmendments() - featureSmartEscrow);
             auto ledger = std::make_shared<Ledger>(
                 kCreateGenesis,
                 Rules{env.app().config().features},
@@ -318,12 +409,105 @@ class FeeVote_test : public beast::unit_test::Suite
             auto feeTx = createFeeTx(ledger->rules(), ledger->seq(), fields);
 
             OpenView accum(ledger.get());
-            BEAST_EXPECT(applyFeeAndTestResult(env, accum, feeTx));
+            BEAST_EXPECT(isTesSuccess(applyFeeAndTestResult(env, accum, feeTx)));
             accum.apply(*ledger);
 
             // Verify fee object was created/updated correctly
             BEAST_EXPECT(verifyFeeObject(ledger, ledger->rules(), fields));
         }
+
+        // Test with both XRPFees and SmartEscrow enabled
+        {
+            jtx::Env env(*this, jtx::testableAmendments());
+            auto ledger = std::make_shared<Ledger>(
+                kCreateGenesis,
+                Rules{env.app().config().features},
+                env.app().config().fees.toFees(),
+                std::vector<uint256>{},
+                env.app().getNodeFamily());
+
+            // Create the next ledger to apply transaction to
+            ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
+
+            FeeSettingsFields const fields{
+                .baseFeeDrops = XRPAmount{10},
+                .reserveBaseDrops = XRPAmount{200000},
+                .reserveIncrementDrops = XRPAmount{50000},
+                .gasLimit = 100,
+                .bytecodeSizeLimit = 200,
+                .gasPrice = 300};
+            // Test successful fee transaction with new fields
+            auto feeTx = createFeeTx(ledger->rules(), ledger->seq(), fields);
+
+            OpenView accum(ledger.get());
+            BEAST_EXPECT(isTesSuccess(applyFeeAndTestResult(env, accum, feeTx)));
+            accum.apply(*ledger);
+
+            // Verify fee object was created/updated correctly
+            BEAST_EXPECT(verifyFeeObject(ledger, ledger->rules(), fields));
+        }
+
+        // Test that Smart Escrow limits reject values above their maximums.
+        {
+            jtx::Env env(*this, jtx::testableAmendments());
+            auto ledger = std::make_shared<Ledger>(
+                kCreateGenesis,
+                Rules{env.app().config().features},
+                env.app().config().fees.toFees(),
+                std::vector<uint256>{},
+                env.app().getNodeFamily());
+
+            ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
+
+            auto testBadFields = [&](FeeSettingsFields const& fields) {
+                auto feeTx = createFeeTx(ledger->rules(), ledger->seq(), fields);
+                OpenView accum(ledger.get());
+                BEAST_EXPECT(!isTesSuccess(applyFeeAndTestResult(env, accum, feeTx)));
+            };
+
+            testBadFields(
+                {.baseFeeDrops = XRPAmount{10},
+                 .reserveBaseDrops = XRPAmount{200000},
+                 .reserveIncrementDrops = XRPAmount{50000},
+                 .gasLimit = kMaxGasLimit + 1,
+                 .bytecodeSizeLimit = kMaxBytecodeSizeLimit,
+                 .gasPrice = 300});
+            testBadFields(
+                {.baseFeeDrops = XRPAmount{10},
+                 .reserveBaseDrops = XRPAmount{200000},
+                 .reserveIncrementDrops = XRPAmount{50000},
+                 .gasLimit = kMaxGasLimit,
+                 .bytecodeSizeLimit = kMaxBytecodeSizeLimit + 1,
+                 .gasPrice = 300});
+        }
+
+        // Test that the Smart Escrow fields are rejected if the
+        // feature is disabled
+        {
+            jtx::Env env(*this, jtx::testableAmendments() - featureSmartEscrow);
+            auto ledger = std::make_shared<Ledger>(
+                kCreateGenesis,
+                Rules{env.app().config().features},
+                env.app().config().fees.toFees(),
+                std::vector<uint256>{},
+                env.app().getNodeFamily());
+
+            // Create the next ledger to apply transaction to
+            ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
+
+            FeeSettingsFields const fields{
+                .baseFeeDrops = XRPAmount{10},
+                .reserveBaseDrops = XRPAmount{200000},
+                .reserveIncrementDrops = XRPAmount{50000},
+                .gasLimit = 100,
+                .bytecodeSizeLimit = 200,
+                .gasPrice = 300};
+            // Test successful fee transaction with new fields
+            auto feeTx = createFeeTx(ledger->rules(), ledger->seq(), fields, true);
+
+            OpenView accum(ledger.get());
+            BEAST_EXPECT(!isTesSuccess(applyFeeAndTestResult(env, accum, feeTx)));
+        }
     }
 
     void
@@ -332,7 +516,7 @@ class FeeVote_test : public beast::unit_test::Suite
         testcase("Fee Transaction Validation");
 
         {
-            jtx::Env env(*this, jtx::testableAmendments() - featureXRPFees);
+            jtx::Env env(*this, jtx::testableAmendments() - featureXRPFees - featureSmartEscrow);
             auto ledger = std::make_shared<Ledger>(
                 kCreateGenesis,
                 Rules{env.app().config().features},
@@ -346,15 +530,15 @@ class FeeVote_test : public beast::unit_test::Suite
             // Test transaction with missing required legacy fields
             auto invalidTx = createInvalidFeeTx(ledger->rules(), ledger->seq(), true, false, 1);
             OpenView accum(ledger.get());
-            BEAST_EXPECT(!applyFeeAndTestResult(env, accum, invalidTx));
+            BEAST_EXPECT(!isTesSuccess(applyFeeAndTestResult(env, accum, invalidTx)));
 
             // Test transaction with new format fields when XRPFees is disabled
             auto disallowedTx = createInvalidFeeTx(ledger->rules(), ledger->seq(), false, true, 2);
-            BEAST_EXPECT(!applyFeeAndTestResult(env, accum, disallowedTx));
+            BEAST_EXPECT(!isTesSuccess(applyFeeAndTestResult(env, accum, disallowedTx)));
         }
 
         {
-            jtx::Env env(*this, jtx::testableAmendments() | featureXRPFees);
+            jtx::Env env(*this, jtx::testableAmendments() - featureSmartEscrow);
             auto ledger = std::make_shared<Ledger>(
                 kCreateGenesis,
                 Rules{env.app().config().features},
@@ -368,11 +552,33 @@ class FeeVote_test : public beast::unit_test::Suite
             // Test transaction with missing required new fields
             auto invalidTx = createInvalidFeeTx(ledger->rules(), ledger->seq(), true, false, 3);
             OpenView accum(ledger.get());
-            BEAST_EXPECT(!applyFeeAndTestResult(env, accum, invalidTx));
+            BEAST_EXPECT(!isTesSuccess(applyFeeAndTestResult(env, accum, invalidTx)));
 
             // Test transaction with legacy fields when XRPFees is enabled
             auto disallowedTx = createInvalidFeeTx(ledger->rules(), ledger->seq(), false, true, 4);
-            BEAST_EXPECT(!applyFeeAndTestResult(env, accum, disallowedTx));
+            BEAST_EXPECT(!isTesSuccess(applyFeeAndTestResult(env, accum, disallowedTx)));
+        }
+
+        {
+            jtx::Env env(*this, jtx::testableAmendments() | featureXRPFees | featureSmartEscrow);
+            auto ledger = std::make_shared<Ledger>(
+                kCreateGenesis,
+                Rules{env.app().config().features},
+                env.app().config().fees.toFees(),
+                std::vector<uint256>{},
+                env.app().getNodeFamily());
+
+            // Create the next ledger to apply transaction to
+            ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
+
+            // Test transaction with missing required new fields
+            auto invalidTx = createInvalidFeeTx(ledger->rules(), ledger->seq(), true, false, 5);
+            OpenView accum(ledger.get());
+            BEAST_EXPECT(!isTesSuccess(applyFeeAndTestResult(env, accum, invalidTx)));
+
+            // Test transaction with legacy fields when XRPFees is enabled
+            auto disallowedTx = createInvalidFeeTx(ledger->rules(), ledger->seq(), false, true, 6);
+            BEAST_EXPECT(!isTesSuccess(applyFeeAndTestResult(env, accum, disallowedTx)));
         }
     }
 
@@ -381,7 +587,7 @@ class FeeVote_test : public beast::unit_test::Suite
     {
         testcase("Pseudo Transaction Properties");
 
-        jtx::Env env(*this, jtx::testableAmendments());
+        jtx::Env env(*this, jtx::testableAmendments() - featureSmartEscrow);
         auto ledger = std::make_shared<Ledger>(
             kCreateGenesis,
             Rules{env.app().config().features},
@@ -411,7 +617,7 @@ class FeeVote_test : public beast::unit_test::Suite
         // But can be applied to a closed ledger
         {
             OpenView closedAccum(ledger.get());
-            BEAST_EXPECT(applyFeeAndTestResult(env, closedAccum, feeTx));
+            BEAST_EXPECT(isTesSuccess(applyFeeAndTestResult(env, closedAccum, feeTx)));
         }
     }
 
@@ -420,7 +626,7 @@ class FeeVote_test : public beast::unit_test::Suite
     {
         testcase("Multiple Fee Updates");
 
-        jtx::Env env(*this, jtx::testableAmendments() | featureXRPFees);
+        jtx::Env env(*this, jtx::testableAmendments() - featureSmartEscrow);
         auto ledger = std::make_shared<Ledger>(
             kCreateGenesis,
             Rules{env.app().config().features},
@@ -438,7 +644,7 @@ class FeeVote_test : public beast::unit_test::Suite
 
         {
             OpenView accum(ledger.get());
-            BEAST_EXPECT(applyFeeAndTestResult(env, accum, feeTx1));
+            BEAST_EXPECT(isTesSuccess(applyFeeAndTestResult(env, accum, feeTx1)));
             accum.apply(*ledger);
         }
 
@@ -455,7 +661,7 @@ class FeeVote_test : public beast::unit_test::Suite
 
         {
             OpenView accum(ledger.get());
-            BEAST_EXPECT(applyFeeAndTestResult(env, accum, feeTx2));
+            BEAST_EXPECT(isTesSuccess(applyFeeAndTestResult(env, accum, feeTx2)));
             accum.apply(*ledger);
         }
 
@@ -468,7 +674,7 @@ class FeeVote_test : public beast::unit_test::Suite
     {
         testcase("Wrong Ledger Sequence");
 
-        jtx::Env env(*this, jtx::testableAmendments() | featureXRPFees);
+        jtx::Env env(*this, jtx::testableAmendments() - featureSmartEscrow);
         auto ledger = std::make_shared<Ledger>(
             kCreateGenesis,
             Rules{env.app().config().features},
@@ -491,7 +697,7 @@ class FeeVote_test : public beast::unit_test::Suite
         // The transaction should still succeed as long as other fields are
         // valid
         // The ledger sequence field is only used for informational purposes
-        BEAST_EXPECT(applyFeeAndTestResult(env, accum, feeTx));
+        BEAST_EXPECT(isTesSuccess(applyFeeAndTestResult(env, accum, feeTx)));
     }
 
     void
@@ -499,7 +705,7 @@ class FeeVote_test : public beast::unit_test::Suite
     {
         testcase("Partial Field Updates");
 
-        jtx::Env env(*this, jtx::testableAmendments() | featureXRPFees);
+        jtx::Env env(*this, jtx::testableAmendments() - featureSmartEscrow);
         auto ledger = std::make_shared<Ledger>(
             kCreateGenesis,
             Rules{env.app().config().features},
@@ -517,7 +723,7 @@ class FeeVote_test : public beast::unit_test::Suite
 
         {
             OpenView accum(ledger.get());
-            BEAST_EXPECT(applyFeeAndTestResult(env, accum, feeTx1));
+            BEAST_EXPECT(isTesSuccess(applyFeeAndTestResult(env, accum, feeTx1)));
             accum.apply(*ledger);
         }
 
@@ -532,7 +738,7 @@ class FeeVote_test : public beast::unit_test::Suite
 
         {
             OpenView accum(ledger.get());
-            BEAST_EXPECT(applyFeeAndTestResult(env, accum, feeTx2));
+            BEAST_EXPECT(isTesSuccess(applyFeeAndTestResult(env, accum, feeTx2)));
             accum.apply(*ledger);
         }
 
@@ -545,7 +751,7 @@ class FeeVote_test : public beast::unit_test::Suite
     {
         testcase("Single Invalid Transaction");
 
-        jtx::Env env(*this, jtx::testableAmendments() | featureXRPFees);
+        jtx::Env env(*this, jtx::testableAmendments() - featureSmartEscrow);
         auto ledger = std::make_shared<Ledger>(
             kCreateGenesis,
             Rules{env.app().config().features},
@@ -567,7 +773,7 @@ class FeeVote_test : public beast::unit_test::Suite
         });
 
         OpenView accum(ledger.get());
-        BEAST_EXPECT(!applyFeeAndTestResult(env, accum, invalidTx));
+        BEAST_EXPECT(!isTesSuccess(applyFeeAndTestResult(env, accum, invalidTx)));
     }
 
     void
@@ -584,7 +790,7 @@ class FeeVote_test : public beast::unit_test::Suite
 
         // Test with XRPFees enabled
         {
-            Env env(*this, testableAmendments() | featureXRPFees);
+            Env env(*this, testableAmendments() - featureSmartEscrow);
             auto feeVote = makeFeeVote(setup, env.app().getJournal("FeeVote"));
 
             auto ledger = std::make_shared<Ledger>(
@@ -614,7 +820,7 @@ class FeeVote_test : public beast::unit_test::Suite
 
         // Test with XRPFees disabled (legacy format)
         {
-            Env env(*this, testableAmendments() - featureXRPFees);
+            Env env(*this, testableAmendments() - featureXRPFees - featureSmartEscrow);
             auto feeVote = makeFeeVote(setup, env.app().getJournal("FeeVote"));
 
             auto ledger = std::make_shared<Ledger>(
@@ -654,7 +860,7 @@ class FeeVote_test : public beast::unit_test::Suite
         setup.accountReserve = 1234567;
         setup.ownerReserve = 7654321;
 
-        Env env(*this, testableAmendments() | featureXRPFees);
+        Env env(*this, testableAmendments() - featureSmartEscrow);
 
         // establish what the current fees are
         BEAST_EXPECT(env.current()->fees().base == XRPAmount{UNIT_TEST_REFERENCE_FEE});
@@ -729,6 +935,156 @@ class FeeVote_test : public beast::unit_test::Suite
             feeTx.getFieldAmount(sfReserveIncrementDrops) == XRPAmount{setup.ownerReserve});
     }
 
+    void
+    testDoVotingSmartEscrow()
+    {
+        testcase("doVoting with Smart Escrow");
+
+        using namespace jtx;
+
+        Env env(*this, testableAmendments() | featureXRPFees | featureSmartEscrow);
+
+        // establish what the current fees are
+        BEAST_EXPECT(env.current()->fees().base == XRPAmount{UNIT_TEST_REFERENCE_FEE});
+        BEAST_EXPECT(env.current()->fees().reserve == XRPAmount{200'000'000});
+        BEAST_EXPECT(env.current()->fees().increment == XRPAmount{50'000'000});
+        BEAST_EXPECT(env.current()->fees().gasLimit == 0);
+        BEAST_EXPECT(env.current()->fees().bytecodeSizeLimit == 0);
+        BEAST_EXPECT(env.current()->fees().gasPrice == 0);
+
+        auto const createFeeTxFromVoting =
+            [&](FeeSetup const& setup) -> std::pair<STTx, std::shared_ptr<Ledger>> {
+            auto feeVote = makeFeeVote(setup, env.app().getJournal("FeeVote"));
+            auto ledger = std::make_shared<Ledger>(
+                kCreateGenesis,
+                Rules{env.app().config().features},
+                env.app().config().fees.toFees(),
+                std::vector<uint256>{},
+                env.app().getNodeFamily());
+
+            // doVoting requires a flag ledger (every 256th ledger)
+            // We need to create a ledger at sequence 256 to make it a flag
+            // ledger
+            for (int i = 0; i < 256 - 1; ++i)
+            {
+                ledger = std::make_shared<Ledger>(*ledger, env.app().getTimeKeeper().closeTime());
+            }
+            BEAST_EXPECT(ledger->isFlagLedger());
+
+            // Create some mock validations with fee votes
+            std::vector<std::shared_ptr<STValidation>> validations;
+
+            for (int i = 0; i < 5; i++)
+            {
+                auto sec = randomSecretKey();
+                auto pub = derivePublicKey(KeyType::Secp256k1, sec);
+
+                auto val = std::make_shared<STValidation>(
+                    env.app().getTimeKeeper().now(),
+                    pub,
+                    sec,
+                    calcNodeID(pub),
+                    [&](STValidation& v) {
+                        v.setFieldU32(sfLedgerSequence, ledger->seq());
+                        // Vote for different fees than current
+                        v.setFieldAmount(sfBaseFeeDrops, XRPAmount{setup.referenceFee});
+                        v.setFieldAmount(sfReserveBaseDrops, XRPAmount{setup.accountReserve});
+                        v.setFieldAmount(sfReserveIncrementDrops, XRPAmount{setup.ownerReserve});
+                        v.setFieldU32(sfGasLimit, setup.gasLimit);
+                        v.setFieldU32(sfBytecodeSizeLimit, setup.bytecodeSizeLimit);
+                        v.setFieldU32(sfGasPrice, setup.gasPrice);
+                    });
+                if (i % 2)
+                    val->setTrusted();
+                validations.push_back(val);
+            }
+
+            auto txSet =
+                std::make_shared<SHAMap>(SHAMapType::TRANSACTION, env.app().getNodeFamily());
+
+            // This should not throw since we have a flag ledger
+            feeVote->doVoting(ledger, validations, txSet);
+
+            auto const txs = getTxs(txSet);
+            BEAST_EXPECT(txs.size() == 1);
+            return {txs[0], ledger};
+        };
+
+        auto checkFeeTx = [&](FeeSetup const& setup,
+                              STTx const& feeTx,
+                              std::shared_ptr<Ledger> const& ledger,
+                              std::source_location const loc = std::source_location::current()) {
+            auto const line = " (" + std::to_string(loc.line()) + ")";
+            BEAST_EXPECTS(feeTx.getTxnType() == ttFEE, line);
+
+            BEAST_EXPECTS(feeTx.getAccountID(sfAccount) == AccountID(), line);
+            BEAST_EXPECTS(feeTx.getFieldU32(sfLedgerSequence) == ledger->seq() + 1, line);
+
+            BEAST_EXPECTS(feeTx.isFieldPresent(sfBaseFeeDrops), line);
+            BEAST_EXPECTS(feeTx.isFieldPresent(sfReserveBaseDrops), line);
+            BEAST_EXPECTS(feeTx.isFieldPresent(sfReserveIncrementDrops), line);
+
+            // The legacy fields should NOT be present
+            BEAST_EXPECTS(!feeTx.isFieldPresent(sfBaseFee), line);
+            BEAST_EXPECTS(!feeTx.isFieldPresent(sfReserveBase), line);
+            BEAST_EXPECTS(!feeTx.isFieldPresent(sfReserveIncrement), line);
+            BEAST_EXPECTS(!feeTx.isFieldPresent(sfReferenceFeeUnits), line);
+
+            // Check the values
+            BEAST_EXPECTS(
+                feeTx.getFieldAmount(sfBaseFeeDrops) == XRPAmount{setup.referenceFee}, line);
+            BEAST_EXPECTS(
+                feeTx.getFieldAmount(sfReserveBaseDrops) == XRPAmount{setup.accountReserve}, line);
+            BEAST_EXPECTS(
+                feeTx.getFieldAmount(sfReserveIncrementDrops) == XRPAmount{setup.ownerReserve},
+                line);
+            BEAST_EXPECTS(feeTx.getFieldU32(sfGasLimit) == setup.gasLimit, line);
+            BEAST_EXPECTS(feeTx.getFieldU32(sfBytecodeSizeLimit) == setup.bytecodeSizeLimit, line);
+            BEAST_EXPECTS(feeTx.getFieldU32(sfGasPrice) == setup.gasPrice, line);
+        };
+
+        {
+            FeeSetup setup;
+            setup.referenceFee = 42;
+            setup.accountReserve = 1234567;
+            setup.ownerReserve = 7654321;
+            setup.gasLimit = 100;
+            setup.bytecodeSizeLimit = 200;
+            setup.gasPrice = 300;
+            auto const [feeTx, ledger] = createFeeTxFromVoting(setup);
+
+            checkFeeTx(setup, feeTx, ledger);
+        }
+
+        {
+            FeeSetup setup;
+            setup.referenceFee = 42;
+            setup.accountReserve = 1234567;
+            setup.ownerReserve = 7654321;
+            setup.gasLimit = 0;
+            setup.bytecodeSizeLimit = 0;
+            setup.gasPrice = 300;
+            auto const [feeTx, ledger] = createFeeTxFromVoting(setup);
+
+            checkFeeTx(setup, feeTx, ledger);
+        }
+
+        {
+            FeeSetup setup;
+            setup.referenceFee = 42;
+            setup.accountReserve = 1234567;
+            setup.ownerReserve = 7654321;
+            setup.gasLimit = kMaxGasLimit + 1;
+            setup.bytecodeSizeLimit = kMaxBytecodeSizeLimit + 1;
+            setup.gasPrice = 300;
+            auto const [feeTx, ledger] = createFeeTxFromVoting(setup);
+
+            setup.gasLimit = ledger->fees().gasLimit;
+            setup.bytecodeSizeLimit = ledger->fees().bytecodeSizeLimit;
+            checkFeeTx(setup, feeTx, ledger);
+        }
+    }
+
     void
     run() override
     {
@@ -742,6 +1098,7 @@ class FeeVote_test : public beast::unit_test::Suite
         testSingleInvalidTransaction();
         testDoValidation();
         testDoVoting();
+        testDoVotingSmartEscrow();
     }
 };
 

src/test/app/PseudoTx_test.cpp

@@ -43,6 +43,12 @@ struct PseudoTx_test : public beast::unit_test::Suite
                 obj[sfReserveIncrement] = 0;
                 obj[sfReferenceFeeUnits] = 0;
             }
+            if (rules.enabled(featureSmartEscrow))
+            {
+                obj[sfGasLimit] = 0;
+                obj[sfBytecodeSizeLimit] = 0;
+                obj[sfGasPrice] = 0;
+            }
         });
 
         res.emplace_back(ttAMENDMENT, [&](auto& obj) {
@@ -107,7 +113,9 @@ struct PseudoTx_test : public beast::unit_test::Suite
         FeatureBitset const all{testableAmendments()};
         FeatureBitset const xrpFees{featureXRPFees};
 
+        testPrevented(all - featureXRPFees - featureSmartEscrow);
         testPrevented(all - featureXRPFees);
+        testPrevented(all - featureSmartEscrow);
         testPrevented(all);
         testAllowed();
     }

src/test/app/TestHostFunctions.h

@@ -0,0 +1,492 @@
+#pragma once
+
+#include <test/jtx/Env.h>
+#include <test/unit_test/SuiteJournal.h>
+
+#include <xrpl/basics/Slice.h>
+#include <xrpl/basics/base_uint.h>
+#include <xrpl/beast/utility/Journal.h>
+#include <xrpl/ledger/detail/ApplyViewBase.h>
+#include <xrpl/protocol/AccountID.h>
+#include <xrpl/protocol/Asset.h>
+#include <xrpl/protocol/Indexes.h>
+#include <xrpl/protocol/MPTIssue.h>
+#include <xrpl/protocol/Protocol.h>
+#include <xrpl/protocol/SField.h>
+#include <xrpl/protocol/STAmount.h>
+#include <xrpl/protocol/SeqProxy.h>
+#include <xrpl/tx/wasm/HostFunc.h>
+#include <xrpl/tx/wasm/WasmCommon.h>
+
+#include <cstdint>
+#include <expected>
+#include <string>
+#include <string_view>
+
+namespace xrpl::test {
+
+class TestLedgerDataProvider : public HostFunctions
+{
+    jtx::Env& env_;
+
+public:
+    TestLedgerDataProvider(jtx::Env& env) : HostFunctions(env.journal), env_(env)
+    {
+    }
+
+    [[nodiscard]] std::expected<std::uint32_t, HostFunctionError>
+    getLedgerSqn() const override
+    {
+        return env_.current()->seq();
+    }
+};
+
+class TestHostFunctions : public HostFunctions
+{
+protected:
+    test::jtx::Env& env_;
+    AccountID accountID_;
+    Bytes data_;
+
+public:
+    TestHostFunctions(test::jtx::Env& env) : HostFunctions(env.journal), env_(env)
+    {
+        accountID_ = env.master.id();
+        std::string t = "10000";
+        data_ = Bytes{t.begin(), t.end()};
+    }
+
+    [[nodiscard]] std::expected<std::uint32_t, HostFunctionError>
+    getLedgerSqn() const override
+    {
+        return 12345;
+    }
+
+    [[nodiscard]] std::expected<std::uint32_t, HostFunctionError>
+    getParentLedgerTime() const override
+    {
+        return 67890;
+    }
+
+    [[nodiscard]] std::expected<Hash, HostFunctionError>
+    getParentLedgerHash() const override
+    {
+        return env_.current()->header().parentHash;
+    }
+
+    [[nodiscard]] std::expected<std::uint32_t, HostFunctionError>
+    getBaseFee() const override
+    {
+        return 10;
+    }
+
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
+    isAmendmentEnabled(uint256 const& amendmentId) const override
+    {
+        return 1;
+    }
+
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
+    isAmendmentEnabled(std::string_view const& amendmentName) const override
+    {
+        return 1;
+    }
+
+    std::expected<int32_t, HostFunctionError>
+    cacheLedgerObj(uint256 const& objId, int32_t cacheIdx) override
+    {
+        return 1;
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    getTxField(SField const& fname) const override
+    {
+        if (fname == sfAccount)
+            return Bytes(accountID_.begin(), accountID_.end());
+
+        if (fname == sfFee)
+        {
+            int64_t x = 235;
+            auto const* p = reinterpret_cast<uint8_t const*>(&x);
+            return Bytes{p, p + sizeof(x)};
+        }
+
+        if (fname == sfSequence)
+        {
+            auto const x = getLedgerSqn();
+            if (!x)
+                return std::unexpected(x.error());
+            std::uint32_t const data = x.value();
+            auto const* b = reinterpret_cast<uint8_t const*>(&data);
+            auto const* e = reinterpret_cast<uint8_t const*>(&data + 1);
+            return Bytes{b, e};
+        }
+
+        return Bytes();
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    getCurrentLedgerObjField(SField const& fname) const override
+    {
+        auto const& sn = fname.getName();
+        if (sn == "Destination" || sn == "Account")
+            return Bytes(accountID_.begin(), accountID_.end());
+        if (sn == "Data")
+            return data_;
+        if (sn == "FinishAfter")
+        {
+            auto t = env_.current()->parentCloseTime().time_since_epoch().count();
+            std::string s = std::to_string(t);
+            return Bytes{s.begin(), s.end()};
+        }
+
+        return std::unexpected(HostFunctionError::Unimplemented);
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    getLedgerObjField(int32_t, SField const& fname) const override
+    {
+        if (fname == sfBalance)
+        {
+            int64_t x = 10'000;
+            auto const* p = reinterpret_cast<uint8_t const*>(&x);
+            return Bytes{p, p + sizeof(x)};
+        }
+
+        if (fname == sfAccount)
+            return Bytes(accountID_.begin(), accountID_.end());
+
+        return data_;
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    getTxNestedField(FieldLocator const& locator) const override
+    {
+        if (locator.size() == 1)
+        {
+            int32_t const* l = locator.data();
+            int32_t const sfield = l[0];
+            if (sfield == sfAccount.getCode())
+                return Bytes(accountID_.begin(), accountID_.end());
+        }
+
+        uint8_t const a[] = {0x2b, 0x6a, 0x23, 0x2a, 0xa4, 0xc4, 0xbe, 0x41, 0xbf, 0x49, 0xd2,
+                             0x45, 0x9f, 0xa4, 0xa0, 0x34, 0x7e, 0x1b, 0x54, 0x3a, 0x4c, 0x92,
+                             0xfc, 0xee, 0x08, 0x21, 0xc0, 0x20, 0x1e, 0x2e, 0x9a, 0x00};
+        return Bytes(&a[0], &a[sizeof(a)]);
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    getCurrentLedgerObjNestedField(FieldLocator const& locator) const override
+    {
+        if (locator.size() == 1)
+        {
+            int32_t const* l = locator.data();
+            int32_t const sfield = l[0];
+            if (sfield == sfAccount.getCode())
+                return Bytes(accountID_.begin(), accountID_.end());
+        }
+
+        uint8_t const a[] = {0x2b, 0x6a, 0x23, 0x2a, 0xa4, 0xc4, 0xbe, 0x41, 0xbf, 0x49, 0xd2,
+                             0x45, 0x9f, 0xa4, 0xa0, 0x34, 0x7e, 0x1b, 0x54, 0x3a, 0x4c, 0x92,
+                             0xfc, 0xee, 0x08, 0x21, 0xc0, 0x20, 0x1e, 0x2e, 0x9a, 0x00};
+        return Bytes(&a[0], &a[sizeof(a)]);
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    getLedgerObjNestedField(int32_t cacheIdx, FieldLocator const& locator) const override
+    {
+        if (locator.size() == 1)
+        {
+            int32_t const* l = locator.data();
+            int32_t const sfield = l[0];
+            if (sfield == sfAccount.getCode())
+                return Bytes(accountID_.begin(), accountID_.end());
+        }
+
+        uint8_t const a[] = {0x2b, 0x6a, 0x23, 0x2a, 0xa4, 0xc4, 0xbe, 0x41, 0xbf, 0x49, 0xd2,
+                             0x45, 0x9f, 0xa4, 0xa0, 0x34, 0x7e, 0x1b, 0x54, 0x3a, 0x4c, 0x92,
+                             0xfc, 0xee, 0x08, 0x21, 0xc0, 0x20, 0x1e, 0x2e, 0x9a, 0x00};
+        return Bytes(&a[0], &a[sizeof(a)]);
+    }
+
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
+    getTxArrayLen(SField const& fname) const override
+    {
+        return 32;
+    }
+
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
+    getCurrentLedgerObjArrayLen(SField const& fname) const override
+    {
+        return 32;
+    }
+
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
+    getLedgerObjArrayLen(int32_t cacheIdx, SField const& fname) const override
+    {
+        return 32;
+    }
+
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
+    getTxNestedArrayLen(FieldLocator const& locator) const override
+    {
+        return 32;
+    }
+
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
+    getCurrentLedgerObjNestedArrayLen(FieldLocator const& locator) const override
+    {
+        return 32;
+    }
+
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
+    getLedgerObjNestedArrayLen(int32_t cacheIdx, FieldLocator const& locator) const override
+    {
+        return 32;
+    }
+
+    std::expected<int32_t, HostFunctionError>
+    updateData(Slice const& data) override
+    {
+        return data.size();
+    }
+
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
+    checkSignature(Slice const& message, Slice const& signature, Slice const& pubkey) const override
+    {
+        return 1;
+    }
+
+    [[nodiscard]] std::expected<Hash, HostFunctionError>
+    computeSha512HalfHash(Slice const& data) const override
+    {
+        return env_.current()->header().parentHash;
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    accountKeylet(AccountID const& account) const override
+    {
+        if (!account)
+            return std::unexpected(HostFunctionError::InvalidAccount);
+        auto const keylet = keylet::account(account);
+        return Bytes{keylet.key.begin(), keylet.key.end()};
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    ammKeylet(Asset const& issue1, Asset const& issue2) const override
+    {
+        if (issue1 == issue2)
+            return std::unexpected(HostFunctionError::InvalidParams);
+        if (issue1.holds<MPTIssue>() || issue2.holds<MPTIssue>())
+            return std::unexpected(HostFunctionError::InvalidParams);
+        auto const keylet = keylet::amm(issue1, issue2);
+        return Bytes{keylet.key.begin(), keylet.key.end()};
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    checkKeylet(AccountID const& account, std::uint32_t seq) const override
+    {
+        if (!account)
+            return std::unexpected(HostFunctionError::InvalidAccount);
+        auto const keylet = keylet::check(account, SeqProxy::rawSequence(seq));
+        return Bytes{keylet.key.begin(), keylet.key.end()};
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    credentialKeylet(AccountID const& subject, AccountID const& issuer, Slice const& credentialType)
+        const override
+    {
+        if (!subject || !issuer || credentialType.empty() ||
+            credentialType.size() > kMaxCredentialTypeLength)
+            return std::unexpected(HostFunctionError::InvalidAccount);
+        auto const keylet = keylet::credential(subject, issuer, credentialType);
+        return Bytes{keylet.key.begin(), keylet.key.end()};
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    escrowKeylet(AccountID const& account, std::uint32_t seq) const override
+    {
+        if (!account)
+            return std::unexpected(HostFunctionError::InvalidAccount);
+        auto const keylet = keylet::escrow(account, SeqProxy::rawSequence(seq));
+        return Bytes{keylet.key.begin(), keylet.key.end()};
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    oracleKeylet(AccountID const& account, std::uint32_t documentId) const override
+    {
+        if (!account)
+            return std::unexpected(HostFunctionError::InvalidAccount);
+        auto const keylet = keylet::oracle(account, documentId);
+        return Bytes{keylet.key.begin(), keylet.key.end()};
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    getNFT(AccountID const& account, uint256 const& nftId) const override
+    {
+        if (!account || !nftId)
+            return std::unexpected(HostFunctionError::InvalidParams);
+
+        std::string s = "https://ripple.com";
+        return Bytes(s.begin(), s.end());
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    getNFTIssuer(uint256 const& nftId) const override
+    {
+        return Bytes(accountID_.begin(), accountID_.end());
+    }
+
+    [[nodiscard]] std::expected<std::uint32_t, HostFunctionError>
+    getNFTTaxon(uint256 const& nftId) const override
+    {
+        return 4;
+    }
+
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
+    getNFTFlags(uint256 const& nftId) const override
+    {
+        return 8;
+    }
+
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
+    getNFTTransferFee(uint256 const& nftId) const override
+    {
+        return 10;
+    }
+
+    [[nodiscard]] std::expected<std::uint32_t, HostFunctionError>
+    getNFTSequence(uint256 const& nftId) const override
+    {
+        return 4;
+    }
+
+    template <typename F>
+    void
+    log(std::string_view const& msg, F&& dataFn) const
+    {
+#ifdef DEBUG_OUTPUT
+        auto& j = std::cerr;
+#else
+        if (!getJournal().active(beast::Severity::Trace))
+            return;
+        auto j = getJournal().trace();
+#endif
+        j << "WasmTrace: " << msg << " " << dataFn();
+
+#ifdef DEBUG_OUTPUT
+        j << std::endl;
+#endif
+    }
+
+    void
+    trace(std::string_view const& msg, std::string_view const& data) const override
+    {
+        log(msg, [&data] { return data; });
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    floatFromInt(int64_t x, int32_t mode) const override
+    {
+        return wasm_float::floatFromIntImpl(x, mode);
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    floatFromUint(uint64_t x, int32_t mode) const override
+    {
+        return wasm_float::floatFromUintImpl(x, mode);
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    floatFromSTAmount(STAmount const& x, int32_t mode) const override
+    {
+        return wasm_float::floatFromSTAmountImpl(x, mode);
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    floatFromSTNumber(STNumber const& x, int32_t mode) const override
+    {
+        return wasm_float::floatFromSTNumberImpl(x, mode);
+    }
+
+    [[nodiscard]] std::expected<int64_t, HostFunctionError>
+    floatToInt(Slice const& x, int32_t mode) const override
+    {
+        return wasm_float::floatToIntImpl(x, mode);
+    }
+
+    [[nodiscard]] std::expected<FloatPair, HostFunctionError>
+    floatToMantExp(Slice const& x) const override
+    {
+        return wasm_float::floatToMantExpImpl(x);
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    floatFromMantExp(int64_t mantissa, int32_t exponent, int32_t mode) const override
+    {
+        return wasm_float::floatFromMantExpImpl(mantissa, exponent, mode);
+    }
+
+    [[nodiscard]] std::expected<int32_t, HostFunctionError>
+    floatCompare(Slice const& x, Slice const& y) const override
+    {
+        return wasm_float::floatCompareImpl(x, y);
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    floatAdd(Slice const& x, Slice const& y, int32_t mode) const override
+    {
+        return wasm_float::floatAddImpl(x, y, mode);
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    floatSubtract(Slice const& x, Slice const& y, int32_t mode) const override
+    {
+        return wasm_float::floatSubtractImpl(x, y, mode);
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    floatMultiply(Slice const& x, Slice const& y, int32_t mode) const override
+    {
+        return wasm_float::floatMultiplyImpl(x, y, mode);
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    floatDivide(Slice const& x, Slice const& y, int32_t mode) const override
+    {
+        return wasm_float::floatDivideImpl(x, y, mode);
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    floatRoot(Slice const& x, int32_t n, int32_t mode) const override
+    {
+        return wasm_float::floatRootImpl(x, n, mode);
+    }
+
+    [[nodiscard]] std::expected<Bytes, HostFunctionError>
+    floatPower(Slice const& x, int32_t n, int32_t mode) const override
+    {
+        return wasm_float::floatPowerImpl(x, n, mode);
+    }
+};
+
+class TestHostFunctionsSink : public TestHostFunctions
+{
+    test::StreamSink sink_;
+
+public:
+    explicit TestHostFunctionsSink(test::jtx::Env& env)
+        : TestHostFunctions(env), sink_(beast::Severity::Debug)
+    {
+        j_ = beast::Journal(sink_);
+    }
+
+    test::StreamSink&
+    getSink()
+    {
+        return sink_;
+    }
+};
+
+}  // namespace xrpl::test

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,180 @@
+# 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-common-stdlib",
+ "xrpl-escrow-stdlib",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2f6c7dbe95a6ed67ad9f18e57daf93a2f034c524b99fd2b76d18fdfeb6660aa"
+dependencies = [
+ "hybrid-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 = "const-oid"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c"
+
+[[package]]
+name = "cpufeatures"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453"
+dependencies = [
+ "hybrid-array",
+]
+
+[[package]]
+name = "digest"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
+dependencies = [
+ "block-buffer",
+ "const-oid",
+ "crypto-common",
+]
+
+[[package]]
+name = "hybrid-array"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "707114b52a152fa7bdb290cd7cd5912d9467273b6d74e21b8d81aca1f8533f6b"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.186"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "sha2"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "syn"
+version = "3.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3"
+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.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40ce102ab67701b8526c123c1bab5cbe42d7040ccfd0f64af1a385808d2f43de"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "xrpl-common-stdlib"
+version = "0.8.0"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git?branch=error-and-trace#b008b097237ce0d1a2dffc72ba39dd9fc50020a9"
+dependencies = [
+ "xrpl-macros",
+]
+
+[[package]]
+name = "xrpl-escrow-stdlib"
+version = "0.1.0"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git?branch=error-and-trace#b008b097237ce0d1a2dffc72ba39dd9fc50020a9"
+dependencies = [
+ "xrpl-common-stdlib",
+]
+
+[[package]]
+name = "xrpl-macros"
+version = "0.1.0"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git?branch=error-and-trace#b008b097237ce0d1a2dffc72ba39dd9fc50020a9"
+dependencies = [
+ "bs58",
+ "proc-macro2",
+ "quote",
+ "sha2",
+ "syn",
+]

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

@@ -0,0 +1,22 @@
+[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-common-stdlib", branch = "error-and-trace" }
+xrpl-escrow = { git = "https://github.com/ripple/xrpl-wasm-stdlib.git", package = "xrpl-escrow-stdlib", branch = "error-and-trace" }
+
+[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,760 @@
+#![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_escrow::current_tx::escrow_finish::EscrowFinish;
+use xrpl_std::current_tx::traits::TransactionCommonFields;
+use xrpl_std::host;
+use xrpl_std::host::trace::TraceDataType;
+use xrpl_std::host::trace::{trace, trace_acct_buf, trace_hex, trace_num};
+use xrpl_std::sfield;
+
+#[unsafe(no_mangle)]
+pub extern "C" fn escrow_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::ldgr_index(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::parent_ldgr_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::parent_ldgr_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_hex("Parent ledger hash:", &hash_buffer);
+
+    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::tx_field(
+            sfield::Account.into(),
+            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_acct_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::tx_field(
+            sfield::Fee.into(),
+            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_hex("Transaction Fee (serialized XRP amount):", &fee_buffer);
+
+    // Test with Sequence field (required, 4 bytes uint32)
+    let mut seq_buffer = [0u8; 4];
+    let seq_len = unsafe {
+        host::tx_field(
+            sfield::Sequence.into(),
+            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_hex("Transaction Sequence:", &seq_buffer);
+
+    // 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_u8, 0x00_u8, 0x00_u8, 0x00_u8, 0x00_u8, 0x00_u8, 0x00_u8, 0x00_u8,
+    ]; // Two int32s in little-endian: [1, 0]
+    let mut nested_buffer = [0u8; 32];
+    let nested_result = unsafe {
+        host::tx_inner(
+            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_hex("Nested field:", &nested_buffer[..nested_result as usize]);
+    }
+
+    // Test 2.3: get_tx_array_len() - Get array length
+    let signers_len = unsafe { host::tx_arr_len(sfield::Signers.into()) };
+    let _ = trace_num("Signers array length:", signers_len as i64);
+
+    let memos_len = unsafe { host::tx_arr_len(sfield::Memos.into()) };
+    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::tx_inner_arr_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::home_le_field(
+            sfield::Balance.into(),
+            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_hex(
+            "Current object balance (serialized XRP amount):",
+            &balance_buffer,
+        );
+    } else {
+        let _ = trace_num(
+            "Current object balance length (non-XRP amount):",
+            balance_result as i64,
+        );
+        let _ = trace_hex(
+            "Current object balance:",
+            &balance_buffer[..balance_result as usize],
+        );
+    }
+
+    // Test with Account field
+    let mut current_account_buffer = [0u8; 20];
+    let current_account_result = unsafe {
+        host::home_le_field(
+            sfield::Account.into(),
+            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_acct_buf("Current ledger object account:", &current_account_buffer);
+    }
+
+    // Test 3.2: get_current_ledger_obj_nested_field() - Nested field access
+    let locator = [
+        0x01_u8, 0x00_u8, 0x00_u8, 0x00_u8, 0x00_u8, 0x00_u8, 0x00_u8, 0x00_u8,
+    ]; // Two int32s in little-endian: [1, 0]
+    let mut current_nested_buffer = [0u8; 32];
+    let current_nested_result = unsafe {
+        host::home_le_inner(
+            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_hex(
+            "Current nested field:",
+            &current_nested_buffer[..current_nested_result as usize],
+        );
+    }
+
+    // Test 3.3: get_current_ledger_obj_array_len() - Array length in current object
+    let current_array_len = unsafe { host::home_le_arr_len(sfield::Signers.into()) };
+    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::home_le_inner_arr_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_le() - Cache a ledger object
+    let mut keylet_buffer = [0u8; 32];
+    let keylet_result = unsafe {
+        host::accountroot_id(
+            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: accountroot_id failed for caching test:",
+            keylet_result as i64,
+        );
+        return -401; // Keylet generation failed for caching test
+    }
+
+    let cache_result = unsafe { host::cache_le(keylet_buffer.as_ptr(), keylet_result as usize, 0) };
+
+    if cache_result <= 0 {
+        let _ = trace_num(
+            "INFO: cache_le 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 le_field with invalid slot
+        let field_result = unsafe {
+            host::le_field(
+                1,
+                sfield::Balance.into(),
+                test_buffer.as_mut_ptr(),
+                test_buffer.len(),
+            )
+        };
+        if field_result < 0 {
+            let _ = trace_num(
+                "INFO: le_field failed as expected (no cached object):",
+                field_result as i64,
+            );
+        }
+
+        // Test le_inner_field with invalid slot
+        let locator = [
+            0x01_u8, 0x00_u8, 0x00_u8, 0x00_u8, 0x00_u8, 0x00_u8, 0x00_u8, 0x00_u8,
+        ]; // Two int32s in little-endian: [1, 0]
+        let nested_result = unsafe {
+            host::le_inner(
+                1,
+                locator.as_ptr(),
+                locator.len(),
+                test_buffer.as_mut_ptr(),
+                test_buffer.len(),
+            )
+        };
+        if nested_result < 0 {
+            let _ = trace_num(
+                "INFO: le_inner_field failed as expected:",
+                nested_result as i64,
+            );
+        }
+
+        // Test le_inner_arr_len with invalid slot
+        let array_result = unsafe { host::le_arr_len(1, sfield::Signers.into()) };
+        if array_result < 0 {
+            let _ = trace_num(
+                "INFO: le_inner_arr_len failed as expected:",
+                array_result as i64,
+            );
+        }
+
+        // Test get_ledger_obj_nested_array_len with invalid slot
+        let nested_array_result =
+            unsafe { host::le_inner_arr_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: le_field() - Access field from cached object
+    let mut cached_balance_buffer = [0u8; 8];
+    let cached_balance_result = unsafe {
+        host::le_field(
+            slot,
+            sfield::Balance.into(),
+            cached_balance_buffer.as_mut_ptr(),
+            cached_balance_buffer.len(),
+        )
+    };
+
+    if cached_balance_result <= 0 {
+        let _ = trace_num(
+            "INFO: le_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_hex(
+            "Cached object balance (serialized XRP amount):",
+            &cached_balance_buffer,
+        );
+    } else {
+        let _ = trace_num(
+            "Cached object balance length (non-XRP amount):",
+            cached_balance_result as i64,
+        );
+        let _ = trace_hex(
+            "Cached object balance:",
+            &cached_balance_buffer[..cached_balance_result as usize],
+        );
+    }
+
+    // Test 4.3: le_inner_field() - Nested field from cached object
+    let locator = [
+        0x01_u8, 0x00_u8, 0x00_u8, 0x00_u8, 0x00_u8, 0x00_u8, 0x00_u8, 0x00_u8,
+    ]; // Two int32s in little-endian: [1, 0]
+    let mut cached_nested_buffer = [0u8; 32];
+    let cached_nested_result = unsafe {
+        host::le_inner(
+            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: le_inner_field not applicable:",
+            cached_nested_result as i64,
+        );
+    } else {
+        let _ = trace_num("Cached nested field length:", cached_nested_result as i64);
+        let _ = trace_hex(
+            "Cached nested field:",
+            &cached_nested_buffer[..cached_nested_result as usize],
+        );
+    }
+
+    // Test 4.4: le_inner_arr_len() - Array length from cached object
+    let cached_array_len = unsafe { host::le_arr_len(slot, sfield::Signers.into()) };
+    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::le_inner_arr_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: accountroot_id() - Generate keylet for account
+    let mut accountroot_id_buffer = [0u8; 32];
+    let accountroot_id_result = unsafe {
+        host::accountroot_id(
+            account_id.0.as_ptr(),
+            account_id.0.len(),
+            accountroot_id_buffer.as_mut_ptr(),
+            accountroot_id_buffer.len(),
+        )
+    };
+
+    if accountroot_id_result != 32 {
+        let _ = trace_num(
+            "ERROR: accountroot_id failed:",
+            accountroot_id_result as i64,
+        );
+        return -501; // Account keylet generation failed
+    }
+    let _ = trace_hex("Account keylet:", &accountroot_id_buffer);
+
+    // Test 5.2: credential_keylet() - Generate keylet for credential
+    let mut credential_keylet_buffer = [0u8; 32];
+    let credential_keylet_result = unsafe {
+        host::credential_id(
+            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_hex(
+            "Credential keylet:",
+            &credential_keylet_buffer[..credential_keylet_result as usize],
+        );
+    }
+
+    // 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_id(
+            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_hex("Escrow keylet:", &escrow_keylet_buffer);
+
+    // 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_id(
+            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_hex("Oracle keylet:", &oracle_keylet_buffer);
+
+    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::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_hex("Input data:", test_data);
+    let _ = trace_hex("SHA512 half hash:", &hash_output);
+
+    // 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::nft_uri(
+            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_hex("NFT data:", &nft_buffer[..nft_result as usize]);
+    }
+
+    // Test 6.3: trace() - Debug logging with data
+    let trace_message = b"Test trace message";
+    let trace_data_payload = b"payload";
+    unsafe {
+        host::trace(
+            trace_message.as_ptr(),
+            trace_message.len(),
+            TraceDataType::AsHex as i32,
+            trace_data_payload.as_ptr(),
+            trace_data_payload.len(),
+        )
+    };
+
+    // Test 6.4: trace_num() - Debug logging with number
+    let test_number = 42i64;
+    trace_num("Test number trace", test_number);
+
+    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::set_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_hex("Successfully updated ledger entry with:", update_payload);
+    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.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+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.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.186"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+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.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3"
+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.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40ce102ab67701b8526c123c1bab5cbe42d7040ccfd0f64af1a385808d2f43de"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "xrpl-macros"
+version = "0.1.0"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git?branch=renames#21c522f34a24b460297ebb6be1822680459bf37e"
+dependencies = [
+ "bs58",
+ "quote",
+ "sha2",
+ "syn",
+]
+
+[[package]]
+name = "xrpl-wasm-stdlib"
+version = "0.8.0"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git?branch=renames#21c522f34a24b460297ebb6be1822680459bf37e"
+dependencies = [
+ "xrpl-macros",
+]

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 = "renames" }
+
+[profile.dev]
+panic = "abort"

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

@@ -0,0 +1,176 @@
+#![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::keylets;
+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::ledger_objects::LedgerObjectFieldGetter;
+use xrpl_std::core::types::currency::Currency;
+use xrpl_std::core::types::issue::{IouIssue, Issue, XrpIssue};
+use xrpl_std::core::types::mpt_id::MptId;
+use xrpl_std::host;
+use xrpl_std::host::trace::{trace, trace_acct, trace_data, trace_num, DataRepr};
+use xrpl_std::sfield;
+
+pub fn object_exists<T: LedgerObjectFieldGetter, const CODE: i32>(
+    keylet_result: Result<keylets::KeyletBytes>,
+    keylet_type: &str,
+    sfield: sfield::SField<T, CODE>,
+) -> Result<bool> {
+    let field = CODE;
+    match keylet_result {
+        Ok(keylet) => {
+            let _ = trace_data(keylet_type, &keylet, DataRepr::AsHex);
+
+            let slot = unsafe { host::cache_le(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.clone().into());
+                match ledger_object::get_field(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(slot, sfield) {
+                    Ok(_data) => {
+                        let _ = trace("Field data: retrieved");
+                    }
+                    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 escrow_finish() -> i32 {
+    let _ = trace("$$$$$ STARTING WASM EXECUTION $$$$$");
+
+    let escrow: CurrentEscrow = get_current_escrow();
+
+    let account = escrow.get_account().unwrap_or_panic();
+    let _ = trace_acct("Account:", &account);
+
+    let destination = escrow.get_destination().unwrap_or_panic();
+    let _ = trace_acct("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 accountroot_id = keylets::accountroot_id(&account);
+    check_object_exists!(accountroot_id, "Account", sfield::Account);
+
+    let currency_code: &[u8; 3] = b"USD";
+    let currency: Currency = Currency::from(*currency_code);
+    let trustline_id = keylets::trustline_id(&account, &destination, &currency);
+    check_object_exists!(trustline_id, "Trustline", sfield::Generic);
+    seq += 1;
+
+    let asset1 = Issue::XRP(XrpIssue {});
+    let asset2 = Issue::IOU(IouIssue::new(destination, currency));
+    check_object_exists!(keylets::amm_id(&asset1, &asset2), "AMM", sfield::Account);
+
+    let check_id = keylets::check_id(&account, seq);
+    check_object_exists!(check_id, "Check", sfield::Account);
+    seq += 1;
+
+    let cred_type: &[u8] = b"termsandconditions";
+    let credential_id = keylets::credential_id(&account, &account, cred_type);
+    check_object_exists!(credential_id, "Credential", sfield::Subject);
+    seq += 1;
+
+    let delegate_id = keylets::delegate_id(&account, &destination);
+    check_object_exists!(delegate_id, "Delegate", sfield::Account);
+    seq += 1;
+
+    let deposit_preauth_id = keylets::deposit_preauth_id(&account, &destination);
+    check_object_exists!(deposit_preauth_id, "DepositPreauth", sfield::Account);
+    seq += 1;
+
+    let did_id = keylets::did_id(&account);
+    check_object_exists!(did_id, "DID", sfield::Account);
+    seq += 1;
+
+    let escrow_id = keylets::escrow_id(&account, seq);
+    check_object_exists!(escrow_id, "Escrow", sfield::Account);
+    seq += 1;
+
+    let mpt_issuance_id = keylets::mpt_issuance_id(&account, seq);
+    let mpt_id = MptId::new(seq.try_into().unwrap(), account);
+    check_object_exists!(mpt_issuance_id, "MPTIssuance", sfield::Issuer);
+    seq += 1;
+
+    let mptoken_id = keylets::mptoken_id(&mpt_id, &destination);
+    check_object_exists!(mptoken_id, "MPToken", sfield::Account);
+
+    let nft_offer_id = keylets::nft_offer_id(&destination, 6);
+    check_object_exists!(nft_offer_id, "NFTokenOffer", sfield::Owner);
+
+    let offer_id = keylets::offer_id(&account, seq);
+    check_object_exists!(offer_id, "Offer", sfield::Account);
+    seq += 1;
+
+    let paychan_id = keylets::paychan_id(&account, &destination, seq);
+    check_object_exists!(paychan_id, "PayChannel", sfield::Account);
+    seq += 1;
+
+    let pd_id = keylets::permissioned_domain_id(&account, seq);
+    check_object_exists!(pd_id, "PermissionedDomain", sfield::Owner);
+    seq += 1;
+
+    let signers_id = keylets::signers_id(&account);
+    check_object_exists!(signers_id, "SignerList", sfield::Generic);
+    seq += 1;
+
+    seq += 1; // ticket sequence number is one greater
+    let ticket_id = keylets::ticket_id(&account, seq);
+    check_object_exists!(ticket_id, "Ticket", sfield::Account);
+    seq += 1;
+
+    let vault_id = keylets::vault_id(&account, seq);
+    check_object_exists!(vault_id, "Vault", sfield::Account);
+    // seq += 1;
+
+    1 // All keylets exist, finish the escrow.
+}

src/test/app/wasm_fixtures/bad_align.c

@@ -0,0 +1,42 @@
+#include <stdint.h>
+
+int32_t float_from_uint(uint8_t const *, int32_t, uint8_t *, int32_t, int32_t);
+int32_t check_id(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_id with misaligned uint32 at &e_data2[1] to hit line 72 in
+  // HostFuncWrapper.cpp
+  int32_t result = check_id(&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/codecov_tests/Cargo.lock

@@ -0,0 +1,180 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "block-buffer"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2f6c7dbe95a6ed67ad9f18e57daf93a2f034c524b99fd2b76d18fdfeb6660aa"
+dependencies = [
+ "hybrid-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-common-stdlib",
+ "xrpl-escrow-stdlib",
+]
+
+[[package]]
+name = "const-oid"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c"
+
+[[package]]
+name = "cpufeatures"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453"
+dependencies = [
+ "hybrid-array",
+]
+
+[[package]]
+name = "digest"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
+dependencies = [
+ "block-buffer",
+ "const-oid",
+ "crypto-common",
+]
+
+[[package]]
+name = "hybrid-array"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "707114b52a152fa7bdb290cd7cd5912d9467273b6d74e21b8d81aca1f8533f6b"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.186"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "sha2"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "syn"
+version = "3.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53e9bae58849f64dfa4f5d5ae372c8341f7305f82a3868709269343628b659a3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3"
+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.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40ce102ab67701b8526c123c1bab5cbe42d7040ccfd0f64af1a385808d2f43de"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "xrpl-common-stdlib"
+version = "0.8.0"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git?branch=error-and-trace#b008b097237ce0d1a2dffc72ba39dd9fc50020a9"
+dependencies = [
+ "xrpl-macros",
+]
+
+[[package]]
+name = "xrpl-escrow-stdlib"
+version = "0.1.0"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git?branch=error-and-trace#b008b097237ce0d1a2dffc72ba39dd9fc50020a9"
+dependencies = [
+ "xrpl-common-stdlib",
+]
+
+[[package]]
+name = "xrpl-macros"
+version = "0.1.0"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git?branch=error-and-trace#b008b097237ce0d1a2dffc72ba39dd9fc50020a9"
+dependencies = [
+ "bs58",
+ "proc-macro2",
+ "quote",
+ "sha2",
+ "syn",
+]

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

@@ -0,0 +1,19 @@
+[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-common-stdlib", branch = "error-and-trace" }
+xrpl-escrow = { git = "https://github.com/ripple/xrpl-wasm-stdlib.git", package = "xrpl-escrow-stdlib", branch = "error-and-trace" }

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

@@ -0,0 +1,56 @@
+//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 parent_ldgr_hash(out_buff_ptr: i32, out_buff_len: i32) -> i32;
+
+    pub fn cache_le(keylet_ptr: i32, keylet_len: i32, cache_num: i32) -> i32;
+
+    pub fn tx_inner_arr_len(locator_ptr: i32, locator_len: i32) -> i32;
+
+    pub fn accountroot_id(
+        account_ptr: i32,
+        account_len: i32,
+        out_buff_ptr: *mut u8,
+        out_buff_len: usize,
+    ) -> i32;
+
+    pub fn trustline_id(
+        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;
+
+    // Same wasm functype as the real binding, so this is not a second import of
+    // host_lib.trace. Loose i32 pointers exercise the out-of-bounds path.
+    #[link_name = "trace"]
+    pub fn trace_loose(
+        msg_read_ptr: i32,
+        msg_read_len: i32,
+        data_type: i32,
+        data_read_ptr: i32,
+        data_read_len: i32,
+    );
+}

src/test/app/wasm_fixtures/copyFixtures.py

@@ -0,0 +1,302 @@
+# cspell: disable
+import os
+import re
+import shlex
+import subprocess
+import sys
+import tempfile
+import zipfile
+from difflib import get_close_matches
+
+OPT = "-Oz"
+BASE_PATH = os.path.abspath(os.path.dirname(__file__))
+
+
+def pascal_case(name):
+    return "".join(word[:1].upper() + word[1:] for word in re.split(r"[_\W]+", name))
+
+
+def normalize_name(name):
+    name = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", name)
+    return re.sub(r"[^a-z0-9]", "", name.lower())
+
+
+def fixture_key(name):
+    name = normalize_name(name).removeprefix("k")
+    return name.removesuffix("wasmhex").removesuffix("hex")
+
+
+def declared_fixtures():
+    h_path = os.path.join(BASE_PATH, "fixtures.h")
+    with open(h_path, "r", encoding="utf8") as f:
+        return re.findall(
+            r"extern std::string const ([A-Za-z_][A-Za-z0-9_]*);", f.read()
+        )
+
+
+def find_fixture_name(project_name, suffix):
+    default = re.sub(r"_([a-z])", lambda m: m.group(1).upper(), project_name) + suffix
+    k_default = f"k{pascal_case(project_name)}{suffix}"
+    declarations = declared_fixtures()
+    normalized = {normalize_name(name): name for name in declarations}
+    fixture_keys = {fixture_key(name): name for name in declarations}
+
+    for name in (default, k_default):
+        if normalize_name(name) in normalized:
+            return normalized[normalize_name(name)]
+
+    project_key = normalize_name(project_name)
+    matches = [
+        name
+        for key, name in fixture_keys.items()
+        if key.endswith(project_key)
+        or key.startswith(project_key)
+        or project_key.endswith(key)
+        or project_key.startswith(key)
+    ]
+    if len(matches) == 1:
+        return matches[0]
+
+    close = get_close_matches(project_key, fixture_keys.keys(), n=1, cutoff=0.82)
+    if close:
+        return fixture_keys[close[0]]
+
+    return k_default
+
+
+def fixture_cpp_path(fixture_name):
+    pattern = rf"extern std::string const {fixture_name} ="
+    for file_name in os.listdir(BASE_PATH):
+        if not file_name.endswith(".cpp"):
+            continue
+        cpp_path = os.path.join(BASE_PATH, file_name)
+        with open(cpp_path, "r", encoding="utf8") as f:
+            if re.search(pattern, f.read()):
+                return cpp_path
+    return os.path.join(BASE_PATH, "fixtures.cpp")
+
+
+def update_fixture(project_name, wasm, suffix="WasmHex"):
+    fixture_name = find_fixture_name(project_name, suffix)
+    print(f"Updating fixture: {fixture_name}")
+
+    cpp_path = fixture_cpp_path(fixture_name)
+    h_path = os.path.join(BASE_PATH, "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\nextern 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 read_wasm_hex(path):
+    with open(path, "rb") as f:
+        return f.read().hex()
+
+
+def process_rust(project_name):
+    project_path = os.path.join(BASE_PATH, project_name)
+    wasm_location = os.path.join(
+        project_path, "target", "wasm32v1-none", "release", f"{project_name}.wasm"
+    )
+    try:
+        subprocess.run(
+            ["cargo", "build", "--target", "wasm32v1-none", "--release"],
+            cwd=project_path,
+            check=True,
+        )
+        subprocess.run(
+            ["wasm-opt", wasm_location, OPT, "-o", wasm_location], check=True
+        )
+        print(f"WASM file for {project_name} has been built and optimized.")
+    except FileNotFoundError as e:
+        print(f"exec error: {e.filename} is required to build Rust fixtures")
+        sys.exit(1)
+    except subprocess.CalledProcessError as e:
+        print(f"exec error: {e}")
+        sys.exit(1)
+
+    update_fixture(project_name, read_wasm_hex(wasm_location))
+
+
+def process_c(project_name):
+    project_path = os.path.join(BASE_PATH, f"{project_name}.c")
+    wasm_path = os.path.join(BASE_PATH, f"{project_name}.wasm")
+    cc = os.environ.get("CC")
+    sysroot = os.environ.get("SYSROOT")
+    if not cc or not sysroot:
+        print("exec error: CC and SYSROOT are required to build C fixtures")
+        sys.exit(1)
+
+    build_cmd = [
+        *shlex.split(cc),
+        f"--sysroot={sysroot}",
+        "-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",
+        "-o",
+        wasm_path,
+        project_path,
+    ]
+    try:
+        subprocess.run(build_cmd, check=True)
+        subprocess.run(["wasm-opt", wasm_path, OPT, "-o", wasm_path], check=True)
+        print(
+            f"WASM file for {project_name} has been built with WASI support using clang."
+        )
+    except FileNotFoundError as e:
+        print(f"exec error: {e.filename} is required to build C fixtures")
+        sys.exit(1)
+    except subprocess.CalledProcessError as e:
+        print(f"exec error: {e}")
+        sys.exit(1)
+
+    update_fixture(project_name, read_wasm_hex(wasm_path))
+
+
+def wat_to_wasm(wat_path, wasm_path):
+    build_cmd = ["wat2wasm", "--enable-all", wat_path, "-o", wasm_path]
+    try:
+        subprocess.run(build_cmd, check=True)
+        print(f"WASM file for {os.path.basename(wat_path)} has been built.")
+        return
+    except FileNotFoundError:
+        print("exec error: wat2wasm is required to build WAT fixtures")
+        sys.exit(1)
+    except subprocess.CalledProcessError:
+        # wat2wasm (wabt) does not support some proposal text syntax such as
+        # the GC instructions, so fall back to wasm-tools which does.
+        pass
+
+    fallback_cmd = ["wasm-tools", "parse", wat_path, "-o", wasm_path]
+    try:
+        subprocess.run(fallback_cmd, check=True)
+        print(
+            f"WASM file for {os.path.basename(wat_path)} has been built with wasm-tools."
+        )
+    except FileNotFoundError:
+        print("exec error: wasm-tools is required to build this WAT fixture")
+        sys.exit(1)
+    except subprocess.CalledProcessError as e:
+        print(f"exec error: {e}")
+        sys.exit(1)
+
+
+def process_wat_file(wat_path):
+    project_name = os.path.splitext(os.path.basename(wat_path))[0]
+    with open(wat_path, "r", encoding="utf8") as f:
+        if "(module" not in f.read():
+            print(f"Skipping WAT fixture without a module: {project_name}")
+            return
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        wasm_path = os.path.join(tmpdir, f"{project_name}.wasm")
+        wat_to_wasm(wat_path, wasm_path)
+        update_fixture(project_name, read_wasm_hex(wasm_path), "Hex")
+
+
+def process_wat_zip(zip_path):
+    project_name = os.path.splitext(os.path.basename(zip_path))[0]
+    with tempfile.TemporaryDirectory() as tmpdir:
+        with zipfile.ZipFile(zip_path) as archive:
+            wat_names = [name for name in archive.namelist() if name.endswith(".wat")]
+            if len(wat_names) != 1:
+                print(f"exec error: expected one .wat file in {zip_path}")
+                sys.exit(1)
+            archive.extract(wat_names[0], tmpdir)
+
+        wasm_path = os.path.join(tmpdir, f"{project_name}.wasm")
+        wat_to_wasm(os.path.join(tmpdir, wat_names[0]), wasm_path)
+        update_fixture(project_name, read_wasm_hex(wasm_path), "Hex")
+
+
+def process_wat(project_name):
+    candidates = [
+        os.path.join(BASE_PATH, f"{project_name}.wat"),
+        os.path.join(BASE_PATH, "wat", f"{project_name}.wat"),
+        os.path.join(BASE_PATH, "wat", f"{project_name}.zip"),
+    ]
+    for path in candidates:
+        if os.path.isfile(path):
+            if path.endswith(".zip"):
+                process_wat_zip(path)
+            else:
+                process_wat_file(path)
+            return
+
+    print(f"exec error: fixture {project_name} not found")
+    sys.exit(1)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 2:
+        print("Usage: python copyFixtures.py [<project_name>]")
+        sys.exit(1)
+
+    if len(sys.argv) == 2:
+        project_name = os.path.splitext(os.path.basename(sys.argv[1]))[0]
+        if os.path.isfile(os.path.join(BASE_PATH, project_name, "Cargo.toml")):
+            process_rust(project_name)
+        elif os.path.isfile(os.path.join(BASE_PATH, f"{project_name}.c")):
+            process_c(project_name)
+        else:
+            process_wat(project_name)
+        print("Fixture has been processed.")
+    else:
+        dirs = [
+            d
+            for d in os.listdir(BASE_PATH)
+            if os.path.isfile(os.path.join(BASE_PATH, d, "Cargo.toml"))
+        ]
+        c_files = [f for f in os.listdir(BASE_PATH) if f.endswith(".c")]
+        wat_files = [f for f in os.listdir(BASE_PATH) if f.endswith(".wat")]
+        wat_path = os.path.join(BASE_PATH, "wat")
+        wat_fixture_files = [
+            f
+            for f in (os.listdir(wat_path) if os.path.isdir(wat_path) else [])
+            if f.endswith((".wat", ".zip"))
+        ]
+
+        for d in sorted(dirs):
+            process_rust(d)
+        for c in sorted(c_files):
+            process_c(c[:-2])
+        for wat in sorted(wat_files):
+            process_wat_file(os.path.join(BASE_PATH, wat))
+        for wat_fixture in sorted(wat_fixture_files):
+            path = os.path.join(wat_path, wat_fixture)
+            if wat_fixture.endswith(".zip"):
+                process_wat_zip(path)
+            else:
+                process_wat_file(path)
+        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 "escrow_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,11 @@
+// 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,157 @@
+#pragma once
+
+// TODO: consider moving these to separate files (and figure out the build)
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+// WASM binary format constants and helpers for building test modules
+namespace wasm_constants {
+
+// Magic + version header
+uint8_t const kWasmHeader[] = {
+    0x00,
+    0x61,
+    0x73,
+    0x6d,  // magic: \0asm
+    0x01,
+    0x00,
+    0x00,
+    0x00  // version: 1
+};
+
+// Type section: () -> ()
+uint8_t const kTypeEmptyFunc[] = {0x01, 0x04, 0x01, 0x60, 0x00, 0x00};
+
+// Function section: one function using type 0
+uint8_t const kFuncTypE0[] = {0x03, 0x02, 0x01, 0x00};
+
+// Export section: export func 0 as "escrow_finish"
+uint8_t const kExportFinish[] = {
+    0x07,
+    0x11,
+    0x01,
+    0x0d,
+    'e',
+    's',
+    'c',
+    'r',
+    'o',
+    'w',
+    '_',
+    'f',
+    'i',
+    'n',
+    'i',
+    's',
+    'h',
+    0x00,
+    0x00};
+
+// Empty function body: 0 locals, end
+uint8_t const kEmptyBody[] = {0x00, 0x0b};
+
+// Data segment offset: i32.const 0, end
+uint8_t const kDataOffsetZero[] = {0x41, 0x00, 0x0b};
+
+// Section IDs
+uint8_t const kSectionMemory = 0x05;
+uint8_t const kSectionCode = 0x0a;
+uint8_t const kSectionData = 0x0b;
+
+// Instructions
+uint8_t const kInstrNop = 0x01;
+uint8_t const kInstrEnd = 0x0b;
+
+// Fill byte for data section bloat
+uint8_t const kDataFillByte = 0xEE;
+
+// Generator for WASM module with large code section (many NOPs)
+std::vector<uint8_t>
+generateCodeBlob(uint32_t numInstructions);
+
+// Generator for WASM module with large data section
+std::vector<uint8_t>
+generateDataBlob(uint32_t dataSize);
+
+}  // namespace wasm_constants
+
+extern std::string const kLedgerSqnWasmHex;
+extern std::string const kAllHostFunctionsWasmHex;
+extern std::string const kAllKeyletsWasmHex;
+extern std::string const kCodecovTestsWasmHex;
+
+extern std::string const kFibWasmHex;
+
+extern std::string const kFloatTestsWasmHex;
+extern std::string const kFloat0Hex;
+extern std::string const kDisabledFloatHex;
+
+extern std::string const kMemoryPointerAtLimitHex;
+extern std::string const kMemoryPointerOverLimitHex;
+extern std::string const kMemoryOffsetOverLimitHex;
+extern std::string const kMemoryEndOfWordOverLimitHex;
+extern std::string const kMemoryGrow0To1PageHex;
+extern std::string const kMemoryGrow1To0PageHex;
+extern std::string const kMemoryLastByteOf8MbHex;
+extern std::string const kMemoryGrow1MoreThan8MbHex;
+extern std::string const kMemoryGrow0MoreThan8MbHex;
+extern std::string const kMemoryInit1MoreThan8MbHex;
+extern std::string const kMemoryNegativeAddressHex;
+
+extern std::string const kTable64ElementsHex;
+extern std::string const kTable65ElementsHex;
+extern std::string const kTable2TablesHex;
+extern std::string const kTable0ElementsHex;
+extern std::string const kTableUintMaxHex;
+
+extern std::string const kProposalMutableGlobalHex;
+extern std::string const kProposalGcStructNewHex;
+extern std::string const kProposalMultiValueHex;
+extern std::string const kProposalSignExtHex;
+extern std::string const kProposalFloatToIntHex;
+extern std::string const kProposalBulkMemoryHex;
+extern std::string const kProposalRefTypesHex;
+extern std::string const kProposalTailCallHex;
+extern std::string const kProposalExtendedConstHex;
+extern std::string const kProposalMultiMemoryHex;
+extern std::string const kProposalCustomPageSizesHex;
+extern std::string const kProposalMemory64Hex;
+extern std::string const kProposalWideArithmeticHex;
+
+extern std::string const kTrapDivideBy0Hex;
+extern std::string const kTrapIntOverflowHex;
+extern std::string const kTrapUnreachableHex;
+extern std::string const kTrapNullCallHex;
+extern std::string const kTrapFuncSigMismatchHex;
+
+extern std::string const kWasiGetTimeHex;
+extern std::string const kWasiPrintHex;
+
+extern std::string const kBadMagicNumberHex;
+extern std::string const kBadVersionNumberHex;
+extern std::string const kLyingHeaderHex;
+extern std::string const kNeverEndingNumberHex;
+extern std::string const kVectorLieHex;
+extern std::string const kSectionOrderingHex;
+extern std::string const kGhostPayloadHex;
+extern std::string const kJunkAfterSectionHex;
+extern std::string const kInvalidSectionIdHex;
+extern std::string const kLocalVariableBombHex;
+
+extern std::string const kDeepRecursionHex;
+extern std::string const kInfiniteLoopWasmHex;
+extern std::string const kStartLoopHex;
+
+extern std::string const kBadAlignWasmHex;
+
+extern std::string const kThousandParamsHex;
+extern std::string const kThousand1ParamsHex;
+extern std::string const kLocals10kHex;
+extern std::string const kFunctions5kHex;
+
+extern std::string const kOpcReservedHex;
+
+extern std::string const kImpExpHex;
+extern std::string const kUpdateDataWasmHex;

src/test/app/wasm_fixtures/float_0/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.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2f6c7dbe95a6ed67ad9f18e57daf93a2f034c524b99fd2b76d18fdfeb6660aa"
+dependencies = [
+ "hybrid-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 = "const-oid"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c"
+
+[[package]]
+name = "cpufeatures"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453"
+dependencies = [
+ "hybrid-array",
+]
+
+[[package]]
+name = "digest"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
+dependencies = [
+ "block-buffer",
+ "const-oid",
+ "crypto-common",
+]
+
+[[package]]
+name = "float_0"
+version = "0.0.1"
+dependencies = [
+ "xrpl-wasm-stdlib",
+]
+
+[[package]]
+name = "hybrid-array"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "818356c5132c1fede50f837ca96afbe78ff42413047f4abb886217845e1b6c8c"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.183"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "sha2"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3"
+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.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "xrpl-macros"
+version = "0.1.0"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git?branch=renames#6b35fe45ac70bad38914e7f319d31d7947e05e25"
+dependencies = [
+ "bs58",
+ "proc-macro2",
+ "quote",
+ "sha2",
+ "syn",
+]
+
+[[package]]
+name = "xrpl-wasm-stdlib"
+version = "0.8.0"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git?branch=renames#6b35fe45ac70bad38914e7f319d31d7947e05e25"
+dependencies = [
+ "xrpl-macros",
+]

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

@@ -0,0 +1,21 @@
+[package]
+name = "float_0"
+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 = "renames" }
+
+[profile.dev]
+panic = "abort"

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

@@ -0,0 +1,70 @@
+#![cfg_attr(target_arch = "wasm32", no_std)]
+
+use xrpl_std::host::trace::trace;
+use xrpl_std::host::{float_cmp, float_from_int, float_sub, FLOAT_ROUNDING_MODES_TO_NEAREST};
+
+// Float size constant (8 bytes mantissa + 4 bytes exponent)
+const FLOAT_SIZE: usize = 12;
+
+// FLOAT_ZERO constant
+const FLOAT_ZERO: [u8; FLOAT_SIZE] = [
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
+];
+
+#[unsafe(no_mangle)]
+pub extern "C" fn escrow_finish() -> i32 {
+    let _ = trace("\n$$$ test_float_0 $$$");
+
+    // Test: 10 - 10 should equal 0
+    let mut f10: [u8; FLOAT_SIZE] = [0u8; FLOAT_SIZE];
+    let mut f_result: [u8; FLOAT_SIZE] = [0u8; FLOAT_SIZE];
+
+    // Create float from 10
+    if FLOAT_SIZE as i32
+        != unsafe {
+            float_from_int(
+                10,
+                f10.as_mut_ptr(),
+                FLOAT_SIZE,
+                FLOAT_ROUNDING_MODES_TO_NEAREST,
+            )
+        }
+    {
+        let _ = trace("  float 10-10: failed");
+        return 1;
+    }
+
+    // Subtract: 10 - 10 = 0
+    if FLOAT_SIZE as i32
+        != unsafe {
+            float_sub(
+                f10.as_ptr(),
+                FLOAT_SIZE,
+                f10.as_ptr(),
+                FLOAT_SIZE,
+                f_result.as_mut_ptr(),
+                FLOAT_SIZE,
+                FLOAT_ROUNDING_MODES_TO_NEAREST,
+            )
+        }
+    {
+        let _ = trace("  float 10-10: failed");
+        return 1;
+    }
+
+    // Compare result with FLOAT_ZERO constant
+    if 0 == unsafe {
+        float_cmp(
+            f_result.as_ptr(),
+            FLOAT_SIZE,
+            FLOAT_ZERO.as_ptr(),
+            FLOAT_SIZE,
+        )
+    } {
+        let _ = trace("  FLOAT_ZERO compare: good");
+    } else {
+        let _ = trace("  FLOAT_ZERO compare: bad");
+    }
+
+    1
+}

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.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2f6c7dbe95a6ed67ad9f18e57daf93a2f034c524b99fd2b76d18fdfeb6660aa"
+dependencies = [
+ "hybrid-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 = "const-oid"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c"
+
+[[package]]
+name = "cpufeatures"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453"
+dependencies = [
+ "hybrid-array",
+]
+
+[[package]]
+name = "digest"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
+dependencies = [
+ "block-buffer",
+ "const-oid",
+ "crypto-common",
+]
+
+[[package]]
+name = "float_tests"
+version = "0.0.1"
+dependencies = [
+ "xrpl-wasm-stdlib",
+]
+
+[[package]]
+name = "hybrid-array"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "818356c5132c1fede50f837ca96afbe78ff42413047f4abb886217845e1b6c8c"
+dependencies = [
+ "typenum",
+]
+
+[[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.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4"
+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.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+
+[[package]]
+name = "xrpl-macros"
+version = "0.1.0"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git?branch=renames#6b35fe45ac70bad38914e7f319d31d7947e05e25"
+dependencies = [
+ "bs58",
+ "proc-macro2",
+ "quote",
+ "sha2",
+ "syn",
+]
+
+[[package]]
+name = "xrpl-wasm-stdlib"
+version = "0.8.0"
+source = "git+https://github.com/ripple/xrpl-wasm-stdlib.git?branch=renames#6b35fe45ac70bad38914e7f319d31d7947e05e25"
+dependencies = [
+ "xrpl-macros",
+]

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 = "renames" }
+
+[profile.dev]
+panic = "abort"

src/test/app/wasm_fixtures/infiniteLoop.c

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

src/test/app/wasm_fixtures/ledgerSqn.c

@@ -0,0 +1,14 @@
+#include <stdint.h>
+
+int32_t ldgr_index(uint8_t *, int32_t);
+
+int escrow_finish()
+{
+  uint32_t sqn;
+  int32_t result = ldgr_index((uint8_t *)&sqn, sizeof(sqn));
+
+  if (result < 0)
+    return result;
+
+  return sqn >= 5 ? 5 : 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/updateData.c

@@ -0,0 +1,11 @@
+#include <stdint.h>
+
+int32_t set_data(uint8_t const *, int32_t);
+
+int escrow_finish()
+{
+  uint8_t buf[] = "Data";
+  set_data(buf, sizeof(buf) - 1);
+
+  return -256;
+}

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 byte.
+  ;; Standard Wasm implies (pagesize 65536).
+  (memory 1 (pagesize 1))
+
+  (func $escrow_finish (result i32)
+    ;; If this module instantiates, the runtime accepted the custom page size.
+    i32.const 1
+  )
+
+  (export "escrow_finish" (func $escrow_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 $escrow_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 $escrow_finish
+  )
+
+  ;; Export the only function we have
+  (export "escrow_finish" (func $escrow_finish))
+)