debug_traceCallMany: extend timeout CTS lifetime to enumerator disposal (#11429)

* debug_traceCallMany: extend timeout CTS lifetime to enumerator disposal

Bind the timeout CancellationTokenSource lifetime to enumerator disposal
in DebugRpcModule.TraceCallMany's simple path. The previous `using` scope
disposed the CTS before the lazy bundle pipeline was enumerated, leaving
the cancellation token unusable to downstream consumers (e.g. WaitHandle
throws ObjectDisposedException).

Mirrors the iterator-owns-CTS pattern already used by EthRpcModule.GetLogs.
Streaming is preserved -- no per-bundle or per-trace buffering is introduced.

Add two regression tests covering the disposed-CTS bug and guarding against
a future eager-materialization regression.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* Simplify debug_traceCallMany regression test

Collapse the two regression tests into one that exercises both invariants:
the first inner sequence touches WaitHandle (catches premature CTS disposal),
the second bundle throws unconditionally (catches eager materialization).

Drops the local-mock factory and revertes the CreateDebugRpcModule overload --
shared mocks already configured for similar tests in this fixture work fine here.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* Guard CTS against exceptions before iterator handoff

Mirror EthRpcModule.eth_getFilterLogs: dispose the timeout CTS in a catch
block if anything between creation and handoff to StreamBundleTraces throws.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: LukaszRozmej

src/Nethermind/Nethermind.JsonRpc.Test/Modules/DebugModuleTests.cs

@@ -53,6 +53,43 @@ public class DebugModuleTests
             _blockFinder
         );
 
+    [Test]
+    public void Debug_traceCallMany_streams_under_live_cancellation_token()
+    {
+        BlockHeader header = Build.A.BlockHeader.WithNumber(1).TestObject;
+        _blockFinder.Head.Returns(Build.A.Block.WithHeader(header).TestObject);
+        _blockFinder.FindHeader(Arg.Any<BlockParameter>()).ReturnsForAnyArgs(header);
+        _blockchainBridge.HasStateForBlock(Arg.Any<BlockHeader>()).Returns(true);
+        _debugBridge
+            .GetBundleTraces(Arg.Any<TransactionBundle[]>(), Arg.Any<BlockParameter>(), Arg.Any<CancellationToken>(), Arg.Any<GethTraceOptions>())
+            .Returns(static c => StreamBundles(c.ArgAt<CancellationToken>(2)));
+
+        DebugRpcModule rpcModule = CreateDebugRpcModule(_debugBridge);
+        TransactionBundle bundle = new() { Transactions = [new LegacyTransactionForRpc { To = TestItem.AddressC }] };
+
+        ResultWrapper<IEnumerable<IEnumerable<GethLikeTxTrace>>> result =
+            rpcModule.debug_traceCallMany([bundle, bundle], BlockParameter.Latest);
+
+        // The first inner sequence touches WaitHandle (throws ObjectDisposedException if the
+        // timeout CTS has been disposed). The second bundle throws unconditionally, so the
+        // call only succeeds if the result is a deferred sequence and we stop after the first.
+        using IEnumerator<IEnumerable<GethLikeTxTrace>> outer = result.Data.GetEnumerator();
+        outer.MoveNext().Should().BeTrue();
+        outer.Current.Count().Should().Be(1);
+    }
+
+    private static IEnumerable<IEnumerable<GethLikeTxTrace>> StreamBundles(CancellationToken token)
+    {
+        yield return YieldTrace(token);
+        throw new InvalidOperationException("second bundle should not be enumerated — streaming was lost");
+    }
+
+    private static IEnumerable<GethLikeTxTrace> YieldTrace(CancellationToken token)
+    {
+        _ = token.WaitHandle;
+        yield return new GethLikeTxTrace();
+    }
+
     [Test]
     public async Task Get_from_db()
     {

src/Nethermind/Nethermind.JsonRpc/Modules/DebugModule/DebugRpcModule.cs

@@ -465,19 +465,42 @@ private ResultWrapper<IEnumerable<IEnumerable<GethLikeTxTrace>>> TraceCallMany(T
     {
         PrepareTransactions(bundles, header);
 
-        using CancellationTokenSource timeout = BuildTimeoutCancellationTokenSource();
-        CancellationToken cancellationToken = timeout.Token;
+        CancellationTokenSource timeout = BuildTimeoutCancellationTokenSource();
+        try
+        {
+            IEnumerable<IEnumerable<GethLikeTxTrace>> bundleTraces = debugBridge
+                .GetBundleTraces(bundles, blockParameter, timeout.Token, options);
 
-        IEnumerable<IEnumerable<GethLikeTxTrace>> bundleTraces = debugBridge
-            .GetBundleTraces(bundles, blockParameter, cancellationToken, options);
+            if (_logger.IsTrace)
+            {
+                int totalTransactions = bundles.Sum(b => b.Transactions?.Length ?? 0);
+                _logger.Trace($"{nameof(debug_traceCallMany)} completed: {bundles.Length} bundles, {totalTransactions} transactions via simple path");
+            }
 
-        if (_logger.IsTrace)
+            return ResultWrapper<IEnumerable<IEnumerable<GethLikeTxTrace>>>.Success(StreamBundleTraces(bundleTraces, timeout));
+        }
+        catch
         {
-            int totalTransactions = bundles.Sum(b => b.Transactions?.Length ?? 0);
-            _logger.Trace($"{nameof(debug_traceCallMany)} completed: {bundles.Length} bundles, {totalTransactions} transactions via simple path");
+            timeout.Dispose();
+            throw;
         }
+    }
 
-        return ResultWrapper<IEnumerable<IEnumerable<GethLikeTxTrace>>>.Success(bundleTraces);
+    // Bind the timeout CTS lifetime to enumerator disposal so the lazy bundle pipeline
+    // can keep using the cancellation token after this method returns (JSON-RPC serializes
+    // the result lazily). Disposing the CTS earlier breaks downstream token consumers
+    // (e.g. WaitHandle access throws ObjectDisposedException).
+    private static IEnumerable<IEnumerable<GethLikeTxTrace>> StreamBundleTraces(
+        IEnumerable<IEnumerable<GethLikeTxTrace>> bundleTraces,
+        CancellationTokenSource cancellationTokenSource)
+    {
+        using (cancellationTokenSource)
+        {
+            foreach (IEnumerable<GethLikeTxTrace> traces in bundleTraces)
+            {
+                yield return traces;
+            }
+        }
     }
 
     private ResultWrapper<IEnumerable<IEnumerable<GethLikeTxTrace>>> TraceCallManyWithOverrides(TransactionBundle[] bundles, GethTraceOptions? options, BlockHeader header)