Merge remote-tracking branch 'upstream/dev' into hook-helper-func

.gitignore

@@ -129,3 +129,6 @@ generated
 
 # Suggested in-tree build directory
 /.build/
+
+guard_checker
+guard_checker.dSYM

hook/sfcodes.h

@@ -240,7 +240,6 @@
 #define sfLockingChainDoor ((8U << 16U) + 22U)
 #define sfIssuingChainDoor ((8U << 16U) + 23U)
 #define sfSubject ((8U << 16U) + 24U)
-#define sfHookAdministrator ((8U << 16U) + 98U)
 #define sfInform ((8U << 16U) + 99U)
 #define sfIndexes ((19U << 16U) + 1U)
 #define sfHashes ((19U << 16U) + 2U)

include/xrpl/hook/Guard.h

@@ -5,6 +5,7 @@
 #include <memory>
 #include <optional>
 #include <ostream>
+#include <set>
 #include <stack>
 #include <string>
 #include <string_view>
@@ -282,7 +283,8 @@ check_guard(
      * might have unforeseen consequences, without also rolling back further
      * changes that are fine.
      */
-    uint64_t rulesVersion = 0
+    uint64_t rulesVersion = 0,
+    std::set<int>* out_callees = nullptr
 
 )
 {
@@ -492,17 +494,27 @@ check_guard(
         {
             REQUIRE(1);
             uint64_t callee_idx = LEB();
-            // disallow calling of user defined functions inside a hook
+
+            // record user-defined function calls if tracking is enabled
             if (callee_idx > last_import_idx)
             {
-                GUARDLOG(hook::log::CALL_ILLEGAL)
-                    << "GuardCheck "
-                    << "Hook calls a function outside of the whitelisted "
-                       "imports "
-                    << "codesec: " << codesec << " hook byte offset: " << i
-                    << "\n";
+                if (out_callees != nullptr)
+                {
+                    // record the callee for call graph analysis
+                    out_callees->insert(callee_idx);
+                }
+                else
+                {
+                    // if not tracking, maintain original behavior: reject
+                    GUARDLOG(hook::log::CALL_ILLEGAL)
+                        << "GuardCheck "
+                        << "Hook calls a function outside of the whitelisted "
+                           "imports "
+                        << "codesec: " << codesec << " hook byte offset: " << i
+                        << "\n";
 
-                return {};
+                    return {};
+                }
             }
 
             // enforce guard call limit
@@ -838,6 +850,42 @@ validateGuards(
      */
     uint64_t rulesVersion = 0x00)
 {
+    // Structure to track function call graph information
+    struct FunctionInfo
+    {
+        int func_idx;
+        std::set<int> callees;  // functions this function calls
+        std::set<int> callers;  // functions that call this function
+        bool has_loops;         // whether this function contains loops
+        uint64_t local_wce;     // local worst-case execution count
+        uint64_t total_wce;     // total WCE including callees
+        bool wce_calculated;    // whether total_wce has been computed
+        bool in_calculation;    // for cycle detection in WCE calculation
+
+        FunctionInfo()
+            : func_idx(-1)
+            , has_loops(false)
+            , local_wce(0)
+            , total_wce(0)
+            , wce_calculated(false)
+            , in_calculation(false)
+        {
+        }
+
+        FunctionInfo(int idx, uint64_t local_wce_val, bool has_loops_val)
+            : func_idx(idx)
+            , has_loops(has_loops_val)
+            , local_wce(local_wce_val)
+            , total_wce(0)
+            , wce_calculated(false)
+            , in_calculation(false)
+        {
+        }
+    };
+
+    // Call graph: maps function index to its information
+    std::map<int, FunctionInfo> call_graph;
+
     uint64_t byteCount = wasm.size();
 
     // 63 bytes is the smallest possible valid hook wasm
@@ -1170,6 +1218,12 @@ validateGuards(
                 if (DEBUG_GUARD)
                     printf("Function map: func %d -> type %d\n", j, type_idx);
                 func_type_map[j] = type_idx;
+
+                // Step 4: Initialize FunctionInfo for each user-defined
+                // function func_idx starts from last_import_number + 1
+                int actual_func_idx = last_import_number + 1 + j;
+                call_graph[actual_func_idx] = FunctionInfo();
+                call_graph[actual_func_idx].func_idx = actual_func_idx;
             }
         }
 
@@ -1211,9 +1265,6 @@ validateGuards(
         return {};
     }
 
-    int64_t maxInstrCountHook = 0;
-    int64_t maxInstrCountCbak = 0;
-
     // second pass... where we check all the guard function calls follow the
     // guard rules minimal other validation in this pass because first pass
     // caught most of it
@@ -1247,6 +1298,7 @@ validateGuards(
                 std::optional<
                     std::reference_wrapper<std::vector<uint8_t> const>>
                     first_signature;
+                bool helper_function = false;
                 if (auto const& usage = import_type_map.find(j);
                     usage != import_type_map.end())
                 {
@@ -1278,7 +1330,7 @@ validateGuards(
                         }
                     }
                 }
-                else if (j == hook_type_idx)
+                else if (j == hook_type_idx)  // hook() or cbak() function type
                 {
                     // pass
                 }
@@ -1291,7 +1343,8 @@ validateGuards(
                         << "Codesec: " << section_type << " "
                         << "Local: " << j << " "
                         << "Offset: " << i << "\n";
-                    return {};
+                    // return {};
+                    helper_function = true;
                 }
 
                 int param_count = parseLeb128(wasm, i, &i);
@@ -1308,12 +1361,19 @@ validateGuards(
                         return {};
                     }
                 }
+                else if (helper_function)
+                {
+                    // pass
+                }
                 else if (param_count != (*first_signature).get().size() - 1)
                 {
                     GUARDLOG(hook::log::FUNC_TYPE_INVALID)
                         << "Malformed transaction. "
                         << "Hook API: " << *first_name
-                        << " has the wrong number of parameters.\n";
+                        << " has the wrong number of parameters.\n"
+                        << "param_count: " << param_count << " "
+                        << "first_signature: "
+                        << (*first_signature).get().size() - 1 << "\n";
                     return {};
                 }
 
@@ -1360,6 +1420,10 @@ validateGuards(
                             return {};
                         }
                     }
+                    else if (helper_function)
+                    {
+                        // pass
+                    }
                     else if ((*first_signature).get()[k + 1] != param_type)
                     {
                         GUARDLOG(hook::log::FUNC_PARAM_INVALID)
@@ -1436,6 +1500,10 @@ validateGuards(
                             return {};
                         }
                     }
+                    else if (helper_function)
+                    {
+                        // pass
+                    }
                     else if ((*first_signature).get()[0] != result_type)
                     {
                         GUARDLOG(hook::log::FUNC_RETURN_INVALID)
@@ -1487,6 +1555,17 @@ validateGuards(
                 // execution to here means we are up to the actual expr for the
                 // codesec/function
 
+                // Step 5: Calculate actual function index and prepare callees
+                // tracking
+                int actual_func_idx = last_import_number + 1 + j;
+                std::set<int>* out_callees_ptr = nullptr;
+
+                // Only track callees if this function is in the call_graph
+                if (call_graph.find(actual_func_idx) != call_graph.end())
+                {
+                    out_callees_ptr = &call_graph[actual_func_idx].callees;
+                }
+
                 auto valid = check_guard(
                     wasm,
                     j,
@@ -1496,33 +1575,188 @@ validateGuards(
                     last_import_number,
                     guardLog,
                     guardLogAccStr,
-                    rulesVersion);
+                    rulesVersion,
+                    out_callees_ptr);
 
                 if (!valid)
                     return {};
 
-                if (hook_func_idx && *hook_func_idx == j)
-                    maxInstrCountHook = *valid;
-                else if (cbak_func_idx && *cbak_func_idx == j)
-                    maxInstrCountCbak = *valid;
-                else
+                // Step 5: Store local WCE and build bidirectional call
+                // relationships
+                if (call_graph.find(actual_func_idx) != call_graph.end())
                 {
-                    if (DEBUG_GUARD)
-                        printf(
-                            "code section: %d not hook_func_idx: %d or "
-                            "cbak_func_idx: %d\n",
-                            j,
-                            *hook_func_idx,
-                            (cbak_func_idx ? *cbak_func_idx : -1));
-                    //   assert(false);
+                    call_graph[actual_func_idx].local_wce = *valid;
+
+                    // Build bidirectional relationships: for each callee, add
+                    // this function as a caller
+                    for (int callee_idx : call_graph[actual_func_idx].callees)
+                    {
+                        if (call_graph.find(callee_idx) != call_graph.end())
+                        {
+                            call_graph[callee_idx].callers.insert(
+                                actual_func_idx);
+                        }
+                    }
                 }
+
+                // Note: We will calculate total WCE later after processing all
+                // functions
                 i = code_end;
             }
         }
         i = next_section;
     }
 
-    // execution to here means guards are installed correctly
+    // Step 6: Cycle detection using DFS
+    // Lambda function for DFS-based cycle detection
+    std::set<int> visited;
+    std::set<int> rec_stack;
+    std::function<bool(int)> detect_cycles_dfs = [&](int func_idx) -> bool {
+        if (rec_stack.find(func_idx) != rec_stack.end())
+        {
+            // Found a cycle: func_idx is already in the recursion stack
+            return true;
+        }
 
-    return std::pair<uint64_t, uint64_t>{maxInstrCountHook, maxInstrCountCbak};
+        if (visited.find(func_idx) != visited.end())
+        {
+            // Already visited and no cycle found from this node
+            return false;
+        }
+
+        visited.insert(func_idx);
+        rec_stack.insert(func_idx);
+
+        // Check all callees
+        if (call_graph.find(func_idx) != call_graph.end())
+        {
+            for (int callee_idx : call_graph[func_idx].callees)
+            {
+                if (detect_cycles_dfs(callee_idx))
+                {
+                    return true;
+                }
+            }
+        }
+
+        rec_stack.erase(func_idx);
+        return false;
+    };
+
+    // Run cycle detection on all user-defined functions
+    for (const auto& [func_idx, func_info] : call_graph)
+    {
+        if (detect_cycles_dfs(func_idx))
+        {
+            GUARDLOG(hook::log::CALL_ILLEGAL)
+                << "GuardCheck: Recursive function calls detected. "
+                << "Hooks cannot contain recursive or mutually recursive "
+                   "functions.\n";
+            return {};
+        }
+    }
+
+    // Step 7: Calculate total WCE for each function using bottom-up approach
+    // Lambda function for recursive WCE calculation with memoization
+    std::function<uint64_t(int)> calculate_function_wce =
+        [&](int func_idx) -> uint64_t {
+        // Check if function exists in call graph
+        if (call_graph.find(func_idx) == call_graph.end())
+        {
+            // This is an imported function, WCE = 0 (already accounted for)
+            return 0;
+        }
+
+        FunctionInfo& func_info = call_graph[func_idx];
+
+        // If already calculated, return cached result
+        if (func_info.wce_calculated)
+        {
+            return func_info.total_wce;
+        }
+
+        // Detect circular dependency in WCE calculation (should not happen
+        // after cycle detection)
+        if (func_info.in_calculation)
+        {
+            GUARDLOG(hook::log::CALL_ILLEGAL)
+                << "GuardCheck: Internal error - circular dependency detected "
+                   "during WCE calculation.\n";
+            return 0xFFFFFFFFU;  // Return large value to trigger overflow error
+        }
+
+        func_info.in_calculation = true;
+
+        // Start with local WCE
+        uint64_t total = func_info.local_wce;
+
+        // Add WCE of all callees
+        for (int callee_idx : func_info.callees)
+        {
+            uint64_t callee_wce = calculate_function_wce(callee_idx);
+
+            // Check for overflow
+            if (total > 0xFFFFU || callee_wce > 0xFFFFU ||
+                (total + callee_wce) > 0xFFFFU)
+            {
+                func_info.in_calculation = false;
+                return 0xFFFFFFFFU;  // Signal overflow
+            }
+
+            total += callee_wce;
+        }
+
+        func_info.total_wce = total;
+        func_info.wce_calculated = true;
+        func_info.in_calculation = false;
+
+        return total;
+    };
+
+    // Calculate WCE for hook and cbak functions
+    int64_t hook_wce_actual = 0;
+    int64_t cbak_wce_actual = 0;
+
+    if (hook_func_idx)
+    {
+        int actual_hook_idx = last_import_number + 1 + *hook_func_idx;
+        hook_wce_actual = calculate_function_wce(actual_hook_idx);
+
+        if (hook_wce_actual >= 0xFFFFU)
+        {
+            GUARDLOG(hook::log::INSTRUCTION_EXCESS)
+                << "GuardCheck: hook() function exceeds maximum instruction "
+                   "count (65535). "
+                << "Total WCE including called functions: " << hook_wce_actual
+                << "\n";
+            return {};
+        }
+
+        if (DEBUG_GUARD)
+            printf("hook() total WCE: %ld\n", hook_wce_actual);
+    }
+
+    if (cbak_func_idx)
+    {
+        int actual_cbak_idx = last_import_number + 1 + *cbak_func_idx;
+        cbak_wce_actual = calculate_function_wce(actual_cbak_idx);
+
+        if (cbak_wce_actual >= 0xFFFFU)
+        {
+            GUARDLOG(hook::log::INSTRUCTION_EXCESS)
+                << "GuardCheck: cbak() function exceeds maximum instruction "
+                   "count (65535). "
+                << "Total WCE including called functions: " << cbak_wce_actual
+                << "\n";
+            return {};
+        }
+
+        if (DEBUG_GUARD)
+            printf("cbak() total WCE: %ld\n", cbak_wce_actual);
+    }
+
+    // execution to here means guards are installed correctly and WCE is within
+    // limits
+
+    return std::pair<uint64_t, uint64_t>{hook_wce_actual, cbak_wce_actual};
 }

include/xrpl/protocol/Feature.h

@@ -80,7 +80,7 @@ namespace detail {
 // Feature.cpp. Because it's only used to reserve storage, and determine how
 // large to make the FeatureBitset, it MAY be larger. It MUST NOT be less than
 // the actual number of amendments. A LogicError on startup will verify this.
-static constexpr std::size_t numFeatures = 114;
+static constexpr std::size_t numFeatures = 113;
 
 /** Amendments that this server supports and the default voting behavior.
    Whether they are enabled depends on the Rules defined in the validated

include/xrpl/protocol/TxFlags.h

@@ -223,11 +223,6 @@ constexpr std::uint32_t const tfNFTokenCancelOfferMask     = ~tfUniversal;
 // NFTokenAcceptOffer flags:
 constexpr std::uint32_t const tfNFTokenAcceptOfferMask     = ~tfUniversal;
 
-enum SetHookFlags : uint32_t {
-    tfNewAccount = 0x00000001,
-};
-constexpr std::uint32_t const tfSetHookMask = ~(tfUniversal | tfNewAccount);
-
 // URIToken mask
 constexpr std::uint32_t const tfURITokenMintMask = ~(tfUniversal | tfBurnable);
 constexpr std::uint32_t const tfURITokenNonMintMask = ~tfUniversal;

include/xrpl/protocol/detail/features.macro

@@ -31,7 +31,6 @@
 // If you add an amendment here, then do not forget to increment `numFeatures`
 // in include/xrpl/protocol/Feature.h.
 
-XRPL_FEATURE(HookAdministrator,          Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(HookAPISerializedType240,   Supported::yes, VoteBehavior::DefaultNo)
 XRPL_FEATURE(PermissionedDomains,        Supported::no,  VoteBehavior::DefaultNo)
 XRPL_FEATURE(DynamicNFT,                 Supported::no,  VoteBehavior::DefaultNo)

include/xrpl/protocol/detail/ledger_entries.macro

@@ -262,7 +262,6 @@ LEDGER_ENTRY(ltACCOUNT_ROOT, 0x0061, AccountRoot, account, ({
     {sfHookStateScale,       soeOPTIONAL},
     {sfCron,                 soeOPTIONAL},
     {sfAMMID,                soeOPTIONAL},
-    {sfHookAdministrator,    soeOPTIONAL},
 }))
 
 /** A ledger object which contains a list of object identifiers.

include/xrpl/protocol/detail/sfields.macro

@@ -317,7 +317,6 @@ TYPED_SFIELD(sfAttestationRewardAccount, ACCOUNT,   21)
 TYPED_SFIELD(sfLockingChainDoor,         ACCOUNT,   22)
 TYPED_SFIELD(sfIssuingChainDoor,         ACCOUNT,   23)
 TYPED_SFIELD(sfSubject,                  ACCOUNT,   24)
-TYPED_SFIELD(sfHookAdministrator,        ACCOUNT,   98)
 TYPED_SFIELD(sfInform,                   ACCOUNT,   99)
 
 // vector of 256-bit

include/xrpl/protocol/detail/transactions.macro

@@ -195,7 +195,6 @@ TRANSACTION(ttACCOUNT_DELETE, 21, AccountDelete, ({
 /** This transaction type installs a hook. */
 TRANSACTION(ttHOOK_SET, 22, SetHook, ({
     {sfHooks, soeREQUIRED},
-    {sfDestination, soeOPTIONAL},
 }))
 
 /** This transaction mints a new NFT. */

src/test/app/SetHook_test.cpp

@@ -2971,6 +2971,809 @@ public:
         }
     }
 
+    void
+    testHelperFunctions(FeatureBitset features)
+    {
+        testcase("Test helper functions and recursion detection");
+        using namespace jtx;
+        Env env{*this, features};
+
+        auto const alice = Account{"alice"};
+        auto const bob = Account{"bob"};
+        env.fund(XRP(10000), alice, bob);
+        env.close();
+
+        // Test 1: Valid helper function without loops - should pass
+        {
+            /*
+            #include <stdint.h>
+            extern int32_t _g(uint32_t id, uint32_t maxiter);
+            extern int64_t accept(uint32_t read_ptr, uint32_t read_len, int64_t
+                                  error_code);
+            extern int64_t hook_pos(void);
+
+            int64_t helper(int64_t n) { return n + hook_pos(); }
+
+            int64_t cbak(uint32_t reserved) {
+                _g(1, 1);
+                int64_t result = helper(34);
+                return accept(0, 0, result);
+            }
+
+            int64_t hook(uint32_t reserved) {
+                _g(1, 1);
+                int64_t result = helper(5);
+                return accept(0, 0, result);
+            }
+            */
+            TestHook hook_wasm = wasm[R"[test.hook](
+                (module
+                    (type (;0;) (func (param i32) (result i64)))
+                    (type (;1;) (func (result i64)))
+                    (type (;2;) (func (param i32 i32) (result i32)))
+                    (type (;3;) (func (param i32 i32 i64) (result i64)))
+                    (type (;4;) (func (param i64) (result i64)))
+                    (import "env" "hook_pos" (func (;0;) (type 1)))
+                    (import "env" "_g" (func (;1;) (type 2)))
+                    (import "env" "accept" (func (;2;) (type 3)))
+                    (func (;3;) (type 4) (param i64) (result i64)
+                        call 0
+                        local.get 0
+                        i64.add)
+                    (func (;4;) (type 0) (param i32) (result i64)
+                        i32.const 1
+                        i32.const 1
+                        call 1
+                        drop
+                        i32.const 0
+                        i32.const 0
+                        i64.const 34
+                        call 3
+                        call 2)
+                    (func (;5;) (type 0) (param i32) (result i64)
+                        i32.const 1
+                        i32.const 1
+                        call 1
+                        drop
+                        i32.const 0
+                        i32.const 0
+                        i64.const 5
+                        call 3
+                        call 2)
+                    (memory (;0;) 2)
+                    (export "memory" (memory 0))
+                    (export "cbak" (func 4))
+                    (export "hook" (func 5)))
+            )[test.hook]"];
+            HASH_WASM(hook);
+
+            env(ripple::test::jtx::hook(
+                    alice, {{hso(hook_wasm, overrideFlag)}}, 0),
+                M("Valid helper function without loops"),
+                HSFEE,
+                ter(tesSUCCESS));
+            env.close();
+            EXPECT_HOOK_FEE(hook, 14);
+
+            env(pay(bob, alice, XRP(1)), M("Test helper 1"), fee(XRP(1)));
+            env.close();
+        }
+
+        // Test 2: Helper function with guarded loop - should pass
+        {
+            /*
+            #include <stdint.h>
+            extern int32_t _g(uint32_t id, uint32_t maxiter);
+            extern int64_t accept(uint32_t read_ptr, uint32_t read_len, int64_t
+            error_code); extern int64_t hook_pos(void);
+
+            int64_t helper(int64_t n) {
+                int64_t sum = 0;
+                for (int i = 0; i < 3; ++i) {
+                    _g(2, 4);
+                    sum += i * n;
+                }
+                return sum;
+            }
+
+            int64_t cbak(uint32_t reserved) {
+                _g(1, 1);
+                int64_t result = helper(2);
+                return accept(0, 0, result);
+            }
+
+            int64_t hook(uint32_t reserved) {
+                _g(1, 1);
+                int64_t result = helper(3);
+                return accept(0, 0, result);
+            }
+            */
+            TestHook hook_wasm = wasm[R"[test.hook](
+                (module
+                    (type (;0;) (func (param i32) (result i64)))
+                    (type (;1;) (func (param i32 i32) (result i32)))
+                    (type (;2;) (func (param i32 i32 i64) (result i64)))
+                    (type (;3;) (func (param i64) (result i64)))
+                    (import "env" "_g" (func (;0;) (type 1)))
+                    (import "env" "accept" (func (;1;) (type 2)))
+                    (func (;2;) (type 0) (param i32) (result i64)
+                        i32.const 1
+                        i32.const 1
+                        call 0
+                        drop
+                        i32.const 0
+                        i32.const 0
+                        i64.const 3
+                        call 3
+                        call 1)
+                    (func (;3;) (type 3) (param i64) (result i64)
+                        i32.const 2
+                        i32.const 4
+                        call 0
+                        drop
+                        i32.const 2
+                        i32.const 4
+                        call 0
+                        drop
+                        i32.const 2
+                        i32.const 4
+                        call 0
+                        drop
+                        local.get 0
+                        i64.const 3
+                        i64.mul)
+                    (func (;4;) (type 0) (param i32) (result i64)
+                        i32.const 1
+                        i32.const 1
+                        call 0
+                        drop
+                        i32.const 0
+                        i32.const 0
+                        i64.const 2
+                        call 3
+                        call 1)
+                    (memory (;0;) 2)
+                    (export "memory" (memory 0))
+                    (export "hook" (func 2))
+                    (export "cbak" (func 4)))
+            )[test.hook]"];
+            HASH_WASM(hook);
+
+            env(ripple::test::jtx::hook(
+                    alice, {{hso(hook_wasm, overrideFlag)}}, 0),
+                M("Helper function with guarded loop"),
+                HSFEE,
+                ter(tesSUCCESS));
+            env.close();
+            EXPECT_HOOK_FEE(hook, 26);
+
+            env(pay(bob, alice, XRP(1)), M("Test helper 2"), fee(XRP(1)));
+            env.close();
+        }
+
+        // Test 3: Direct recursion - should fail
+        {
+            /*
+            #include <stdint.h>
+            extern int32_t _g(uint32_t id, uint32_t maxiter);
+            extern int64_t accept(uint32_t read_ptr, uint32_t read_len, int64_t
+                                  error_code);
+            extern int64_t hook_pos(void);
+
+            int64_t recursive_func(int64_t n) {
+              if (n <= 0)
+                return 0;
+              return n + recursive_func(n - hook_pos());
+            }
+            int64_t cbak(uint32_t reserved) {
+              _g(1, 1);
+              int64_t result = recursive_func(5);
+              return accept(0, 0, result);
+            }
+
+            int64_t hook(uint32_t reserved) {
+              _g(1, 1);
+              int64_t result = recursive_func(10);
+              return accept(0, 0, result);
+            }
+
+            */
+            TestHook hook = wasm[R"[test.hook](
+            (module
+                (type (;0;) (func (param i32) (result i64)))
+                (type (;1;) (func (param i32 i32) (result i32)))
+                (type (;2;) (func (param i32 i32 i64) (result i64)))
+                (type (;3;) (func (result i64)))
+                (type (;4;) (func (param i64) (result i64)))
+                (import "env" "_g" (func $g (type 1)))
+                (import "env" "accept" (func $accept (type 2)))
+                (import "env" "hook_pos" (func $hook_pos (type 3)))
+                (func $recursive_func (type 4) (param $n i64) (result i64)
+                    (if (result i64)
+                    (i64.le_s (local.get $n) (i64.const 0))
+                    (then
+                        (i64.const 0)
+                    )
+                    (else
+                        (i64.add
+                        (local.get $n)
+                        (call $recursive_func
+                            (i64.sub (local.get $n) (call $hook_pos))
+                        )
+                        )
+                    )
+                    )
+                )
+                (func (;3;) (type 0) (param i32) (result i64) ;; cbak
+                    i32.const 1
+                    i32.const 1
+                    call $g
+                    drop
+                    i32.const 0
+                    i32.const 0
+                    i64.const 5
+                    call $recursive_func
+                    call $accept
+                )
+                (func (;5;) (type 0) (param i32) (result i64) ;; hook
+                    i32.const 1
+                    i32.const 1
+                    call $g
+                    drop
+                    i32.const 0
+                    i32.const 0
+                    i64.const 10
+                    call $recursive_func
+                    call $accept
+                )
+                (memory (;0;) 2)
+                (export "memory" (memory 0))
+                (export "cbak" (func 3))
+                (export "hook" (func 5)))
+            )[test.hook]"];
+
+            env(ripple::test::jtx::hook(alice, {{hso(hook)}}, 0),
+                M("Direct recursion should fail"),
+                HSFEE,
+                ter(temMALFORMED));
+            env.close();
+        }
+
+        // Test 4: Indirect recursion (A -> B -> A) - should fail
+        {
+            /*
+            #include <stdint.h>
+            extern int32_t _g(uint32_t id, uint32_t maxiter);
+            extern int64_t accept(uint32_t read_ptr, uint32_t read_len, int64_t
+            error_code);
+
+            int64_t func_b(int64_t n);
+
+            int64_t func_a(int64_t n) {
+              if (n <= 0)
+                return 0;
+              return n + func_b(n - 1);
+            }
+
+            int64_t func_b(int64_t n) {
+              if (n <= 0)
+                return 0;
+              return n + func_a(n - 1);
+            }
+
+            int64_t cbak(uint32_t reserved) {
+              _g(1, 1);
+              int64_t result = func_a(5);
+              return accept(0, 0, result);
+            }
+
+            int64_t hook(uint32_t reserved) {
+              _g(1, 1);
+              int64_t result = func_a(10);
+              return accept(0, 0, result);
+            }
+
+            */
+            TestHook hook = wasm[R"[test.hook](
+            (module
+                (import "env" "_g" (func $_g (param i32 i32) (result i32)))
+                (import "env" "accept" (func $accept (param i32 i32 i64) (result i64)))
+                (type $func_type (func (param i64) (result i64)))
+                (func $func_b (param $n i64) (result i64)
+                    (if (result i64)
+                    (i64.le_s (local.get $n) (i64.const 0))
+                    (then
+                        (i64.const 0)
+                    )
+                    (else
+                        (i64.add
+                        (local.get $n)
+                        (call $func_a
+                            (i64.sub (local.get $n) (i64.const 1))
+                        )
+                        )
+                    )
+                    )
+                )
+                (func $func_a (param $n i64) (result i64)
+                    (if (result i64)
+                    (i64.le_s (local.get $n) (i64.const 0))
+                    (then
+                        (i64.const 0)
+                    )
+                    (else
+                        (i64.add
+                        (local.get $n)
+                        (call $func_b
+                            (i64.sub (local.get $n) (i64.const 1))
+                        )
+                        )
+                    )
+                    )
+                )
+                (func $cbak (param $reserved i32) (result i64)
+                    (local $result i64)
+                    (drop (call $_g (i32.const 1) (i32.const 1)))
+                    (local.set $result (call $func_a (i64.const 5)))
+                    (call $accept (i32.const 0) (i32.const 0) (local.get $result))
+                )
+                (func $hook (param $reserved i32) (result i64)
+                    (local $result i64)
+                    (drop (call $_g (i32.const 1) (i32.const 1)))
+                    (local.set $result (call $func_a (i64.const 10)))
+                    (call $accept (i32.const 0) (i32.const 0) (local.get $result))
+                )
+                (export "cbak" (func $cbak))
+                (export "hook" (func $hook)))
+            )[test.hook]"];
+
+            env(ripple::test::jtx::hook(alice, {{hso(hook)}}, 0),
+                M("Indirect recursion should fail"),
+                HSFEE,
+                ter(temMALFORMED));
+            env.close();
+        }
+
+        // Test 5: Deep call chain (A -> B -> C -> D) - should pass if WCE is OK
+        {
+            /*
+            #include <stdint.h>
+            extern int32_t _g(uint32_t id, uint32_t maxiter);
+            extern int64_t accept(uint32_t read_ptr, uint32_t read_len, int64_t
+                                  error_code);
+            extern int64_t hook_pos(void);
+
+            int64_t helper(int64_t n) { return n + hook_pos(); }
+
+            int64_t cbak(uint32_t reserved) {
+                _g(1, 1);
+                int64_t result = helper(34);
+                return accept(0, 0, result);
+            }
+
+            int64_t hook(uint32_t reserved) {
+                _g(1, 1);
+                int64_t result = helper(5);
+                return accept(0, 0, result);
+            }
+            */
+            TestHook hook_wasm = wasm[R"[test.hook](
+                (module
+                    (type (;0;) (func (param i32) (result i64)))
+                    (type (;1;) (func (result i64)))
+                    (type (;2;) (func (param i32 i32) (result i32)))
+                    (type (;3;) (func (param i32 i32 i64) (result i64)))
+                    (type (;4;) (func (param i64) (result i64)))
+                    (import "env" "hook_pos" (func (;0;) (type 1)))
+                    (import "env" "_g" (func (;1;) (type 2)))
+                    (import "env" "accept" (func (;2;) (type 3)))
+                    (func (;3;) (type 4) (param i64) (result i64)
+                        call 0
+                        local.get 0
+                        i64.add)
+                    (func (;4;) (type 0) (param i32) (result i64)
+                        i32.const 1
+                        i32.const 1
+                        call 1
+                        drop
+                        i32.const 0
+                        i32.const 0
+                        i64.const 34
+                        call 3
+                        call 2)
+                    (func (;5;) (type 0) (param i32) (result i64)
+                        i32.const 1
+                        i32.const 1
+                        call 1
+                        drop
+                        i32.const 0
+                        i32.const 0
+                        i64.const 5
+                        call 3
+                        call 2)
+                    (memory (;0;) 2)
+                    (export "memory" (memory 0))
+                    (export "cbak" (func 4))
+                    (export "hook" (func 5)))
+            )[test.hook]"];
+            HASH_WASM(hook);
+
+            env(ripple::test::jtx::hook(
+                    alice, {{hso(hook_wasm, overrideFlag)}}, 0),
+                M("Deep call chain without recursion"),
+                HSFEE,
+                ter(tesSUCCESS));
+            env.close();
+            EXPECT_HOOK_FEE(hook, 14);
+
+            env(pay(bob, alice, XRP(1)), M("Test helper 5"), fee(XRP(1)));
+            env.close();
+        }
+
+        // Test 6: Helper called multiple times - WCE should accumulate
+        {
+            /*
+            #include <stdint.h>
+            extern int32_t _g(uint32_t id, uint32_t maxiter);
+            extern int64_t accept(uint32_t read_ptr, uint32_t read_len, int64_t
+            error_code);
+
+            int64_t expensive_helper() {
+              int64_t sum = 0;
+              for (int i = 0; i < 100; ++i) {
+                _g(2, 301);
+                sum += i;
+              }
+              return sum;
+            }
+
+            int64_t hook(uint32_t reserved) {
+              _g(1, 1);
+              int64_t result = 0;
+              result += expensive_helper();
+              result += expensive_helper();
+              result += expensive_helper();
+              return accept(0, 0, result);
+            }
+            */
+
+            TestHook hook_wasm = wasm[R"[test.hook](
+                (module
+                    (type (;0;) (func (param i32 i32) (result i32)))
+                    (type (;1;) (func (param i32 i32 i64) (result i64)))
+                    (type (;2;) (func (result i64)))
+                    (type (;3;) (func (param i32) (result i64)))
+                    (import "env" "_g" (func (;0;) (type 0)))
+                    (import "env" "accept" (func (;1;) (type 1)))
+                    (func (;2;) (type 2) (result i64)
+                        (local i64)
+                        i64.const 100
+                        local.set 0
+                        loop  ;; label = @1
+                        i32.const 2
+                        i32.const 301
+                        call 0
+                        drop
+                        local.get 0
+                        i64.const 1
+                        i64.sub
+                        local.tee 0
+                        i64.eqz
+                        i32.eqz
+                        br_if 0 (;@1;)
+                        end
+                        i64.const 4950)
+                    (func (;3;) (type 3) (param i32) (result i64)
+                        i32.const 1
+                        i32.const 1
+                        call 0
+                        drop
+                        i32.const 0
+                        i32.const 0
+                        call 2
+                        call 2
+                        i64.add
+                        call 2
+                        i64.add
+                        call 1)
+                    (memory (;0;) 2)
+                    (export "memory" (memory 0))
+                    (export "hook" (func 3)))
+            )[test.hook]"];
+            HASH_WASM(hook);
+
+            env(ripple::test::jtx::hook(
+                    alice, {{hso(hook_wasm, overrideFlag)}}, 0),
+                M("Helper called multiple times"),
+                HSFEE,
+                ter(tesSUCCESS));
+            env.close();
+            EXPECT_HOOK_FEE(hook, 2727);
+
+            env(pay(bob, alice, XRP(1)), M("Test helper 6"), fee(XRP(1)));
+            env.close();
+        }
+
+        // Test 7: WCE overflow through many helpers - should fail
+        {
+            /*
+            #include <stdint.h>
+            extern int32_t _g(uint32_t id, uint32_t maxiter);
+            extern int64_t accept(uint32_t read_ptr, uint32_t read_len, int64_t
+            error_code);
+
+            int64_t large_helper(int64_t n) {
+              int64_t sum = n;
+              for (int i = 0; i < 10000; ++i) {
+                _g(2, 10001);
+                sum += i;
+              }
+              return sum;
+            }
+
+            int64_t cbak(uint32_t reserved) {
+              _g(1, 1);
+              int64_t result = 10;
+              for (int i = 0; i < 10; ++i) {
+                _g(3, 11);
+                result += large_helper(10);
+              }
+              return accept(0, 0, result);
+            }
+
+            int64_t hook(uint32_t reserved) {
+              _g(1, 1);
+              int64_t result = 0;
+              for (int i = 0; i < 10; ++i) {
+                _g(3, 11);
+                result += large_helper(0);
+              }
+              return accept(0, 0, result);
+            }
+
+            */
+            TestHook hook = wasm[R"[test.hook](
+                (module
+                    (type (;0;) (func (param i32) (result i64)))
+                    (type (;1;) (func (param i32 i32) (result i32)))
+                    (type (;2;) (func (param i32 i32 i64) (result i64)))
+                    (type (;3;) (func (param i64) (result i64)))
+                    (import "env" "_g" (func (;0;) (type 1)))
+                    (import "env" "accept" (func (;1;) (type 2)))
+                    (func (;2;) (type 0) (param i32) (result i64)
+                        (local i64)
+                        i32.const 1
+                        i32.const 1
+                        call 0
+                        drop
+                        i32.const 10
+                        local.set 0
+                        i64.const 10
+                        local.set 1
+                        loop  ;; label = @1
+                        i32.const 3
+                        i32.const 11
+                        call 0
+                        drop
+                        i64.const 10
+                        call 3
+                        local.get 1
+                        i64.add
+                        local.set 1
+                        local.get 0
+                        i32.const 1
+                        i32.sub
+                        local.tee 0
+                        br_if 0 (;@1;)
+                        end
+                        i32.const 0
+                        i32.const 0
+                        local.get 1
+                        call 1)
+                    (func (;3;) (type 3) (param i64) (result i64)
+                        (local i64)
+                        i64.const 10000
+                        local.set 1
+                        loop  ;; label = @1
+                        i32.const 2
+                        i32.const 10001
+                        call 0
+                        drop
+                        local.get 1
+                        i64.const 1
+                        i64.sub
+                        local.tee 1
+                        i64.eqz
+                        i32.eqz
+                        br_if 0 (;@1;)
+                        end
+                        local.get 0
+                        i64.const 49995000
+                        i64.add)
+                    (func (;4;) (type 0) (param i32) (result i64)
+                        (local i64)
+                        i32.const 1
+                        i32.const 1
+                        call 0
+                        drop
+                        i32.const 10
+                        local.set 0
+                        loop  ;; label = @1
+                        i32.const 3
+                        i32.const 11
+                        call 0
+                        drop
+                        i64.const 0
+                        call 3
+                        local.get 1
+                        i64.add
+                        local.set 1
+                        local.get 0
+                        i32.const 1
+                        i32.sub
+                        local.tee 0
+                        br_if 0 (;@1;)
+                        end
+                        i32.const 0
+                        i32.const 0
+                        local.get 1
+                        call 1)
+                    (memory (;0;) 2)
+                    (export "memory" (memory 0))
+                    (export "cbak" (func 2))
+                    (export "hook" (func 4)))
+            )[test.hook]"];
+
+            env(ripple::test::jtx::hook(alice, {{hso(hook)}}, 0),
+                M("WCE overflow through helpers"),
+                HSFEE,
+                ter(temMALFORMED));
+            env.close();
+        }
+
+        // Test 8: guard inside guard
+        {
+            /*
+            #include <stdint.h>
+            extern int32_t _g(uint32_t id, uint32_t maxiter);
+            extern int64_t accept(uint32_t read_ptr, uint32_t read_len, int64_t
+            error_code);
+
+            int64_t helper(int64_t n) {
+                int64_t sum = n;
+                for (int i = 0; i < 100; ++i) {
+                    _g(2, 1000);
+                    sum += i;
+                }
+                return sum;
+            }
+
+            int64_t cbak(uint32_t reserved) {
+                _g(1, 1);
+                int64_t result = 10;
+                for (int i = 0; i < 10; ++i) {
+                    _g(3, 11);
+                    result += helper(10);
+                }
+                return accept(0, 0, result);
+            }
+
+            int64_t hook(uint32_t reserved) {
+                _g(1, 1);
+                int64_t result = 0;
+                for (int i = 0; i < 10; ++i) {
+                    _g(3, 11);
+                    result += helper(0);
+                }
+                return accept(0, 0, result);
+            }
+            */
+
+            TestHook hook_wasm = wasm[R"[test.hook](
+                (module
+                    (type (;0;) (func (param i32) (result i64)))
+                    (type (;1;) (func (param i32 i32) (result i32)))
+                    (type (;2;) (func (param i32 i32 i64) (result i64)))
+                    (type (;3;) (func (param i64) (result i64)))
+                    (import "env" "_g" (func (;0;) (type 1)))
+                    (import "env" "accept" (func (;1;) (type 2)))
+                    (func (;2;) (type 3) (param i64) (result i64)
+                        (local i64)
+                        i64.const 100
+                        local.set 1
+                        loop  ;; label = @1
+                        i32.const 2
+                        i32.const 1000
+                        call 0
+                        drop
+                        local.get 1
+                        i64.const 1
+                        i64.sub
+                        local.tee 1
+                        i64.eqz
+                        i32.eqz
+                        br_if 0 (;@1;)
+                        end
+                        local.get 0
+                        i64.const 4950
+                        i64.add)
+                    (func (;3;) (type 0) (param i32) (result i64)
+                        (local i64)
+                        i32.const 1
+                        i32.const 1
+                        call 0
+                        drop
+                        i32.const 10
+                        local.set 0
+                        i64.const 10
+                        local.set 1
+                        loop  ;; label = @1
+                        i32.const 3
+                        i32.const 11
+                        call 0
+                        drop
+                        i64.const 10
+                        call 2
+                        local.get 1
+                        i64.add
+                        local.set 1
+                        local.get 0
+                        i32.const 1
+                        i32.sub
+                        local.tee 0
+                        br_if 0 (;@1;)
+                        end
+                        i32.const 0
+                        i32.const 0
+                        local.get 1
+                        call 1)
+                    (func (;4;) (type 0) (param i32) (result i64)
+                        (local i64)
+                        i32.const 1
+                        i32.const 1
+                        call 0
+                        drop
+                        i32.const 10
+                        local.set 0
+                        loop  ;; label = @1
+                        i32.const 3
+                        i32.const 11
+                        call 0
+                        drop
+                        i64.const 0
+                        call 2
+                        local.get 1
+                        i64.add
+                        local.set 1
+                        local.get 0
+                        i32.const 1
+                        i32.sub
+                        local.tee 0
+                        br_if 0 (;@1;)
+                        end
+                        i32.const 0
+                        i32.const 0
+                        local.get 1
+                        call 1)
+                    (memory (;0;) 2)
+                    (export "memory" (memory 0))
+                    (export "cbak" (func 3))
+                    (export "hook" (func 4)))
+            )[test.hook]"];
+            HASH_WASM(hook);
+
+            env(ripple::test::jtx::hook(
+                    alice, {{hso(hook_wasm, overrideFlag)}}, 0),
+                M("guard inside guard"),
+                HSFEE,
+                ter(tesSUCCESS));
+            EXPECT_HOOK_FEE(hook, 9151);
+
+            env(pay(bob, alice, XRP(1)), M("Test helper 8"), fee(XRP(1)));
+            env.close();
+        }
+    }
+
     void
     test_emit(FeatureBitset features)
     {
@@ -14729,6 +15532,7 @@ public:
         test_rollback(features);
 
         testGuards(features);
+        testHelperFunctions(features);
 
         test_emit(features);  //
         test_prepare(features);

src/test/app/build_test_hooks.sh

@@ -58,8 +58,21 @@ cat $INPUT_FILE | tr '\n' '\f' |
             then
                 echo '#include "api.h"' > "$WASM_DIR/test-$COUNTER-gen.c"
                 tr '\f' '\n' <<< $line >> "$WASM_DIR/test-$COUNTER-gen.c"
-                DECLARED="`tr '\f' '\n' <<< $line | grep  -E '(extern|define) ' | grep -Eo '[a-z\-\_]+ *\(' | grep -v 'sizeof' | sed -E 's/[^a-z\-\_]//g' | sort | uniq`"
-                USED="`tr '\f' '\n' <<< $line | grep -vE '(extern|define) ' | grep -Eo '[a-z\-\_]+\(' | grep -v 'sizeof' | sed -E 's/[^a-z\-\_]//g' | grep -vE '^(hook|cbak)' | sort | uniq`"
+                DECLARED="`tr '\f' '\n' <<< $line \
+                  | grep  -E '(extern|static|define) ' \
+                  | grep -Eo '[a-z\-\_]+ *\(' \
+                  | grep -v 'sizeof' \
+                  | sed -E 's/[^a-z\-\_]//g' \
+                  | grep -vE '^__attribute__$' \
+                  | sort | uniq`"
+
+                USED="`tr '\f' '\n' <<< $line \
+                  | grep -vE '(extern|static|define) ' \
+                  | grep -Eo '[a-z\-\_]+\(' \
+                  | grep -v 'sizeof' \
+                  | sed -E 's/[^a-z\-\_]//g' \
+                  | grep -vE '^(__attribute__|hook|cbak)$' \
+                  | sort | uniq`"
                 ONCE="`echo $DECLARED $USED | tr ' ' '\n' | sort | uniq -c | grep '1 ' | sed -E 's/^ *1 //g'`"
                 FILTER="`echo $DECLARED | tr ' ' '|' | sed -E 's/\|$//g'`"
                 UNDECL="`echo $ONCE | grep -v -E $FILTER 2>/dev/null || echo ''`"
@@ -69,7 +82,7 @@ cat $INPUT_FILE | tr '\n' '\f' |
                     echo "$line"
                     exit 1
                 fi
-                wasmcc -x c /dev/stdin -o /dev/stdout -O2 -Wl,--allow-undefined <<< "`tr '\f' '\n' <<< $line`" |
+                wasmcc -x c /dev/stdin -o /dev/stdout -O2 -Wl,--allow-undefined,--export=hook,--export=cbak <<< "`tr '\f' '\n' <<< $line`" |
                     hook-cleaner - - 2>/dev/null |
                     xxd -p -u -c 10 | 
                     sed -E 's/../0x&U,/g' | sed -E 's/^/    /g' >> $OUTPUT_FILE

src/xrpld/app/tx/detail/DeleteAccount.cpp

@@ -330,9 +330,6 @@ DeleteAccount::preclaim(PreclaimContext const& ctx)
         if (sleAccount->isFieldPresent(sfHookNamespaces) ||
             sleAccount->isFieldPresent(sfHooks))
             return tecHAS_OBLIGATIONS;
-
-        if (sleAccount->isFieldPresent(sfHookAdministrator))
-            return tecHAS_OBLIGATIONS;
     }
 
     // When fixNFTokenRemint is enabled, we don't allow an account to be

src/xrpld/app/tx/detail/InvariantCheck.cpp

@@ -1037,9 +1037,7 @@ ValidNewAccountRoot::finalize(
     if ((tt == ttPAYMENT || tt == ttIMPORT || tt == ttGENESIS_MINT ||
          tt == ttREMIT || tt == ttAMM_CREATE ||
          tt == ttXCHAIN_ADD_CLAIM_ATTESTATION ||
-         tt == ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION ||
-         (tt == ttHOOK_SET &&
-          view.rules().enabled(featureHookAdministrator))) &&
+         tt == ttXCHAIN_ADD_ACCOUNT_CREATE_ATTESTATION) &&
         isTesSuccess(result))
     {
         std::uint32_t const startingSeq{

src/xrpld/app/tx/detail/SetHook.cpp

@@ -675,21 +675,6 @@ SetHook::calculateBaseFee(ReadView const& view, STTx const& tx)
 TER
 SetHook::preclaim(ripple::PreclaimContext const& ctx)
 {
-    if (ctx.tx.isFieldPresent(sfHookAdministrator))
-    {
-        auto const& administrator = ctx.tx.getAccountID(sfHookAdministrator);
-        auto const& sle = ctx.view.read(keylet::account(administrator));
-        if (!sle)
-            return tecNO_DST;
-
-        if (!sle->isFieldPresent(sfHookAdministrator))
-            return tecNO_PERMISSION;
-
-        if (sle->getAccountID(sfHookAdministrator) !=
-            ctx.tx.getAccountID(sfAccount))
-            return tecNO_PERMISSION;
-    }
-
     auto const& hookSets = ctx.tx.getFieldArray(sfHooks);
 
     for (auto const& hookSetObj : hookSets)
@@ -729,46 +714,12 @@ SetHook::preflight(PreflightContext const& ctx)
         return ret;
 
     if (ctx.rules.enabled(fixInvalidTxFlags) &&
-        ctx.tx.getFlags() & tfSetHookMask)
+        ctx.tx.getFlags() & tfUniversalMask)
     {
         JLOG(ctx.j.trace()) << "SetHook: Invalid flags set.";
         return temINVALID_FLAG;
     }
 
-    if (ctx.tx.isFlag(tfNewAccount) &&
-        !ctx.rules.enabled(featureHookAdministrator))
-    {
-        JLOG(ctx.j.trace()) << "SetHook: New account flag set but hook "
-                               "administrator amendment is not enabled.";
-        return temDISABLED;
-    }
-
-    if (ctx.tx.isFieldPresent(sfDestination))
-    {
-        if (!ctx.rules.enabled(featureHookAdministrator))
-        {
-            JLOG(ctx.j.trace())
-                << "HookSet: Hook administrator amendment not enabled.";
-            return temDISABLED;
-        }
-
-        if (ctx.tx.isFlag(tfNewAccount))
-        {
-            JLOG(ctx.j.trace())
-                << "HookSet: Both new account flag and destination set. "
-                   "New account flag and destination cannot be set at the same "
-                   "time.";
-            return temMALFORMED;
-        }
-
-        if (ctx.tx.getAccountID(sfDestination) ==
-            ctx.tx.getAccountID(sfAccount))
-        {
-            JLOG(ctx.j.trace()) << "HookSet: Redundant hook administrator.";
-            return temREDUNDANT;
-        }
-    }
-
     if (!ctx.tx.isFieldPresent(sfHooks))
     {
         JLOG(ctx.j.trace())
@@ -1304,23 +1255,6 @@ struct KeyletComparator
     }
 };
 
-AccountID
-randomAccountAddress(ReadView const& view, uint256 const& pseudoOwnerKey)
-{
-    // This number must not be changed without an amendment
-    constexpr std::uint16_t maxAccountAttempts = 256;
-    for (std::uint16_t i = 0; i < maxAccountAttempts; ++i)
-    {
-        ripesha_hasher rsh;
-        auto const hash = sha512Half(i, view.info().parentHash, pseudoOwnerKey);
-        rsh(hash.data(), hash.size());
-        AccountID const ret{static_cast<ripesha_hasher::result_type>(rsh)};
-        if (!view.read(keylet::account(ret)))
-            return ret;
-    }
-    return beast::zero;
-}
-
 TER
 SetHook::setHook()
 {
@@ -1340,69 +1274,11 @@ SetHook::setHook()
         .app = ctx_.app,
         .rules = ctx_.view().rules()};
 
-    auto targetAccount = ctx.tx[~sfDestination].value_or(account_);
-    if (ctx_.tx.isFlag(tfNewAccount))
-    {
-        // create the new account
-        auto const newAccount = randomAccountAddress(ctx_.view(), uint256{});
-        if (newAccount == beast::zero)
-            return tecDUPLICATE;
-
-        auto sleNewAccount = std::make_shared<SLE>(keylet::account(newAccount));
-        sleNewAccount->setAccountID(sfAccount, newAccount);
-        sleNewAccount->setFieldAmount(sfBalance, STAmount{});
-        sleNewAccount->setFieldU32(sfOwnerCount, 1);  // ltHook
-        std::uint32_t const seqno{
-            ctx_.view().rules().enabled(featureXahauGenesis)
-                ? ctx_.view().info().parentCloseTime.time_since_epoch().count()
-                : ctx_.view().rules().enabled(featureDeletableAccounts)
-                ? ctx_.view().seq()
-                : 1};
-        sleNewAccount->setFieldU32(sfSequence, seqno);
-        sleNewAccount->setFieldU32(sfFlags, lsfDisableMaster);
-
-        sleNewAccount->setAccountID(sfHookAdministrator, account_);
-
-        auto sleFees = view().peek(keylet::fees());
-        if (sleFees && view().rules().enabled(featureXahauGenesis))
-        {
-            auto actIdx = sleFees->isFieldPresent(sfAccountCount)
-                ? sleFees->getFieldU64(sfAccountCount)
-                : 0;
-            sleNewAccount->setFieldU64(sfAccountIndex, actIdx);
-            sleFees->setFieldU64(sfAccountCount, actIdx + 1);
-            view().update(sleFees);
-        }
-
-        // fund AccountReserve + ObjectReserve (ltHook)
-        auto const requiredDrops = ctx_.view().fees().accountReserve(1);
-
-        auto sourceSle = ctx_.view().peek(keylet::account(account_));
-        if (!sourceSle)
-            return tefINTERNAL;
-
-        auto const sourceCurrentReserve = ctx_.view().fees().accountReserve(
-            sourceSle->getFieldU32(sfOwnerCount));
-
-        auto const sourceBalance = sourceSle->getFieldAmount(sfBalance).xrp();
-
-        if (sourceBalance < sourceCurrentReserve + requiredDrops)
-            return tecUNFUNDED;
-
-        sourceSle->setFieldAmount(sfBalance, sourceBalance - requiredDrops);
-        ctx_.view().update(sourceSle);
-
-        sleNewAccount->setFieldAmount(sfBalance, requiredDrops);
-        ctx_.view().insert(sleNewAccount);
-
-        targetAccount = newAccount;
-    }
-
     const int blobMax = hook::maxHookWasmSize();
+    auto const accountKeylet = keylet::account(account_);
+    auto const hookKeylet = keylet::hook(account_);
 
-    auto const hookKeylet = keylet::hook(targetAccount);
-
-    auto accountSLE = view().peek(keylet::account(targetAccount));
+    auto accountSLE = view().peek(accountKeylet);
 
     ripple::STArray newHooks{sfHooks, 8};
     auto newHookSLE = std::make_shared<SLE>(hookKeylet);