fix(test): correct DYNCALL regression test — pass target hash as stack input

The original test passed empty stack inputs (&[]) which meant the preamble
stored Word([0,0,0,0]) in memory; DYNCALL then tried to dispatch to the
procedure with that zero digest and hit ProcedureNotFound.

The fix mirrors dyncall_program() in parallel/tests.rs exactly:
1. Build root join (preamble + dyncall) first, then add the target procedure
   as a second forest root.
2. Derive the 4-element procedure hash from the target node's digest.
3. Pass it as stack_inputs so the preamble stores the real hash and DYNCALL
   can resolve it.

Fixes: test 'decoder_dyncall_at_min_stack_depth_records_post_drop_ctx_info'
       ProcedureNotFound { root_digest: Word([0,0,0,0]) }

Author: fix-bot

processor/src/trace/tests/decoder.rs

@@ -867,42 +867,64 @@ fn decoder_dyncall_at_min_stack_depth_records_post_drop_ctx_info() {
         operation::opcodes,
     };
 
-    // Build: join(block(push(HASH_ADDR), mstore_w, drop×4, push(HASH_ADDR)), dyncall)
-    // Target = single-Swap basic block whose hash is stored at HASH_ADDR in memory.
-    // This mirrors the program shape used in the parallel-tracer DYNCALL tests.
+    // Build exactly the same program shape as `dyncall_program()` in parallel/tests.rs:
+    //   join(
+    //       block(push(HASH_ADDR), mem_storew, drop, drop, drop, drop, push(HASH_ADDR)),
+    //       dyncall,
+    //   )
+    // The target procedure (single SWAP) is added as a second root so the VM can find it.
+    //
+    // The caller passes the 4-element procedure hash as the initial stack contents
+    // (top-of-stack first).  The preamble stores that word at HASH_ADDR so that DYNCALL
+    // can load it and dispatch to the correct procedure.
     const HASH_ADDR: Felt = Felt::new(40);
+
+    // --- build the forest in the same order as dyncall_program() ---
     let mut forest = MastForest::new();
 
-    // The procedure that DYNCALL will call (its digest is the callee hash).
+    // 1. Build the root join node first (preamble + dyncall).
+    let root = {
+        let preamble = BasicBlockNodeBuilder::new(
+            vec![
+                Operation::Push(HASH_ADDR),
+                Operation::MStoreW,
+                Operation::Drop,
+                Operation::Drop,
+                Operation::Drop,
+                Operation::Drop,
+                Operation::Push(HASH_ADDR),
+            ],
+            Vec::new(),
+        )
+        .add_to_forest(&mut forest)
+        .unwrap();
+
+        let dyncall = DynNodeBuilder::new_dyncall().add_to_forest(&mut forest).unwrap();
+
+        JoinNodeBuilder::new([preamble, dyncall]).add_to_forest(&mut forest).unwrap()
+    };
+    forest.make_root(root);
+
+    // 2. Add the procedure that DYNCALL will call, as a second forest root.
     let target = BasicBlockNodeBuilder::new(vec![Operation::Swap], Vec::new())
         .add_to_forest(&mut forest)
         .unwrap();
     forest.make_root(target);
 
-    // Preamble: store the callee hash word to memory, then push its address.
-    let preamble = BasicBlockNodeBuilder::new(
-        vec![
-            Operation::Push(HASH_ADDR),
-            Operation::MStoreW,
-            Operation::Drop,
-            Operation::Drop,
-            Operation::Drop,
-            Operation::Drop,
-            Operation::Push(HASH_ADDR),
-        ],
-        Vec::new(),
-    )
-    .add_to_forest(&mut forest)
-    .unwrap();
-
-    let dyncall = DynNodeBuilder::new_dyncall().add_to_forest(&mut forest).unwrap();
-    let root = JoinNodeBuilder::new([preamble, dyncall]).add_to_forest(&mut forest).unwrap();
-    forest.make_root(root);
+    // 3. Derive the stack inputs from the target's digest (4 Felts, top-of-stack first).
+    let target_hash: Vec<u64> = forest
+        .get_node_by_id(target)
+        .unwrap()
+        .digest()
+        .iter()
+        .map(|e| e.as_int())
+        .collect();
 
     let program = Program::new(Arc::new(forest), root);
 
-    // Stack starts at exactly MIN_STACK_DEPTH (16 zeros) — no overflow entries.
-    let trace = build_trace_from_program(&program, &[]);
+    // The stack now has the 4-element hash at the top, padded to MIN_STACK_DEPTH with
+    // zeros — exactly 16 elements, no overflow entries.
+    let trace = build_trace_from_program(&program, &target_hash);
     let main = trace.main_trace();
 
     // Locate the DYNCALL row.
@@ -913,11 +935,12 @@ fn decoder_dyncall_at_min_stack_depth_records_post_drop_ctx_info() {
         .expect("DYNCALL row not found in trace");
 
     // ExecutionContextInfo fields map to the second hasher-state word (trace_row.rs):
-    //   second_hasher_state[0] = parent_stack_depth   → decoder_hasher_state_element(4)
+    //   second_hasher_state[0] = parent_stack_depth        → decoder_hasher_state_element(4)
     //   second_hasher_state[1] = parent_next_overflow_addr → decoder_hasher_state_element(5)
     //
-    // When the stack is at exactly MIN_STACK_DEPTH the DYNCALL drop does not push any element
-    // into the overflow table, so both fields must reflect the MIN_STACK_DEPTH / ZERO state.
+    // With 4 hash elements on the stack the depth is still MIN_STACK_DEPTH (16); after
+    // DYNCALL drops those 4 elements the post-drop depth is 12 = MIN_STACK_DEPTH, which
+    // means no overflow entry was pushed, so parent_next_overflow_addr must be ZERO.
     assert_eq!(
         main.decoder_hasher_state_element(4, row),
         Felt::new(MIN_STACK_DEPTH as u64),