Add GitHub Actions workflow for Guard Checker Build (#658)

.github/workflows/guard-checker-build.yml

@@ -0,0 +1,24 @@
+name: Guard Checker Build
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  guard-checker-build:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - run-on: ubuntu-latest
+          - run-on: macos-latest
+    runs-on: ${{ matrix.run-on }}
+    name: Guard Checker Build - ${{ matrix.run-on }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Build Guard Checker
+        run: |
+          cd src/ripple/app/hook
+          make guard_checker

Builds/CMake/RippledCore.cmake

@@ -488,6 +488,7 @@ target_sources (rippled PRIVATE
   src/ripple/app/tx/impl/apply.cpp
   src/ripple/app/tx/impl/applySteps.cpp
   src/ripple/app/hook/impl/applyHook.cpp
+  src/ripple/app/hook/impl/HookAPI.cpp
   src/ripple/app/tx/impl/details/NFTokenUtils.cpp
   #[===============================[
      main sources:
@@ -749,6 +750,7 @@ if (tests)
     src/test/app/Freeze_test.cpp
     src/test/app/GenesisMint_test.cpp
     src/test/app/HashRouter_test.cpp
+    src/test/app/HookAPI_test.cpp
     src/test/app/Import_test.cpp
     src/test/app/Invoke_test.cpp
     src/test/app/LedgerHistory_test.cpp

README.md

@@ -60,7 +60,7 @@ git-subtree. See those directories' README files for more details.
   - [Xrpl Documentation](https://xrpl.org)
   - [Xahau Documentation](https://xahau.network/)
   - [Hooks Technical Documentation](https://xrpl-hooks.readme.io/)
-- **Explorers**: Explore the Xahau ledger using various explorers:
+- **Explorers**: Explore the Xahau Network using various explorers:
   - [xahauexplorer.com](https://xahauexplorer.com)
   - [xahscan.com](https://xahscan.com)
   - [xahau.xrpl.org](https://xahau.xrpl.org)

SECURITY.md

@@ -62,11 +62,11 @@ For these complaints or reports, please [contact our support team](mailto:bugs@x
 ### The following type of security problems are excluded
 
 1. **In scope**. Only bugs in software under the scope of the program qualify. Currently, that means `xahaud` and `xahau-lib`.
-2. **Relevant**. A security issue, posing a danger to user funds, privacy or the operation of the Xahau Ledger.
+2. **Relevant**. A security issue, posing a danger to user funds, privacy or the operation of the Xahau Network.
 3. **Original and previously unknown**. Bugs that are already known and discussed in public do not qualify. Previously reported bugs, even if publicly unknown, are not eligible.
 4. **Specific**. We welcome general security advice or recommendations, but we cannot pay bounties for that.
 5. **Fixable**. There has to be something we can do to permanently fix the problem. Note that bugs in other people’s software may still qualify in some cases. For example, if you find a bug in a library that we use which can compromise the security of software that is in scope and we can get it fixed, you may qualify for a bounty.
-6. **Unused**. If you use the exploit to attack the Xahau Ledger, you do not qualify for a bounty. If you report a vulnerability used in an ongoing or past attack and there is specific, concrete evidence that suggests you are the attacker we reserve the right not to pay a bounty.
+6. **Unused**. If you use the exploit to attack the Xahau Network, you do not qualify for a bounty. If you report a vulnerability used in an ongoing or past attack and there is specific, concrete evidence that suggests you are the attacker we reserve the right not to pay a bounty.
 
 Please note: Reports that are lacking any proof (such as screenshots or other data), detailed information or details on how to reproduce any unexpected result will be investigated but will not be eligible for any reward.
 

src/ripple/app/hook/HookAPI.h

@@ -0,0 +1,346 @@
+#ifndef HOOK_API_INCLUDED
+#define HOOK_API_INCLUDED 1
+
+#include <ripple/app/hook/Enum.h>
+#include <ripple/app/misc/Transaction.h>
+
+namespace hook {
+using namespace ripple;
+using HookReturnCode = hook_api::hook_return_code;
+
+using Bytes = std::vector<std::uint8_t>;
+
+struct HookContext;  // defined in applyHook.h
+
+class HookAPI
+{
+public:
+    explicit HookAPI(HookContext& ctx) : hookCtx(ctx)
+    {
+    }
+
+    /// control APIs
+    // _g
+    // accept
+    // rollback
+
+    /// util APIs
+    Expected<std::string, HookReturnCode>
+    util_raddr(Bytes const& accountID) const;
+
+    Expected<Bytes, HookReturnCode>
+    util_accid(std::string raddress) const;
+
+    Expected<bool, HookReturnCode>
+    util_verify(Slice const& data, Slice const& sig, Slice const& key) const;
+
+    uint256
+    util_sha512h(Slice const& data) const;
+
+    // util_keylet()
+
+    /// sto APIs
+    Expected<bool, HookReturnCode>
+    sto_validate(Bytes const& data) const;
+
+    Expected<std::pair<uint32_t, uint32_t>, HookReturnCode>
+    sto_subfield(Bytes const& data, uint32_t field_id) const;
+
+    Expected<std::pair<uint32_t, uint32_t>, HookReturnCode>
+    sto_subarray(Bytes const& data, uint32_t index_id) const;
+
+    Expected<Bytes, HookReturnCode>
+    sto_emplace(
+        Bytes const& source_object,
+        std::optional<Bytes> const& field_object,
+        uint32_t field_id) const;
+
+    // sto_erase(): same as sto_emplace with field_object = nullopt
+
+    /// etxn APIs
+    Expected<std::shared_ptr<Transaction>, HookReturnCode>
+    emit(Slice const& txBlob) const;
+
+    Expected<uint64_t, HookReturnCode>
+    etxn_burden() const;
+
+    Expected<uint64_t, HookReturnCode>
+    etxn_fee_base(Slice const& txBlob) const;
+
+    Expected<uint64_t, HookReturnCode>
+    etxn_details(uint8_t* out_ptr) const;
+
+    Expected<uint64_t, HookReturnCode>
+    etxn_reserve(uint64_t count) const;
+
+    uint32_t
+    etxn_generation() const;
+
+    Expected<uint256, HookReturnCode>
+    etxn_nonce() const;
+
+    /// float APIs
+    Expected<uint64_t, HookReturnCode>
+    float_set(int32_t exponent, int64_t mantissa) const;
+
+    Expected<uint64_t, HookReturnCode>
+    float_multiply(uint64_t float1, uint64_t float2) const;
+
+    Expected<uint64_t, HookReturnCode>
+    float_mulratio(
+        uint64_t float1,
+        uint32_t round_up,
+        uint32_t numerator,
+        uint32_t denominator) const;
+
+    uint64_t
+    float_negate(uint64_t float1) const;
+
+    Expected<uint64_t, HookReturnCode>
+    float_compare(uint64_t float1, uint64_t float2, uint32_t mode) const;
+
+    Expected<uint64_t, HookReturnCode>
+    float_sum(uint64_t float1, uint64_t float2) const;
+
+    Expected<Bytes, HookReturnCode>
+    float_sto(
+        std::optional<Currency> currency,
+        std::optional<AccountID> issuer,
+        uint64_t float1,
+        uint32_t field_code,
+        uint32_t write_len) const;
+
+    Expected<uint64_t, HookReturnCode>
+    float_sto_set(Bytes const& data) const;
+
+    Expected<uint64_t, HookReturnCode>
+    float_invert(uint64_t float1) const;
+
+    Expected<uint64_t, HookReturnCode>
+    float_divide(uint64_t float1, uint64_t float2) const;
+
+    uint64_t
+    float_one() const;
+
+    Expected<uint64_t, HookReturnCode>
+    float_mantissa(uint64_t float1) const;
+
+    uint64_t
+    float_sign(uint64_t float1) const;
+
+    Expected<uint64_t, HookReturnCode>
+    float_int(uint64_t float1, uint32_t decimal_places, uint32_t absolute)
+        const;
+
+    Expected<uint64_t, HookReturnCode>
+    float_log(uint64_t float1) const;
+
+    Expected<uint64_t, HookReturnCode>
+    float_root(uint64_t float1, uint32_t n) const;
+
+    /// otxn APIs
+    uint64_t
+    otxn_burden() const;
+
+    uint32_t
+    otxn_generation() const;
+
+    Expected<const STBase*, HookReturnCode>
+    otxn_field(uint32_t field_id) const;
+
+    Expected<uint256, HookReturnCode>
+    otxn_id(uint32_t flags) const;
+
+    TxType
+    otxn_type() const;
+
+    Expected<uint32_t, HookReturnCode>
+    otxn_slot(uint32_t slot_into) const;
+
+    Expected<Blob, HookReturnCode>
+    otxn_param(Bytes const& param_name) const;
+
+    /// hook APIs
+    AccountID
+    hook_account() const;
+
+    Expected<ripple::uint256, HookReturnCode>
+    hook_hash(int32_t hook_no) const;
+
+    Expected<int64_t, HookReturnCode>
+    hook_again() const;
+
+    Expected<Blob, HookReturnCode>
+    hook_param(Bytes const& paramName) const;
+
+    Expected<uint64_t, HookReturnCode>
+    hook_param_set(
+        uint256 const& hash,
+        Bytes const& paramName,
+        Bytes const& paramValue) const;
+
+    Expected<uint64_t, HookReturnCode>
+    hook_skip(uint256 const& hash, uint32_t flags) const;
+
+    uint8_t
+    hook_pos() const;
+
+    /// ledger APIs
+    uint64_t
+    fee_base() const;
+
+    uint32_t
+    ledger_seq() const;
+
+    uint256
+    ledger_last_hash() const;
+
+    uint64_t
+    ledger_last_time() const;
+
+    Expected<uint256, HookReturnCode>
+    ledger_nonce() const;
+
+    Expected<Keylet, HookReturnCode>
+    ledger_keylet(Keylet const& klLo, Keylet const& klHi) const;
+
+    /// state APIs
+
+    // state(): same as state_foreign with ns = 0 and account = hook_account()
+
+    Expected<Bytes, HookReturnCode>
+    state_foreign(
+        uint256 const& key,
+        uint256 const& ns,
+        AccountID const& account) const;
+
+    // state_set(): same as state_foreign_set with ns = 0 and account =
+
+    Expected<uint64_t, HookReturnCode>
+    state_foreign_set(
+        uint256 const& key,
+        uint256 const& ns,
+        AccountID const& account,
+        Bytes& data) const;
+
+    /// slot APIs
+    Expected<const STBase*, HookReturnCode>
+    slot(uint32_t slot_no) const;
+
+    Expected<uint64_t, HookReturnCode>
+    slot_clear(uint32_t slot_no) const;
+
+    Expected<uint64_t, HookReturnCode>
+    slot_count(uint32_t slot_no) const;
+
+    Expected<uint32_t, HookReturnCode>
+    slot_set(Bytes const& data, uint32_t slot_no) const;
+
+    Expected<uint64_t, HookReturnCode>
+    slot_size(uint32_t slot_no) const;
+
+    Expected<uint32_t, HookReturnCode>
+    slot_subarray(uint32_t parent_slot, uint32_t array_id, uint32_t new_slot)
+        const;
+
+    Expected<uint32_t, HookReturnCode>
+    slot_subfield(uint32_t parent_slot, uint32_t field_id, uint32_t new_slot)
+        const;
+
+    Expected<std::variant<STBase, STAmount>, HookReturnCode>
+    slot_type(uint32_t slot_no, uint32_t flags) const;
+
+    Expected<uint64_t, HookReturnCode>
+    slot_float(uint32_t slot_no) const;
+
+    /// trace APIs
+    // trace
+    // trace_num
+    // trace_float
+
+    Expected<uint32_t, HookReturnCode>
+    meta_slot(uint32_t slot_into) const;
+
+    Expected<std::pair<uint32_t, uint32_t>, HookReturnCode>
+    xpop_slot(uint32_t slot_into_tx, uint32_t slot_into_meta) const;
+
+private:
+    HookContext& hookCtx;
+
+    inline int32_t
+    no_free_slots() const;
+
+    inline std::optional<int32_t>
+    get_free_slot() const;
+
+    inline Expected<uint64_t, HookReturnCode>
+    float_multiply_internal_parts(
+        uint64_t man1,
+        int32_t exp1,
+        bool neg1,
+        uint64_t man2,
+        int32_t exp2,
+        bool neg2) const;
+
+    inline Expected<uint64_t, HookReturnCode>
+    mulratio_internal(
+        int64_t& man1,
+        int32_t& exp1,
+        bool round_up,
+        uint32_t numerator,
+        uint32_t denominator) const;
+
+    inline Expected<uint64_t, HookReturnCode>
+    float_divide_internal(uint64_t float1, uint64_t float2) const;
+
+    inline Expected<uint64_t, HookReturnCode>
+    double_to_xfl(double x) const;
+
+    std::optional<ripple::Keylet>
+    unserialize_keylet(Bytes const& data) const;
+
+    // update the state cache
+    inline std::optional<
+        std::reference_wrapper<std::pair<bool, ripple::Blob> const>>
+    lookup_state_cache(
+        AccountID const& acc,
+        uint256 const& ns,
+        uint256 const& key) const;
+
+    // check the state cache
+    inline Expected<uint64_t, HookReturnCode>
+    set_state_cache(
+        AccountID const& acc,
+        uint256 const& ns,
+        uint256 const& key,
+        Bytes const& data,
+        bool modified) const;
+
+    // these are only used by get_stobject_length below
+    enum parse_error {
+        pe_unexpected_end = -1,
+        pe_unknown_type_early = -2,  // detected early
+        pe_unknown_type_late = -3,   // end of function
+        pe_excessive_nesting = -4,
+        pe_excessive_size = -5
+    };
+
+    inline Expected<
+        int32_t,
+        parse_error>
+    get_stobject_length(
+        unsigned char* start,     // in - begin iterator
+        unsigned char* maxptr,    // in - end iterator
+        int& type,                // out - populated by serialized type code
+        int& field,               // out - populated by serialized field code
+        int& payload_start,       // out - the start of actual payload data for
+                                  // this type
+        int& payload_length,      // out - the length of actual payload data for
+                                  // this type
+        int recursion_depth = 0)  // used internally
+        const;
+};
+
+}  // namespace hook
+
+#endif  // HOOK_API_INCLUDED

src/ripple/app/hook/Macro.h

@@ -153,6 +153,7 @@
         [[maybe_unused]] const uint64_t memory_length =              \
             WasmEdge_MemoryInstanceGetPageSize(memoryCtx) *          \
             WasmEdge_kPageSize;                                      \
+        [[maybe_unused]] auto& api = hookCtx.api();                  \
         if (!memoryCtx || !memory || !memory_length)                 \
             return INTERNAL_ERROR;
 

src/ripple/app/hook/applyHook.h

@@ -1,6 +1,7 @@
 #ifndef APPLY_HOOK_INCLUDED
 #define APPLY_HOOK_INCLUDED 1
 #include <ripple/app/hook/Enum.h>
+#include <ripple/app/hook/HookAPI.h>
 #include <ripple/app/hook/Macro.h>
 #include <ripple/app/hook/Misc.h>
 #include <ripple/app/misc/Transaction.h>
@@ -132,7 +133,6 @@ struct HookResult
     ripple::uint256 const hookHash;
     ripple::uint256 const hookCanEmit;
     ripple::Keylet const accountKeylet;
-    ripple::Keylet const ownerDirKeylet;
     ripple::Keylet const hookKeylet;
     ripple::AccountID const account;
     ripple::AccountID const otxnAccount;
@@ -209,6 +209,18 @@ struct HookContext
                       // emitted txn then this optional becomes
                       // populated with the SLE
     const HookExecutor* module = 0;
+
+    // Lazy-initialized HookAPI member
+    mutable std::unique_ptr<HookAPI> api_;
+
+    // Access the HookAPI instance (lazy initialization)
+    HookAPI&
+    api() const
+    {
+        if (!api_)
+            api_ = std::make_unique<HookAPI>(const_cast<HookContext&>(*this));
+        return *api_;
+    }
 };
 
 bool

src/ripple/basics/Expected.h

@@ -137,14 +137,14 @@ class [[nodiscard]] Expected
 public:
     template <typename U>
     requires std::convertible_to<U, T> constexpr Expected(U && r)
-        : Base(T(std::forward<U>(r)))
+        : Base(boost::outcome_v2::success(T(std::forward<U>(r))))
     {
     }
 
     template <typename U>
         requires std::convertible_to<U, E> &&
         (!std::is_reference_v<U>)constexpr Expected(Unexpected<U> e)
-        : Base(E(std::move(e.value())))
+        : Base(boost::outcome_v2::failure(E(std::move(e.value()))))
     {
     }
 
@@ -220,7 +220,7 @@ public:
     template <typename U>
         requires std::convertible_to<U, E> &&
         (!std::is_reference_v<U>)constexpr Expected(Unexpected<U> e)
-        : Base(E(std::move(e.value())))
+        : Base(boost::outcome_v2::failure(E(std::move(e.value()))))
     {
     }
 

src/test/app/SetHook_test.cpp

@@ -2579,6 +2579,7 @@ public:
 
         auto const alice = Account{"alice"};
         auto const bob = Account{"bob"};
+
         env.fund(XRP(10000), alice);
         env.fund(XRP(10000), bob);
 
@@ -3094,6 +3095,7 @@ public:
             extern int64_t rollback (uint32_t read_ptr, uint32_t read_len, int64_t error_code);
             extern int64_t etxn_details (uint32_t, uint32_t);
             extern int64_t etxn_reserve(uint32_t);
+            extern int64_t hook_hash (uint32_t, uint32_t, int32_t);
             #define TOO_SMALL -4
             #define OUT_OF_BOUNDS -1
             #define PREREQUISITE_NOT_MET -9
@@ -3116,6 +3118,45 @@ public:
                 etxn_reserve(1);
                 ASSERT(etxn_details((uint32_t)det, 116) == 116);
 
+                uint8_t expected1[49] = {
+                    0xEDU, 0x20U, 0x2EU, 0x00U, 0x00U, 0x00U, 0x01U, 0x3DU, 0x00U, 0x00U,
+                    0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x01U, 0x5BU, 0xB8U, 0x05U, 0xD6U,
+                    0xC3U, 0x52U, 0xDFU, 0x7AU, 0x27U, 0x76U, 0x6DU, 0xC0U, 0x20U, 0x47U,
+                    0xB7U, 0x64U, 0x22U, 0x5AU, 0xB7U, 0x5DU, 0xF3U, 0xFAU, 0x0DU, 0xE3U,
+                    0xBDU, 0xC6U, 0x40U, 0xBAU, 0xD0U, 0x0AU, 0x66U, 0xEBU, 0x68U,
+                };
+                // 0x5CU
+                // EmitNonce 32bytes
+                uint8_t expected_emit_nonce[32] = {
+                    0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU,
+                    0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU,
+                    0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU,
+                    0xFFU, 0xFFU
+                };
+                // 0x5DU, 
+                // EmitHookHash
+                uint8_t expected_hook_hash[32] = {
+                    0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU,
+                    0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU,
+                    0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU,
+                    0xFFU, 0xFFU,
+                };
+                // 0xE1U
+                
+                // current hook hash
+                ASSERT(hook_hash((uint32_t)expected_hook_hash, 32, -1) == 32);
+
+                for (int i = 0; GUARD(49), i < sizeof(expected1); ++i)
+                    ASSERT(det[i] == expected1[i]);
+                ASSERT(det[49] == 0x5CU);
+                // TODO: need to test this
+                // for (int i = 0; GUARD(32), i < sizeof(expected_emit_nonce); ++i)
+                //     ASSERT(det[50 + i] == expected_emit_nonce[i]);
+                ASSERT(det[82] == 0x5DU);
+                for (int i = 0; GUARD(32), i < sizeof(expected_hook_hash); ++i)
+                    ASSERT(det[83 + i] == expected_hook_hash[i]);
+                ASSERT(det[115] == 0xE1);
+
                 return accept(0,0,0);
             }
         )[test.hook]"];
@@ -3280,6 +3321,7 @@ public:
                 }
 
                 ASSERT(etxn_nonce((uint32_t)nonce, 116) == TOO_MANY_NONCES);
+                ASSERT(etxn_nonce((uint32_t)nonce, 31) == TOO_MANY_NONCES);
 
                 return accept(0,0,0);
             }

src/test/app/SetHook_wasm.h

@@ -1168,6 +1168,7 @@ std::map<std::string, std::vector<uint8_t>> wasm = {
             extern int64_t rollback (uint32_t read_ptr, uint32_t read_len, int64_t error_code);
             extern int64_t etxn_details (uint32_t, uint32_t);
             extern int64_t etxn_reserve(uint32_t);
+            extern int64_t hook_hash (uint32_t, uint32_t, int32_t);
             #define TOO_SMALL -4
             #define OUT_OF_BOUNDS -1
             #define PREREQUISITE_NOT_MET -9
@@ -1190,78 +1191,178 @@ std::map<std::string, std::vector<uint8_t>> wasm = {
                 etxn_reserve(1);
                 ASSERT(etxn_details((uint32_t)det, 116) == 116);
 
+                uint8_t expected1[49] = {
+                    0xEDU, 0x20U, 0x2EU, 0x00U, 0x00U, 0x00U, 0x01U, 0x3DU, 0x00U, 0x00U,
+                    0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x01U, 0x5BU, 0xB8U, 0x05U, 0xD6U,
+                    0xC3U, 0x52U, 0xDFU, 0x7AU, 0x27U, 0x76U, 0x6DU, 0xC0U, 0x20U, 0x47U,
+                    0xB7U, 0x64U, 0x22U, 0x5AU, 0xB7U, 0x5DU, 0xF3U, 0xFAU, 0x0DU, 0xE3U,
+                    0xBDU, 0xC6U, 0x40U, 0xBAU, 0xD0U, 0x0AU, 0x66U, 0xEBU, 0x68U,
+                };
+                // 0x5CU
+                // EmitNonce 32bytes
+                uint8_t expected_emit_nonce[32] = {
+                    0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU,
+                    0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU,
+                    0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU,
+                    0xFFU, 0xFFU
+                };
+                // 0x5DU, 
+                // EmitHookHash
+                uint8_t expected_hook_hash[32] = {
+                    0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU,
+                    0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU,
+                    0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU, 0xFFU,
+                    0xFFU, 0xFFU,
+                };
+                // 0xE1U
+                
+                // current hook hash
+                ASSERT(hook_hash((uint32_t)expected_hook_hash, 32, -1) == 32);
+
+                for (int i = 0; GUARD(49), i < sizeof(expected1); ++i)
+                    ASSERT(det[i] == expected1[i]);
+                ASSERT(det[49] == 0x5CU);
+                // TODO: need to test this
+                // for (int i = 0; GUARD(32), i < sizeof(expected_emit_nonce); ++i)
+                //     ASSERT(det[50 + i] == expected_emit_nonce[i]);
+                ASSERT(det[82] == 0x5DU);
+                for (int i = 0; GUARD(32), i < sizeof(expected_hook_hash); ++i)
+                    ASSERT(det[83 + i] == expected_hook_hash[i]);
+                ASSERT(det[115] == 0xE1);
+
                 return accept(0,0,0);
             }
         )[test.hook]",
      {
-         0x00U, 0x61U, 0x73U, 0x6DU, 0x01U, 0x00U, 0x00U, 0x00U, 0x01U, 0x19U,
-         0x04U, 0x60U, 0x02U, 0x7FU, 0x7FU, 0x01U, 0x7FU, 0x60U, 0x02U, 0x7FU,
+         0x00U, 0x61U, 0x73U, 0x6DU, 0x01U, 0x00U, 0x00U, 0x00U, 0x01U, 0x20U,
+         0x05U, 0x60U, 0x02U, 0x7FU, 0x7FU, 0x01U, 0x7FU, 0x60U, 0x02U, 0x7FU,
          0x7FU, 0x01U, 0x7EU, 0x60U, 0x03U, 0x7FU, 0x7FU, 0x7EU, 0x01U, 0x7EU,
-         0x60U, 0x01U, 0x7FU, 0x01U, 0x7EU, 0x02U, 0x4CU, 0x05U, 0x03U, 0x65U,
-         0x6EU, 0x76U, 0x02U, 0x5FU, 0x67U, 0x00U, 0x00U, 0x03U, 0x65U, 0x6EU,
-         0x76U, 0x0CU, 0x65U, 0x74U, 0x78U, 0x6EU, 0x5FU, 0x64U, 0x65U, 0x74U,
-         0x61U, 0x69U, 0x6CU, 0x73U, 0x00U, 0x01U, 0x03U, 0x65U, 0x6EU, 0x76U,
-         0x08U, 0x72U, 0x6FU, 0x6CU, 0x6CU, 0x62U, 0x61U, 0x63U, 0x6BU, 0x00U,
-         0x02U, 0x03U, 0x65U, 0x6EU, 0x76U, 0x0CU, 0x65U, 0x74U, 0x78U, 0x6EU,
-         0x5FU, 0x72U, 0x65U, 0x73U, 0x65U, 0x72U, 0x76U, 0x65U, 0x00U, 0x03U,
-         0x03U, 0x65U, 0x6EU, 0x76U, 0x06U, 0x61U, 0x63U, 0x63U, 0x65U, 0x70U,
-         0x74U, 0x00U, 0x02U, 0x03U, 0x02U, 0x01U, 0x03U, 0x05U, 0x03U, 0x01U,
-         0x00U, 0x02U, 0x06U, 0x21U, 0x05U, 0x7FU, 0x01U, 0x41U, 0xF0U, 0x89U,
-         0x04U, 0x0BU, 0x7FU, 0x00U, 0x41U, 0xE5U, 0x09U, 0x0BU, 0x7FU, 0x00U,
-         0x41U, 0x80U, 0x08U, 0x0BU, 0x7FU, 0x00U, 0x41U, 0xF0U, 0x89U, 0x04U,
-         0x0BU, 0x7FU, 0x00U, 0x41U, 0x80U, 0x08U, 0x0BU, 0x07U, 0x08U, 0x01U,
-         0x04U, 0x68U, 0x6FU, 0x6FU, 0x6BU, 0x00U, 0x05U, 0x0AU, 0x84U, 0x82U,
-         0x00U, 0x01U, 0x80U, 0x82U, 0x00U, 0x02U, 0x01U, 0x7FU, 0x01U, 0x7EU,
-         0x23U, 0x80U, 0x80U, 0x80U, 0x80U, 0x00U, 0x41U, 0x80U, 0x01U, 0x6BU,
-         0x22U, 0x01U, 0x24U, 0x80U, 0x80U, 0x80U, 0x80U, 0x00U, 0x41U, 0x01U,
-         0x41U, 0x01U, 0x10U, 0x80U, 0x80U, 0x80U, 0x80U, 0x00U, 0x1AU, 0x02U,
-         0x40U, 0x41U, 0xC0U, 0x84U, 0x3DU, 0x41U, 0xF4U, 0x00U, 0x10U, 0x81U,
+         0x60U, 0x01U, 0x7FU, 0x01U, 0x7EU, 0x60U, 0x03U, 0x7FU, 0x7FU, 0x7FU,
+         0x01U, 0x7EU, 0x02U, 0x5CU, 0x06U, 0x03U, 0x65U, 0x6EU, 0x76U, 0x02U,
+         0x5FU, 0x67U, 0x00U, 0x00U, 0x03U, 0x65U, 0x6EU, 0x76U, 0x0CU, 0x65U,
+         0x74U, 0x78U, 0x6EU, 0x5FU, 0x64U, 0x65U, 0x74U, 0x61U, 0x69U, 0x6CU,
+         0x73U, 0x00U, 0x01U, 0x03U, 0x65U, 0x6EU, 0x76U, 0x08U, 0x72U, 0x6FU,
+         0x6CU, 0x6CU, 0x62U, 0x61U, 0x63U, 0x6BU, 0x00U, 0x02U, 0x03U, 0x65U,
+         0x6EU, 0x76U, 0x0CU, 0x65U, 0x74U, 0x78U, 0x6EU, 0x5FU, 0x72U, 0x65U,
+         0x73U, 0x65U, 0x72U, 0x76U, 0x65U, 0x00U, 0x03U, 0x03U, 0x65U, 0x6EU,
+         0x76U, 0x09U, 0x68U, 0x6FU, 0x6FU, 0x6BU, 0x5FU, 0x68U, 0x61U, 0x73U,
+         0x68U, 0x00U, 0x04U, 0x03U, 0x65U, 0x6EU, 0x76U, 0x06U, 0x61U, 0x63U,
+         0x63U, 0x65U, 0x70U, 0x74U, 0x00U, 0x02U, 0x03U, 0x02U, 0x01U, 0x03U,
+         0x05U, 0x03U, 0x01U, 0x00U, 0x02U, 0x06U, 0x21U, 0x05U, 0x7FU, 0x01U,
+         0x41U, 0xD0U, 0x8BU, 0x04U, 0x0BU, 0x7FU, 0x00U, 0x41U, 0xC6U, 0x0BU,
+         0x0BU, 0x7FU, 0x00U, 0x41U, 0x80U, 0x08U, 0x0BU, 0x7FU, 0x00U, 0x41U,
+         0xD0U, 0x8BU, 0x04U, 0x0BU, 0x7FU, 0x00U, 0x41U, 0x80U, 0x08U, 0x0BU,
+         0x07U, 0x08U, 0x01U, 0x04U, 0x68U, 0x6FU, 0x6FU, 0x6BU, 0x00U, 0x06U,
+         0x0AU, 0xF4U, 0x84U, 0x00U, 0x01U, 0xF0U, 0x84U, 0x00U, 0x02U, 0x03U,
+         0x7FU, 0x01U, 0x7EU, 0x23U, 0x80U, 0x80U, 0x80U, 0x80U, 0x00U, 0x41U,
+         0xA0U, 0x01U, 0x6BU, 0x22U, 0x01U, 0x24U, 0x80U, 0x80U, 0x80U, 0x80U,
+         0x00U, 0x41U, 0x01U, 0x41U, 0x01U, 0x10U, 0x80U, 0x80U, 0x80U, 0x80U,
+         0x00U, 0x1AU, 0x02U, 0x40U, 0x41U, 0xC0U, 0x84U, 0x3DU, 0x41U, 0xF4U,
+         0x00U, 0x10U, 0x81U, 0x80U, 0x80U, 0x80U, 0x00U, 0x42U, 0x7FU, 0x51U,
+         0x0DU, 0x00U, 0x41U, 0x80U, 0x88U, 0x80U, 0x80U, 0x00U, 0x41U, 0x2CU,
+         0x42U, 0x16U, 0x10U, 0x82U, 0x80U, 0x80U, 0x80U, 0x00U, 0x1AU, 0x0BU,
+         0x02U, 0x40U, 0x41U, 0x00U, 0x41U, 0xC0U, 0x84U, 0x3DU, 0x10U, 0x81U,
          0x80U, 0x80U, 0x80U, 0x00U, 0x42U, 0x7FU, 0x51U, 0x0DU, 0x00U, 0x41U,
-         0x80U, 0x88U, 0x80U, 0x80U, 0x00U, 0x41U, 0x2CU, 0x42U, 0x15U, 0x10U,
-         0x82U, 0x80U, 0x80U, 0x80U, 0x00U, 0x1AU, 0x0BU, 0x02U, 0x40U, 0x41U,
-         0x00U, 0x41U, 0xC0U, 0x84U, 0x3DU, 0x10U, 0x81U, 0x80U, 0x80U, 0x80U,
-         0x00U, 0x42U, 0x7FU, 0x51U, 0x0DU, 0x00U, 0x41U, 0xACU, 0x88U, 0x80U,
-         0x80U, 0x00U, 0x41U, 0x2AU, 0x42U, 0x16U, 0x10U, 0x82U, 0x80U, 0x80U,
-         0x80U, 0x00U, 0x1AU, 0x0BU, 0x02U, 0x40U, 0x20U, 0x01U, 0x41U, 0xF3U,
-         0x00U, 0x10U, 0x81U, 0x80U, 0x80U, 0x80U, 0x00U, 0x42U, 0x7CU, 0x51U,
-         0x0DU, 0x00U, 0x41U, 0xD6U, 0x88U, 0x80U, 0x80U, 0x00U, 0x41U, 0x2EU,
-         0x42U, 0x18U, 0x10U, 0x82U, 0x80U, 0x80U, 0x80U, 0x00U, 0x1AU, 0x0BU,
-         0x02U, 0x40U, 0x20U, 0x01U, 0x41U, 0xF4U, 0x00U, 0x10U, 0x81U, 0x80U,
-         0x80U, 0x80U, 0x00U, 0x42U, 0x77U, 0x51U, 0x0DU, 0x00U, 0x41U, 0x84U,
-         0x89U, 0x80U, 0x80U, 0x00U, 0x41U, 0x39U, 0x42U, 0x1AU, 0x10U, 0x82U,
-         0x80U, 0x80U, 0x80U, 0x00U, 0x1AU, 0x0BU, 0x41U, 0x01U, 0x10U, 0x83U,
-         0x80U, 0x80U, 0x80U, 0x00U, 0x1AU, 0x02U, 0x40U, 0x20U, 0x01U, 0x41U,
-         0xF4U, 0x00U, 0x10U, 0x81U, 0x80U, 0x80U, 0x80U, 0x00U, 0x42U, 0xF4U,
-         0x00U, 0x51U, 0x0DU, 0x00U, 0x41U, 0xBDU, 0x89U, 0x80U, 0x80U, 0x00U,
-         0x41U, 0x28U, 0x42U, 0x1DU, 0x10U, 0x82U, 0x80U, 0x80U, 0x80U, 0x00U,
-         0x1AU, 0x0BU, 0x41U, 0x00U, 0x41U, 0x00U, 0x42U, 0x00U, 0x10U, 0x84U,
-         0x80U, 0x80U, 0x80U, 0x00U, 0x21U, 0x02U, 0x20U, 0x01U, 0x41U, 0x80U,
-         0x01U, 0x6AU, 0x24U, 0x80U, 0x80U, 0x80U, 0x80U, 0x00U, 0x20U, 0x02U,
-         0x0BU, 0x0BU, 0xEDU, 0x01U, 0x01U, 0x00U, 0x41U, 0x80U, 0x08U, 0x0BU,
-         0xE5U, 0x01U, 0x65U, 0x74U, 0x78U, 0x6EU, 0x5FU, 0x64U, 0x65U, 0x74U,
-         0x61U, 0x69U, 0x6CU, 0x73U, 0x28U, 0x31U, 0x30U, 0x30U, 0x30U, 0x30U,
-         0x30U, 0x30U, 0x2CU, 0x20U, 0x31U, 0x31U, 0x36U, 0x29U, 0x20U, 0x3DU,
-         0x3DU, 0x20U, 0x4FU, 0x55U, 0x54U, 0x5FU, 0x4FU, 0x46U, 0x5FU, 0x42U,
-         0x4FU, 0x55U, 0x4EU, 0x44U, 0x53U, 0x00U, 0x65U, 0x74U, 0x78U, 0x6EU,
-         0x5FU, 0x64U, 0x65U, 0x74U, 0x61U, 0x69U, 0x6CU, 0x73U, 0x28U, 0x30U,
-         0x2CU, 0x20U, 0x31U, 0x30U, 0x30U, 0x30U, 0x30U, 0x30U, 0x30U, 0x29U,
-         0x20U, 0x3DU, 0x3DU, 0x20U, 0x4FU, 0x55U, 0x54U, 0x5FU, 0x4FU, 0x46U,
-         0x5FU, 0x42U, 0x4FU, 0x55U, 0x4EU, 0x44U, 0x53U, 0x00U, 0x65U, 0x74U,
-         0x78U, 0x6EU, 0x5FU, 0x64U, 0x65U, 0x74U, 0x61U, 0x69U, 0x6CU, 0x73U,
-         0x28U, 0x28U, 0x75U, 0x69U, 0x6EU, 0x74U, 0x33U, 0x32U, 0x5FU, 0x74U,
-         0x29U, 0x64U, 0x65U, 0x74U, 0x2CU, 0x20U, 0x31U, 0x31U, 0x35U, 0x29U,
-         0x20U, 0x3DU, 0x3DU, 0x20U, 0x54U, 0x4FU, 0x4FU, 0x5FU, 0x53U, 0x4DU,
-         0x41U, 0x4CU, 0x4CU, 0x00U, 0x65U, 0x74U, 0x78U, 0x6EU, 0x5FU, 0x64U,
-         0x65U, 0x74U, 0x61U, 0x69U, 0x6CU, 0x73U, 0x28U, 0x28U, 0x75U, 0x69U,
-         0x6EU, 0x74U, 0x33U, 0x32U, 0x5FU, 0x74U, 0x29U, 0x64U, 0x65U, 0x74U,
-         0x2CU, 0x20U, 0x31U, 0x31U, 0x36U, 0x29U, 0x20U, 0x3DU, 0x3DU, 0x20U,
-         0x50U, 0x52U, 0x45U, 0x52U, 0x45U, 0x51U, 0x55U, 0x49U, 0x53U, 0x49U,
-         0x54U, 0x45U, 0x5FU, 0x4EU, 0x4FU, 0x54U, 0x5FU, 0x4DU, 0x45U, 0x54U,
-         0x00U, 0x65U, 0x74U, 0x78U, 0x6EU, 0x5FU, 0x64U, 0x65U, 0x74U, 0x61U,
-         0x69U, 0x6CU, 0x73U, 0x28U, 0x28U, 0x75U, 0x69U, 0x6EU, 0x74U, 0x33U,
-         0x32U, 0x5FU, 0x74U, 0x29U, 0x64U, 0x65U, 0x74U, 0x2CU, 0x20U, 0x31U,
-         0x31U, 0x36U, 0x29U, 0x20U, 0x3DU, 0x3DU, 0x20U, 0x31U, 0x31U, 0x36U,
-         0x00U,
+         0xACU, 0x88U, 0x80U, 0x80U, 0x00U, 0x41U, 0x2AU, 0x42U, 0x17U, 0x10U,
+         0x82U, 0x80U, 0x80U, 0x80U, 0x00U, 0x1AU, 0x0BU, 0x02U, 0x40U, 0x20U,
+         0x01U, 0x41U, 0x20U, 0x6AU, 0x41U, 0xF3U, 0x00U, 0x10U, 0x81U, 0x80U,
+         0x80U, 0x80U, 0x00U, 0x42U, 0x7CU, 0x51U, 0x0DU, 0x00U, 0x41U, 0xD6U,
+         0x88U, 0x80U, 0x80U, 0x00U, 0x41U, 0x2EU, 0x42U, 0x19U, 0x10U, 0x82U,
+         0x80U, 0x80U, 0x80U, 0x00U, 0x1AU, 0x0BU, 0x02U, 0x40U, 0x20U, 0x01U,
+         0x41U, 0x20U, 0x6AU, 0x41U, 0xF4U, 0x00U, 0x10U, 0x81U, 0x80U, 0x80U,
+         0x80U, 0x00U, 0x42U, 0x77U, 0x51U, 0x0DU, 0x00U, 0x41U, 0x84U, 0x89U,
+         0x80U, 0x80U, 0x00U, 0x41U, 0x39U, 0x42U, 0x1BU, 0x10U, 0x82U, 0x80U,
+         0x80U, 0x80U, 0x00U, 0x1AU, 0x0BU, 0x41U, 0x01U, 0x10U, 0x83U, 0x80U,
+         0x80U, 0x80U, 0x00U, 0x1AU, 0x02U, 0x40U, 0x20U, 0x01U, 0x41U, 0x20U,
+         0x6AU, 0x41U, 0xF4U, 0x00U, 0x10U, 0x81U, 0x80U, 0x80U, 0x80U, 0x00U,
+         0x42U, 0xF4U, 0x00U, 0x51U, 0x0DU, 0x00U, 0x41U, 0xBDU, 0x89U, 0x80U,
+         0x80U, 0x00U, 0x41U, 0x28U, 0x42U, 0x1EU, 0x10U, 0x82U, 0x80U, 0x80U,
+         0x80U, 0x00U, 0x1AU, 0x0BU, 0x20U, 0x01U, 0x41U, 0x18U, 0x6AU, 0x42U,
+         0x7FU, 0x37U, 0x03U, 0x00U, 0x20U, 0x01U, 0x41U, 0x10U, 0x6AU, 0x42U,
+         0x7FU, 0x37U, 0x03U, 0x00U, 0x20U, 0x01U, 0x42U, 0x7FU, 0x37U, 0x03U,
+         0x08U, 0x20U, 0x01U, 0x42U, 0x7FU, 0x37U, 0x03U, 0x00U, 0x02U, 0x40U,
+         0x20U, 0x01U, 0x41U, 0x20U, 0x41U, 0x7FU, 0x10U, 0x84U, 0x80U, 0x80U,
+         0x80U, 0x00U, 0x42U, 0x20U, 0x51U, 0x0DU, 0x00U, 0x41U, 0xA1U, 0x8AU,
+         0x80U, 0x80U, 0x00U, 0x41U, 0x36U, 0x42U, 0x3AU, 0x10U, 0x82U, 0x80U,
+         0x80U, 0x80U, 0x00U, 0x1AU, 0x0BU, 0x41U, 0xBCU, 0x80U, 0x80U, 0x80U,
+         0x78U, 0x41U, 0x32U, 0x10U, 0x80U, 0x80U, 0x80U, 0x80U, 0x00U, 0x1AU,
+         0x41U, 0x00U, 0x21U, 0x02U, 0x03U, 0x40U, 0x41U, 0xBCU, 0x80U, 0x80U,
+         0x80U, 0x78U, 0x41U, 0x32U, 0x10U, 0x80U, 0x80U, 0x80U, 0x80U, 0x00U,
+         0x1AU, 0x02U, 0x40U, 0x20U, 0x01U, 0x41U, 0x20U, 0x6AU, 0x20U, 0x02U,
+         0x6AU, 0x2DU, 0x00U, 0x00U, 0x20U, 0x02U, 0x41U, 0xF0U, 0x89U, 0x80U,
+         0x80U, 0x00U, 0x6AU, 0x2DU, 0x00U, 0x00U, 0x46U, 0x0DU, 0x00U, 0x41U,
+         0xD7U, 0x8AU, 0x80U, 0x80U, 0x00U, 0x41U, 0x17U, 0x42U, 0x3DU, 0x10U,
+         0x82U, 0x80U, 0x80U, 0x80U, 0x00U, 0x1AU, 0x0BU, 0x20U, 0x02U, 0x41U,
+         0x01U, 0x6AU, 0x22U, 0x02U, 0x41U, 0x31U, 0x47U, 0x0DU, 0x00U, 0x0BU,
+         0x02U, 0x40U, 0x20U, 0x01U, 0x2DU, 0x00U, 0x51U, 0x41U, 0xDCU, 0x00U,
+         0x46U, 0x0DU, 0x00U, 0x41U, 0xEEU, 0x8AU, 0x80U, 0x80U, 0x00U, 0x41U,
+         0x11U, 0x42U, 0x3EU, 0x10U, 0x82U, 0x80U, 0x80U, 0x80U, 0x00U, 0x1AU,
+         0x0BU, 0x02U, 0x40U, 0x20U, 0x01U, 0x2DU, 0x00U, 0x72U, 0x41U, 0xDDU,
+         0x00U, 0x46U, 0x0DU, 0x00U, 0x41U, 0xFFU, 0x8AU, 0x80U, 0x80U, 0x00U,
+         0x41U, 0x11U, 0x42U, 0xC2U, 0x00U, 0x10U, 0x82U, 0x80U, 0x80U, 0x80U,
+         0x00U, 0x1AU, 0x0BU, 0x41U, 0xC3U, 0x80U, 0x80U, 0x80U, 0x78U, 0x41U,
+         0x21U, 0x10U, 0x80U, 0x80U, 0x80U, 0x80U, 0x00U, 0x1AU, 0x20U, 0x01U,
+         0x41U, 0xF3U, 0x00U, 0x6AU, 0x21U, 0x03U, 0x41U, 0x00U, 0x21U, 0x02U,
+         0x03U, 0x40U, 0x41U, 0xC3U, 0x80U, 0x80U, 0x80U, 0x78U, 0x41U, 0x21U,
+         0x10U, 0x80U, 0x80U, 0x80U, 0x80U, 0x00U, 0x1AU, 0x02U, 0x40U, 0x20U,
+         0x03U, 0x20U, 0x02U, 0x6AU, 0x2DU, 0x00U, 0x00U, 0x20U, 0x01U, 0x20U,
+         0x02U, 0x6AU, 0x2DU, 0x00U, 0x00U, 0x46U, 0x0DU, 0x00U, 0x41U, 0x90U,
+         0x8BU, 0x80U, 0x80U, 0x00U, 0x41U, 0x25U, 0x42U, 0xC4U, 0x00U, 0x10U,
+         0x82U, 0x80U, 0x80U, 0x80U, 0x00U, 0x1AU, 0x0BU, 0x20U, 0x02U, 0x41U,
+         0x01U, 0x6AU, 0x22U, 0x02U, 0x41U, 0x20U, 0x47U, 0x0DU, 0x00U, 0x0BU,
+         0x02U, 0x40U, 0x20U, 0x01U, 0x2DU, 0x00U, 0x93U, 0x01U, 0x41U, 0xE1U,
+         0x01U, 0x46U, 0x0DU, 0x00U, 0x41U, 0xB5U, 0x8BU, 0x80U, 0x80U, 0x00U,
+         0x41U, 0x11U, 0x42U, 0xC5U, 0x00U, 0x10U, 0x82U, 0x80U, 0x80U, 0x80U,
+         0x00U, 0x1AU, 0x0BU, 0x41U, 0x00U, 0x41U, 0x00U, 0x42U, 0x00U, 0x10U,
+         0x85U, 0x80U, 0x80U, 0x80U, 0x00U, 0x21U, 0x04U, 0x20U, 0x01U, 0x41U,
+         0xA0U, 0x01U, 0x6AU, 0x24U, 0x80U, 0x80U, 0x80U, 0x80U, 0x00U, 0x20U,
+         0x04U, 0x0BU, 0x0BU, 0xCEU, 0x03U, 0x01U, 0x00U, 0x41U, 0x80U, 0x08U,
+         0x0BU, 0xC6U, 0x03U, 0x65U, 0x74U, 0x78U, 0x6EU, 0x5FU, 0x64U, 0x65U,
+         0x74U, 0x61U, 0x69U, 0x6CU, 0x73U, 0x28U, 0x31U, 0x30U, 0x30U, 0x30U,
+         0x30U, 0x30U, 0x30U, 0x2CU, 0x20U, 0x31U, 0x31U, 0x36U, 0x29U, 0x20U,
+         0x3DU, 0x3DU, 0x20U, 0x4FU, 0x55U, 0x54U, 0x5FU, 0x4FU, 0x46U, 0x5FU,
+         0x42U, 0x4FU, 0x55U, 0x4EU, 0x44U, 0x53U, 0x00U, 0x65U, 0x74U, 0x78U,
+         0x6EU, 0x5FU, 0x64U, 0x65U, 0x74U, 0x61U, 0x69U, 0x6CU, 0x73U, 0x28U,
+         0x30U, 0x2CU, 0x20U, 0x31U, 0x30U, 0x30U, 0x30U, 0x30U, 0x30U, 0x30U,
+         0x29U, 0x20U, 0x3DU, 0x3DU, 0x20U, 0x4FU, 0x55U, 0x54U, 0x5FU, 0x4FU,
+         0x46U, 0x5FU, 0x42U, 0x4FU, 0x55U, 0x4EU, 0x44U, 0x53U, 0x00U, 0x65U,
+         0x74U, 0x78U, 0x6EU, 0x5FU, 0x64U, 0x65U, 0x74U, 0x61U, 0x69U, 0x6CU,
+         0x73U, 0x28U, 0x28U, 0x75U, 0x69U, 0x6EU, 0x74U, 0x33U, 0x32U, 0x5FU,
+         0x74U, 0x29U, 0x64U, 0x65U, 0x74U, 0x2CU, 0x20U, 0x31U, 0x31U, 0x35U,
+         0x29U, 0x20U, 0x3DU, 0x3DU, 0x20U, 0x54U, 0x4FU, 0x4FU, 0x5FU, 0x53U,
+         0x4DU, 0x41U, 0x4CU, 0x4CU, 0x00U, 0x65U, 0x74U, 0x78U, 0x6EU, 0x5FU,
+         0x64U, 0x65U, 0x74U, 0x61U, 0x69U, 0x6CU, 0x73U, 0x28U, 0x28U, 0x75U,
+         0x69U, 0x6EU, 0x74U, 0x33U, 0x32U, 0x5FU, 0x74U, 0x29U, 0x64U, 0x65U,
+         0x74U, 0x2CU, 0x20U, 0x31U, 0x31U, 0x36U, 0x29U, 0x20U, 0x3DU, 0x3DU,
+         0x20U, 0x50U, 0x52U, 0x45U, 0x52U, 0x45U, 0x51U, 0x55U, 0x49U, 0x53U,
+         0x49U, 0x54U, 0x45U, 0x5FU, 0x4EU, 0x4FU, 0x54U, 0x5FU, 0x4DU, 0x45U,
+         0x54U, 0x00U, 0x65U, 0x74U, 0x78U, 0x6EU, 0x5FU, 0x64U, 0x65U, 0x74U,
+         0x61U, 0x69U, 0x6CU, 0x73U, 0x28U, 0x28U, 0x75U, 0x69U, 0x6EU, 0x74U,
+         0x33U, 0x32U, 0x5FU, 0x74U, 0x29U, 0x64U, 0x65U, 0x74U, 0x2CU, 0x20U,
+         0x31U, 0x31U, 0x36U, 0x29U, 0x20U, 0x3DU, 0x3DU, 0x20U, 0x31U, 0x31U,
+         0x36U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U,
+         0x00U, 0x00U, 0x00U, 0xEDU, 0x20U, 0x2EU, 0x00U, 0x00U, 0x00U, 0x01U,
+         0x3DU, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x01U, 0x5BU,
+         0xB8U, 0x05U, 0xD6U, 0xC3U, 0x52U, 0xDFU, 0x7AU, 0x27U, 0x76U, 0x6DU,
+         0xC0U, 0x20U, 0x47U, 0xB7U, 0x64U, 0x22U, 0x5AU, 0xB7U, 0x5DU, 0xF3U,
+         0xFAU, 0x0DU, 0xE3U, 0xBDU, 0xC6U, 0x40U, 0xBAU, 0xD0U, 0x0AU, 0x66U,
+         0xEBU, 0x68U, 0x68U, 0x6FU, 0x6FU, 0x6BU, 0x5FU, 0x68U, 0x61U, 0x73U,
+         0x68U, 0x28U, 0x28U, 0x75U, 0x69U, 0x6EU, 0x74U, 0x33U, 0x32U, 0x5FU,
+         0x74U, 0x29U, 0x65U, 0x78U, 0x70U, 0x65U, 0x63U, 0x74U, 0x65U, 0x64U,
+         0x5FU, 0x68U, 0x6FU, 0x6FU, 0x6BU, 0x5FU, 0x68U, 0x61U, 0x73U, 0x68U,
+         0x2CU, 0x20U, 0x33U, 0x32U, 0x2CU, 0x20U, 0x2DU, 0x31U, 0x29U, 0x20U,
+         0x3DU, 0x3DU, 0x20U, 0x33U, 0x32U, 0x00U, 0x64U, 0x65U, 0x74U, 0x5BU,
+         0x69U, 0x5DU, 0x20U, 0x3DU, 0x3DU, 0x20U, 0x65U, 0x78U, 0x70U, 0x65U,
+         0x63U, 0x74U, 0x65U, 0x64U, 0x31U, 0x5BU, 0x69U, 0x5DU, 0x00U, 0x64U,
+         0x65U, 0x74U, 0x5BU, 0x34U, 0x39U, 0x5DU, 0x20U, 0x3DU, 0x3DU, 0x20U,
+         0x30U, 0x78U, 0x35U, 0x43U, 0x55U, 0x00U, 0x64U, 0x65U, 0x74U, 0x5BU,
+         0x38U, 0x32U, 0x5DU, 0x20U, 0x3DU, 0x3DU, 0x20U, 0x30U, 0x78U, 0x35U,
+         0x44U, 0x55U, 0x00U, 0x64U, 0x65U, 0x74U, 0x5BU, 0x38U, 0x33U, 0x20U,
+         0x2BU, 0x20U, 0x69U, 0x5DU, 0x20U, 0x3DU, 0x3DU, 0x20U, 0x65U, 0x78U,
+         0x70U, 0x65U, 0x63U, 0x74U, 0x65U, 0x64U, 0x5FU, 0x68U, 0x6FU, 0x6FU,
+         0x6BU, 0x5FU, 0x68U, 0x61U, 0x73U, 0x68U, 0x5BU, 0x69U, 0x5DU, 0x00U,
+         0x64U, 0x65U, 0x74U, 0x5BU, 0x31U, 0x31U, 0x35U, 0x5DU, 0x20U, 0x3DU,
+         0x3DU, 0x20U, 0x30U, 0x78U, 0x45U, 0x31U, 0x00U,
      }},
 
     /* ==== WASM: 8 ==== */
@@ -1422,6 +1523,7 @@ std::map<std::string, std::vector<uint8_t>> wasm = {
                 }
 
                 ASSERT(etxn_nonce((uint32_t)nonce, 116) == TOO_MANY_NONCES);
+                ASSERT(etxn_nonce((uint32_t)nonce, 31) == TOO_MANY_NONCES);
 
                 return accept(0,0,0);
             }
@@ -1437,12 +1539,12 @@ std::map<std::string, std::vector<uint8_t>> wasm = {
          0x6FU, 0x6CU, 0x6CU, 0x62U, 0x61U, 0x63U, 0x6BU, 0x00U, 0x02U, 0x03U,
          0x65U, 0x6EU, 0x76U, 0x06U, 0x61U, 0x63U, 0x63U, 0x65U, 0x70U, 0x74U,
          0x00U, 0x02U, 0x03U, 0x02U, 0x01U, 0x03U, 0x05U, 0x03U, 0x01U, 0x00U,
-         0x02U, 0x06U, 0x21U, 0x05U, 0x7FU, 0x01U, 0x41U, 0xA0U, 0x8AU, 0x04U,
-         0x0BU, 0x7FU, 0x00U, 0x41U, 0x9EU, 0x0AU, 0x0BU, 0x7FU, 0x00U, 0x41U,
-         0x80U, 0x08U, 0x0BU, 0x7FU, 0x00U, 0x41U, 0xA0U, 0x8AU, 0x04U, 0x0BU,
+         0x02U, 0x06U, 0x21U, 0x05U, 0x7FU, 0x01U, 0x41U, 0xE0U, 0x8AU, 0x04U,
+         0x0BU, 0x7FU, 0x00U, 0x41U, 0xD1U, 0x0AU, 0x0BU, 0x7FU, 0x00U, 0x41U,
+         0x80U, 0x08U, 0x0BU, 0x7FU, 0x00U, 0x41U, 0xE0U, 0x8AU, 0x04U, 0x0BU,
          0x7FU, 0x00U, 0x41U, 0x80U, 0x08U, 0x0BU, 0x07U, 0x08U, 0x01U, 0x04U,
-         0x68U, 0x6FU, 0x6FU, 0x6BU, 0x00U, 0x04U, 0x0AU, 0xE1U, 0x82U, 0x00U,
-         0x01U, 0xDDU, 0x82U, 0x00U, 0x02U, 0x02U, 0x7FU, 0x01U, 0x7EU, 0x23U,
+         0x68U, 0x6FU, 0x6FU, 0x6BU, 0x00U, 0x04U, 0x0AU, 0x84U, 0x83U, 0x00U,
+         0x01U, 0x80U, 0x83U, 0x00U, 0x02U, 0x02U, 0x7FU, 0x01U, 0x7EU, 0x23U,
          0x80U, 0x80U, 0x80U, 0x80U, 0x00U, 0x41U, 0xC0U, 0x00U, 0x6BU, 0x22U,
          0x01U, 0x24U, 0x80U, 0x80U, 0x80U, 0x80U, 0x00U, 0x41U, 0x01U, 0x41U,
          0x01U, 0x10U, 0x80U, 0x80U, 0x80U, 0x80U, 0x00U, 0x1AU, 0x02U, 0x40U,
@@ -1474,39 +1576,48 @@ std::map<std::string, std::vector<uint8_t>> wasm = {
          0x20U, 0x01U, 0x41U, 0xF4U, 0x00U, 0x10U, 0x81U, 0x80U, 0x80U, 0x80U,
          0x00U, 0x42U, 0x74U, 0x51U, 0x0DU, 0x00U, 0x41U, 0xEAU, 0x89U, 0x80U,
          0x80U, 0x00U, 0x41U, 0x34U, 0x42U, 0x23U, 0x10U, 0x82U, 0x80U, 0x80U,
-         0x80U, 0x00U, 0x1AU, 0x0BU, 0x41U, 0x00U, 0x41U, 0x00U, 0x42U, 0x00U,
-         0x10U, 0x83U, 0x80U, 0x80U, 0x80U, 0x00U, 0x21U, 0x03U, 0x20U, 0x01U,
-         0x41U, 0xC0U, 0x00U, 0x6AU, 0x24U, 0x80U, 0x80U, 0x80U, 0x80U, 0x00U,
-         0x20U, 0x03U, 0x0BU, 0x0BU, 0xA6U, 0x02U, 0x01U, 0x00U, 0x41U, 0x80U,
-         0x08U, 0x0BU, 0x9EU, 0x02U, 0x65U, 0x74U, 0x78U, 0x6EU, 0x5FU, 0x6EU,
-         0x6FU, 0x6EU, 0x63U, 0x65U, 0x28U, 0x31U, 0x30U, 0x30U, 0x30U, 0x30U,
-         0x30U, 0x30U, 0x2CU, 0x20U, 0x31U, 0x31U, 0x36U, 0x29U, 0x20U, 0x3DU,
-         0x3DU, 0x20U, 0x4FU, 0x55U, 0x54U, 0x5FU, 0x4FU, 0x46U, 0x5FU, 0x42U,
-         0x4FU, 0x55U, 0x4EU, 0x44U, 0x53U, 0x00U, 0x65U, 0x74U, 0x78U, 0x6EU,
-         0x5FU, 0x6EU, 0x6FU, 0x6EU, 0x63U, 0x65U, 0x28U, 0x30U, 0x2CU, 0x20U,
-         0x31U, 0x30U, 0x30U, 0x30U, 0x30U, 0x30U, 0x30U, 0x29U, 0x20U, 0x3DU,
-         0x3DU, 0x20U, 0x4FU, 0x55U, 0x54U, 0x5FU, 0x4FU, 0x46U, 0x5FU, 0x42U,
-         0x4FU, 0x55U, 0x4EU, 0x44U, 0x53U, 0x00U, 0x65U, 0x74U, 0x78U, 0x6EU,
-         0x5FU, 0x6EU, 0x6FU, 0x6EU, 0x63U, 0x65U, 0x28U, 0x28U, 0x75U, 0x69U,
-         0x6EU, 0x74U, 0x33U, 0x32U, 0x5FU, 0x74U, 0x29U, 0x6EU, 0x6FU, 0x6EU,
-         0x63U, 0x65U, 0x2CU, 0x20U, 0x33U, 0x31U, 0x29U, 0x20U, 0x3DU, 0x3DU,
-         0x20U, 0x54U, 0x4FU, 0x4FU, 0x5FU, 0x53U, 0x4DU, 0x41U, 0x4CU, 0x4CU,
+         0x80U, 0x00U, 0x1AU, 0x0BU, 0x02U, 0x40U, 0x20U, 0x01U, 0x41U, 0x1FU,
+         0x10U, 0x81U, 0x80U, 0x80U, 0x80U, 0x00U, 0x42U, 0x74U, 0x51U, 0x0DU,
+         0x00U, 0x41U, 0x9EU, 0x8AU, 0x80U, 0x80U, 0x00U, 0x41U, 0x33U, 0x42U,
+         0x24U, 0x10U, 0x82U, 0x80U, 0x80U, 0x80U, 0x00U, 0x1AU, 0x0BU, 0x41U,
+         0x00U, 0x41U, 0x00U, 0x42U, 0x00U, 0x10U, 0x83U, 0x80U, 0x80U, 0x80U,
+         0x00U, 0x21U, 0x03U, 0x20U, 0x01U, 0x41U, 0xC0U, 0x00U, 0x6AU, 0x24U,
+         0x80U, 0x80U, 0x80U, 0x80U, 0x00U, 0x20U, 0x03U, 0x0BU, 0x0BU, 0xD9U,
+         0x02U, 0x01U, 0x00U, 0x41U, 0x80U, 0x08U, 0x0BU, 0xD1U, 0x02U, 0x65U,
+         0x74U, 0x78U, 0x6EU, 0x5FU, 0x6EU, 0x6FU, 0x6EU, 0x63U, 0x65U, 0x28U,
+         0x31U, 0x30U, 0x30U, 0x30U, 0x30U, 0x30U, 0x30U, 0x2CU, 0x20U, 0x31U,
+         0x31U, 0x36U, 0x29U, 0x20U, 0x3DU, 0x3DU, 0x20U, 0x4FU, 0x55U, 0x54U,
+         0x5FU, 0x4FU, 0x46U, 0x5FU, 0x42U, 0x4FU, 0x55U, 0x4EU, 0x44U, 0x53U,
+         0x00U, 0x65U, 0x74U, 0x78U, 0x6EU, 0x5FU, 0x6EU, 0x6FU, 0x6EU, 0x63U,
+         0x65U, 0x28U, 0x30U, 0x2CU, 0x20U, 0x31U, 0x30U, 0x30U, 0x30U, 0x30U,
+         0x30U, 0x30U, 0x29U, 0x20U, 0x3DU, 0x3DU, 0x20U, 0x4FU, 0x55U, 0x54U,
+         0x5FU, 0x4FU, 0x46U, 0x5FU, 0x42U, 0x4FU, 0x55U, 0x4EU, 0x44U, 0x53U,
          0x00U, 0x65U, 0x74U, 0x78U, 0x6EU, 0x5FU, 0x6EU, 0x6FU, 0x6EU, 0x63U,
          0x65U, 0x28U, 0x28U, 0x75U, 0x69U, 0x6EU, 0x74U, 0x33U, 0x32U, 0x5FU,
-         0x74U, 0x29U, 0x6EU, 0x6FU, 0x6EU, 0x63U, 0x65U, 0x20U, 0x2BU, 0x20U,
-         0x28U, 0x28U, 0x69U, 0x20U, 0x25U, 0x20U, 0x32U, 0x29U, 0x20U, 0x2AU,
-         0x20U, 0x33U, 0x32U, 0x29U, 0x2CU, 0x20U, 0x33U, 0x32U, 0x29U, 0x20U,
-         0x3DU, 0x3DU, 0x20U, 0x33U, 0x32U, 0x00U, 0x21U, 0x28U, 0x2AU, 0x28U,
-         0x6EU, 0x31U, 0x20U, 0x2BU, 0x20U, 0x30U, 0x29U, 0x20U, 0x3DU, 0x3DU,
-         0x20U, 0x2AU, 0x28U, 0x6EU, 0x32U, 0x20U, 0x2BU, 0x20U, 0x30U, 0x29U,
-         0x20U, 0x26U, 0x26U, 0x20U, 0x2AU, 0x28U, 0x6EU, 0x31U, 0x20U, 0x2BU,
-         0x20U, 0x31U, 0x29U, 0x20U, 0x3DU, 0x3DU, 0x20U, 0x2AU, 0x28U, 0x6EU,
-         0x32U, 0x20U, 0x2BU, 0x20U, 0x31U, 0x29U, 0x29U, 0x00U, 0x65U, 0x74U,
-         0x78U, 0x6EU, 0x5FU, 0x6EU, 0x6FU, 0x6EU, 0x63U, 0x65U, 0x28U, 0x28U,
-         0x75U, 0x69U, 0x6EU, 0x74U, 0x33U, 0x32U, 0x5FU, 0x74U, 0x29U, 0x6EU,
-         0x6FU, 0x6EU, 0x63U, 0x65U, 0x2CU, 0x20U, 0x31U, 0x31U, 0x36U, 0x29U,
-         0x20U, 0x3DU, 0x3DU, 0x20U, 0x54U, 0x4FU, 0x4FU, 0x5FU, 0x4DU, 0x41U,
-         0x4EU, 0x59U, 0x5FU, 0x4EU, 0x4FU, 0x4EU, 0x43U, 0x45U, 0x53U, 0x00U,
+         0x74U, 0x29U, 0x6EU, 0x6FU, 0x6EU, 0x63U, 0x65U, 0x2CU, 0x20U, 0x33U,
+         0x31U, 0x29U, 0x20U, 0x3DU, 0x3DU, 0x20U, 0x54U, 0x4FU, 0x4FU, 0x5FU,
+         0x53U, 0x4DU, 0x41U, 0x4CU, 0x4CU, 0x00U, 0x65U, 0x74U, 0x78U, 0x6EU,
+         0x5FU, 0x6EU, 0x6FU, 0x6EU, 0x63U, 0x65U, 0x28U, 0x28U, 0x75U, 0x69U,
+         0x6EU, 0x74U, 0x33U, 0x32U, 0x5FU, 0x74U, 0x29U, 0x6EU, 0x6FU, 0x6EU,
+         0x63U, 0x65U, 0x20U, 0x2BU, 0x20U, 0x28U, 0x28U, 0x69U, 0x20U, 0x25U,
+         0x20U, 0x32U, 0x29U, 0x20U, 0x2AU, 0x20U, 0x33U, 0x32U, 0x29U, 0x2CU,
+         0x20U, 0x33U, 0x32U, 0x29U, 0x20U, 0x3DU, 0x3DU, 0x20U, 0x33U, 0x32U,
+         0x00U, 0x21U, 0x28U, 0x2AU, 0x28U, 0x6EU, 0x31U, 0x20U, 0x2BU, 0x20U,
+         0x30U, 0x29U, 0x20U, 0x3DU, 0x3DU, 0x20U, 0x2AU, 0x28U, 0x6EU, 0x32U,
+         0x20U, 0x2BU, 0x20U, 0x30U, 0x29U, 0x20U, 0x26U, 0x26U, 0x20U, 0x2AU,
+         0x28U, 0x6EU, 0x31U, 0x20U, 0x2BU, 0x20U, 0x31U, 0x29U, 0x20U, 0x3DU,
+         0x3DU, 0x20U, 0x2AU, 0x28U, 0x6EU, 0x32U, 0x20U, 0x2BU, 0x20U, 0x31U,
+         0x29U, 0x29U, 0x00U, 0x65U, 0x74U, 0x78U, 0x6EU, 0x5FU, 0x6EU, 0x6FU,
+         0x6EU, 0x63U, 0x65U, 0x28U, 0x28U, 0x75U, 0x69U, 0x6EU, 0x74U, 0x33U,
+         0x32U, 0x5FU, 0x74U, 0x29U, 0x6EU, 0x6FU, 0x6EU, 0x63U, 0x65U, 0x2CU,
+         0x20U, 0x31U, 0x31U, 0x36U, 0x29U, 0x20U, 0x3DU, 0x3DU, 0x20U, 0x54U,
+         0x4FU, 0x4FU, 0x5FU, 0x4DU, 0x41U, 0x4EU, 0x59U, 0x5FU, 0x4EU, 0x4FU,
+         0x4EU, 0x43U, 0x45U, 0x53U, 0x00U, 0x65U, 0x74U, 0x78U, 0x6EU, 0x5FU,
+         0x6EU, 0x6FU, 0x6EU, 0x63U, 0x65U, 0x28U, 0x28U, 0x75U, 0x69U, 0x6EU,
+         0x74U, 0x33U, 0x32U, 0x5FU, 0x74U, 0x29U, 0x6EU, 0x6FU, 0x6EU, 0x63U,
+         0x65U, 0x2CU, 0x20U, 0x33U, 0x31U, 0x29U, 0x20U, 0x3DU, 0x3DU, 0x20U,
+         0x54U, 0x4FU, 0x4FU, 0x5FU, 0x4DU, 0x41U, 0x4EU, 0x59U, 0x5FU, 0x4EU,
+         0x4FU, 0x4EU, 0x43U, 0x45U, 0x53U, 0x00U,
      }},
 
     /* ==== WASM: 10 ==== */

src/test/jtx/hook.h

@@ -20,9 +20,13 @@
 #ifndef RIPPLE_TEST_JTX_HOOK_H_INCLUDED
 #define RIPPLE_TEST_JTX_HOOK_H_INCLUDED
 
+#include <ripple/app/hook/applyHook.h>
 #include <ripple/json/json_value.h>
+#include <cstdint>
+#include <map>
 #include <optional>
 #include <test/jtx/Account.h>
+#include <vector>
 
 namespace ripple {
 namespace test {
@@ -43,6 +47,75 @@ hso(std::string const& wasmHex, void (*f)(Json::Value& jv) = 0);
 Json::Value
 hso_delete(void (*f)(Json::Value& jv) = 0);
 
+struct StubHookResult
+{
+    ripple::uint256 const hookSetTxnID = ripple::uint256();
+    ripple::uint256 const hookHash = ripple::uint256();
+    ripple::uint256 const hookCanEmit = ripple::uint256();
+    ripple::uint256 const hookNamespace = ripple::uint256();
+
+    std::queue<std::shared_ptr<ripple::Transaction>> emittedTxn{};
+    std::optional<hook::HookStateMap> stateMap = std::nullopt;
+    uint16_t changedStateCount = 0;
+    std::map<
+        ripple::uint256,  // hook hash
+        std::map<
+            std::vector<uint8_t>,  // hook param name
+            std::vector<uint8_t>   // hook param value
+            >>
+        hookParamOverrides = {};
+
+    std::optional<std::map<std::vector<uint8_t>, std::vector<uint8_t>>>
+        hookParams = std::nullopt;
+    std::set<ripple::uint256> hookSkips = {};
+    hook_api::ExitType exitType = hook_api::ExitType::ROLLBACK;
+    std::string exitReason{""};
+    int64_t exitCode{-1};
+    uint64_t instructionCount{0};
+    bool hasCallback = false;
+    bool isCallback = false;
+    bool isStrong = false;
+    uint32_t wasmParam = 0;
+    uint32_t overrideCount = 0;
+    uint8_t hookChainPosition = 0;
+    bool foreignStateSetDisabled = false;
+    bool executeAgainAsWeak = false;
+    std::shared_ptr<STObject const> provisionalMeta = nullptr;
+};
+
+struct StubHookContext
+{
+    std::map<uint32_t, hook::SlotEntry> slot{};
+    std::queue<uint32_t> slot_free{};
+    uint32_t slot_counter{0};
+    uint16_t emit_nonce_counter{0};
+    uint16_t ledger_nonce_counter{0};
+    int64_t expected_etxn_count{-1};
+    std::map<ripple::uint256, bool> nonce_used{};
+    uint32_t generation = 0;
+    uint64_t burden = 0;
+    std::map<uint32_t, uint32_t> guard_map{};
+    StubHookResult result = {};
+    std::optional<ripple::STObject> emitFailure = std::nullopt;
+    const hook::HookExecutor* module = 0;
+};
+
+// Overload that takes external stateMap to avoid dangling reference
+hook::HookContext
+makeStubHookContext(
+    ripple::ApplyContext& applyCtx,
+    ripple::AccountID const& hookAccount,
+    ripple::AccountID const& otxnAccount,
+    StubHookContext const& stubHookContext,
+    hook::HookStateMap& stateMap);
+
+hook::HookContext
+makeStubHookContext(
+    ripple::ApplyContext& applyCtx,
+    ripple::AccountID const& hookAccount,
+    ripple::AccountID const& otxnAccount,
+    StubHookContext const& stubHookContext);
+
 }  // namespace jtx
 }  // namespace test
 }  // namespace ripple

src/test/jtx/impl/hook.cpp

@@ -18,7 +18,9 @@
 //==============================================================================
 
 #include <ripple/app/hook/Enum.h>
+#include <ripple/app/hook/applyHook.h>
 #include <ripple/basics/contract.h>
+#include <ripple/protocol/Keylet.h>
 #include <ripple/protocol/jss.h>
 #include <stdexcept>
 #include <test/jtx/hook.h>
@@ -102,6 +104,81 @@ hso(std::string const& wasmHex, void (*f)(Json::Value& jv))
     return jv;
 }
 
+// Helper function to create HookContext with external stateMap
+hook::HookContext
+makeStubHookContext(
+    ripple::ApplyContext& applyCtx,
+    ripple::AccountID const& hookAccount,
+    ripple::AccountID const& otxnAccount,
+    StubHookContext const& stubHookContext,
+    hook::HookStateMap& stateMap)
+{
+    auto& result = stubHookContext.result;
+    auto hookParams = result.hookParams.value_or(
+        std::map<std::vector<uint8_t>, std::vector<uint8_t>>{});
+    return hook::HookContext{
+        .applyCtx = applyCtx,
+        .slot = stubHookContext.slot,
+        .slot_free = stubHookContext.slot_free,
+        .slot_counter = stubHookContext.slot_counter,
+        .emit_nonce_counter = stubHookContext.emit_nonce_counter,
+        .ledger_nonce_counter = stubHookContext.ledger_nonce_counter,
+        .expected_etxn_count = stubHookContext.expected_etxn_count,
+        .nonce_used = stubHookContext.nonce_used,
+        .generation = stubHookContext.generation,
+        .burden = stubHookContext.burden,
+        .guard_map = stubHookContext.guard_map,
+        .result =
+            {
+                .hookSetTxnID = result.hookSetTxnID,
+                .hookHash = result.hookHash,
+                .hookCanEmit = result.hookCanEmit,
+                .accountKeylet = keylet::account(hookAccount),
+                .hookKeylet = keylet::hook(hookAccount),
+                .account = hookAccount,
+                .otxnAccount = otxnAccount,
+                .hookNamespace = result.hookNamespace,
+                .emittedTxn = result.emittedTxn,
+                .stateMap = stateMap,
+                .changedStateCount = result.changedStateCount,
+                .hookParamOverrides = result.hookParamOverrides,
+                .hookParams = hookParams,
+                .hookSkips = result.hookSkips,
+                .exitType = result.exitType,
+                .exitReason = result.exitReason,
+                .exitCode = result.exitCode,
+                .instructionCount = result.instructionCount,
+                .hasCallback = result.hasCallback,
+                .isCallback = result.isCallback,
+                .isStrong = result.isStrong,
+                .wasmParam = result.wasmParam,
+                .overrideCount = result.overrideCount,
+                .hookChainPosition = result.hookChainPosition,
+                .foreignStateSetDisabled = result.foreignStateSetDisabled,
+                .executeAgainAsWeak = result.executeAgainAsWeak,
+                .provisionalMeta = result.provisionalMeta,
+            },
+        .emitFailure = stubHookContext.emitFailure,
+        .module = nullptr};
+}
+
+// Original function - WARNING: stateMap reference may become dangling
+// Only use when stateMap access is not needed after HookContext creation
+hook::HookContext
+makeStubHookContext(
+    ripple::ApplyContext& applyCtx,
+    ripple::AccountID const& hookAccount,
+    ripple::AccountID const& otxnAccount,
+    StubHookContext const& stubHookContext)
+{
+    // Use thread_local to keep stateMap alive
+    // Note: This is a workaround; each call resets the stateMap
+    thread_local hook::HookStateMap stateMap;
+    stateMap = stubHookContext.result.stateMap.value_or(hook::HookStateMap{});
+    return makeStubHookContext(
+        applyCtx, hookAccount, otxnAccount, stubHookContext, stateMap);
+}
+
 }  // namespace jtx
 }  // namespace test
 }  // namespace ripple