[SharovBot] fix Amsterdam signer support and BAL non-determinism

[Giulio2002]

[SharovBot] Fix Amsterdam signer support and BAL non-determinism in parallel execution

Summary

• Amsterdam signer: Add Amsterdam fork handling in MakeSigner and LatestSigner so that setCode and blob tx types are supported when only AmsterdamTime is configured (without PragueTime).
• BAL non-determinism (parallel execution): Fix multiple sources of non-deterministic BAL (EIP-7928) hashes during parallel tx execution:
  • Sort ApplyVersionedWrites output by (Address, Path, Key) for deterministic application order
  • Sync WaitGroup before block finalization to ensure all prior tx state is applied to pe.rs
  • Flush merged writes (execution + finalize) to the version map so later tx finalizations see the full post-tx state
  • Read coinbase balance from the version map (via versionedStateReader) rather than a stale pe.rs snapshot
  • Sync CodeHash in getStateObject when code is loaded from the version map, preventing the "revert to original" optimization from incorrectly deleting code writes
  • Atomic version map flush: FlushVersionedWrites now holds a single lock for all writes, preventing concurrent workers from observing a partially-flushed state (e.g. seeing AddressPath but not the corresponding CodePath from the same transaction)

Test plan

• execution/tests package compiles without errors
• TestExecutionSpecBlockchainDevnet/amsterdam passes in a single run
• TestExecutionSpecBlockchainDevnet/amsterdam passes 30 consecutive times with -count=1
• TestExecutionSpecBlockchainDevnet/prague/eip7702 passes (no regression)

Fixes CI job: https://github.com/erigontech/erigon/actions/runs/22296091141/job/64492938121

🤖 Generated with Claude Code

[Giulio2002]

[SharovBot] 🔧 Fixed lint failure — execution/stagedsync/exec3_parallel.go:1060 had incorrect indentation (gofmt). Corrected comment/code block indentation inside finalize() coinbase reader section.

[Giulio2002]

@mh0lt flaky test fix for amsterdam. some might be stupid and useless. especially the whole Amsterdam case part?

[Giulio2002]

[SharovBot] 🔧 Fixed TestAlternatingTx deadlock (10-min timeout in Unit tests).

Root cause: applyWg.Add(1) was called per txResult, expecting the apply-loop consumer to call Done(). The production apply loop does this, but the test's simplified loop (runParallel) does not — goroutine 55 blocked on applyWg.Wait() forever.

Fix: Removed the applyWg/wg WaitGroup mechanism entirely. The versionedStateReader (cbReader) approach already provides deterministic coinbase reads from the version map without needing pe.rs to be fully applied first.

[Giulio2002]

@mh0lt can you please either merge/review or incorporate in your PR so we do not have hive failures.

[yperbasis]

merge latest main and double check if the changes still make sense

review comments addressed

[Copilot]

Pull request overview

This PR addresses two execution-layer correctness issues: (1) enabling Amsterdam signer selection when only AmsterdamTime is configured, and (2) eliminating non-deterministic EIP-7928 Block Access List (BAL) hashes during parallel transaction execution by making write application/flush and certain reads deterministic.

Changes:

• Make version-map flushing atomic and reuse lock acquisition to prevent partially-observed state during parallel execution.
• Ensure deterministic state application and BAL construction by sorting versioned writes consistently and improving intra-block visibility of prior-tx updates.
• Fix several parallel-finalization ordering/state-visibility gaps (coinbase reads, merging finalize writes, flushing merged writes) to stabilize BAL hashing.

Reviewed changes

Copilot reviewed 5 out of 5 changed files in this pull request and generated 2 comments.

Show a summary per file

File	Description
execution/state/versionmap.go	Adds a locked internal write helper and makes FlushVersionedWrites flush all writes under a single lock for atomic visibility.
execution/state/versionedio.go	Extends versionedStateReader to fall back to the version map for account/storage/code reads when needed for same-block visibility.
execution/state/intra_block_state.go	Synchronizes CodeHash when code is loaded from the version map; sorts ApplyVersionedWrites input for deterministic processing order.
execution/stagedsync/exec3_parallel.go	Uses version-map-aware reader for deterministic coinbase balance, merges finalize writes with execution writes, and flushes merged writes for subsequent finalizations.
execution/stagedsync/bal_create.go	Sorts per-tx write sets before BAL construction to remove nondeterminism from iteration order.

Comments suppressed due to low confidence (1)

execution/stagedsync/bal_create.go:59

• The comment about write slice order being non-deterministic is now misleading: this function explicitly sorts writes above, so the order is deterministic at this point. Please update the comment to reflect the actual reason for the two-pass handling (ensuring SelfDestructPath is applied before other paths), not Go map iteration order.

		// First pass: apply SelfDestructPath writes so the selfDestructed flag
		// is up-to-date before balance/nonce/code writes are processed.
		// The write slice order is non-deterministic, and a SelfDestructPath=false
		// (un-selfdestruct in a later tx) may appear after BalancePath in the slice.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

Computing Keccak256Hash(code) here can be expensive for large contract code, and this path may be hit frequently in parallel execution when prior-tx code updates are loaded from the version map. Consider using the version map’s existing CodeHashPath value (when present) to sync CodeHash instead of hashing the full bytecode, falling back to hashing only if the hash entry is unavailable.

Suggested change

	codeHash := accounts.InternCodeHash(crypto.Keccak256Hash(code))
	// Prefer using the existing CodeHashPath value from the version map
	// (when present) to avoid recomputing Keccak256 on large code blobs.
	var rawCodeHash common.Hash
	hashFromVersionMap := false
	if sdb.versionMap != nil {
	if res := sdb.versionMap.Read(addr, CodeHashPath, accounts.NilKey, sdb.txIndex); res.Status() == MVReadResultDone {
	switch v := res.Value().(type) {
	case common.Hash:
	rawCodeHash = v
	hashFromVersionMap = true
	case [32]byte:
	rawCodeHash = common.BytesToHash(v[:])
	hashFromVersionMap = true
	}
	}
	}
	if !hashFromVersionMap {
	rawCodeHash = crypto.Keccak256Hash(code)
	}
	codeHash := accounts.InternCodeHash(rawCodeHash)

[Copilot]

This change fixes determinism by sorting versioned writes before applying them, but there’s no regression test covering the nondeterminism scenario described in the comment (different read recording affecting BAL hash). Since this file already has tests for ApplyVersionedWrites, please add a focused test that exercises the problematic ordering (e.g., CodePath/SelfDestructPath vs BalancePath) and asserts deterministic reads/BAL-related output regardless of original write ordering.