…2157)

* eth, eth/protocols/eth: fix goroutine leaks in witness request path

The parallel-stateless-import feature leaked goroutines in
RequestWitnessesWithVerification when peers disconnected or stopped
responding. Each stalled witness request leaked 2-4 goroutines that
pinned witness data and channels in memory indefinitely.

Three root causes:

1. doWitnessRequest spawned a goroutine that blocked forever on the
   per-request response channel (<-witResCh) with no timeout or
   cancellation. When a peer disconnected, the wit dispatcher exited
   without signaling pending sink channels, so the goroutine never
   returned. This cascaded: the WaitGroup never completed, witReqResCh
   never closed, and the adapter goroutine also leaked.

2. eth.Request.Close() returned early without closing the Cancel
   channel when peer was nil. The witness adapter returns a shim
   eth.Request (peer == nil) to the concurrent fetcher. When the
   fetcher called Close() on timeout or disconnect, Cancel was never
   closed, so the adapter goroutine's select on Cancel never fired.

3. The adapter spawned fire-and-forget goroutines (go func(){<-doneCh}())
   to drain the Done channel on synthetic eth.Response objects. Nothing
   ever wrote to these channels, so the goroutines leaked unconditionally.

Fixes:

- eth.Request.Close() now always closes Cancel even when peer is nil.
- doWitnessRequest selects on a cancel channel in both receive and
  forward paths, with proper WaitGroup/semaphore cleanup on exit.
- Replace doneCh drainer goroutines with buffered channels.
- Adapter defers closing underlying wit.Request objects on exit.

* Address PR comments

* Fix test

* Add test coverage

* Refactor and simplify

…olygon throughput (#2160)

Polygon mainnet processes 120M gas/block at 2s block times. At high
utilization (90-100% gas), blocks carry 430-520 KB of transaction data,
with full blocks reaching ~520 KB. The previous 100 KB limit required
5+ sequential p2p messages per peer per full block.

This affected both paths:
- Direct broadcast (full txs to sqrt(peers)): many sequential messages
- GetPooledTransactions responses: peers fetching txs after announcement
  could not receive a full block's worth in one response, increasing
  round trips for mempool convergence across the wider peer set

1 MB is chosen to:
- Fit any block at current gas limits in a single message
- Provide ~2x headroom over the current full-block maximum (~520 KB),
  absorbing a gas limit increase to ~200M without another bump
- Stay at 6.3% of the 16 MB p2p message size limit
- Remain well below the ~15 MB witness messages already exchanged on
  this network, keeping head-of-line blocking risk negligible

Note: 512 KB was considered but rejected — full blocks already reach
520 KB, leaving essentially no margin.

v2.7.0 to develop

* perf: use fixed-size array stack to eliminate slice overhead in EVM

* core/vm: add switch-dispatch fast path for EVM interpreter

* fix: keccak 256 benchmark test

* chore: stack benchmark test

* core/vm: fix revert data loss, fork gate, and push allocs in switch dispatch

* chore: nits

* feat: snailtracer benchmark test

* chore: add EnableSwitchDispatch flag

* chore: add a log

* chore: fix tests

* chore: final nits

* fix: use blockchain's vm.Config instead of nil

* fix: tests and disable tracing for block producer

* fix: lint

* chore: comments

* chore: nits

* chore: tests

* fix: lint

* chore: increase test coverage and change the flag name

* chore: add gen_dispatch CLAUDE.md with SOP

* chore: address comments

* chore: add testing and validation section

* chore: comment fixes

* chore: nit

…-over (#2170)

* pebble optimizations

* pathdb: make state carry-over safe with copy-on-write

* Update triedb/pathdb/config.go

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Update triedb/pathdb/buffer.go

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

…Anns (#2171)

Fixes for the postrm scripts

Most of time, SRC is less than 100ms. For this reason, we should allow the worker to spend more time in transaction execution. This change will be crucial when we reduce the block time.