cmd/utils/app, execution/vm: fix hive legacy-cancun blockchain failures (#20892)

## Summary

Two fixes addressing all 29 failures in the Hive `legacy-cancun`

[run](https://hive.ethpandaops.io/#/test/generic/1777223434-c411e5be836d6d6f8a466489c2874cf3)
against `erigon_default`, plus a regression test that catches the
EVM-side bug locally.

### (a) `cmd/utils/app` — TD-based fork choice for `erigon import`

The Hive consensus simulator writes each block to its own `00NN.rlp`
file and runs `erigon import /blocks/00NN.rlp` for each — the simulator
does not implement TD/fork-choice itself, it relies on the client's
native chain selection. `InsertChain` always called
`UpdateForkChoice(importedTip)`, so every imported block became head
even when its TD was lower than the current canonical head's. For
`lotsOfLeafs` block 6 (TD `0x9CCF4`) is the canonical winner, but Erigon
kept switching head through blocks 7-13 (TD `0x9CC34`) and ended on
`0x26ad10c0…` instead of `0xf7f9ea97…`.

This affects **23 tests** (all Berlin/Istanbul/London variants):
`lotsOfLeafs`, `ChainAtoChainB_difficultyB`, `ForkStressTest`,
`CallContractFromNotBestBlock`, `lotsOfBranchesOverrideAtTheMiddle`,
`sideChainWithMoreTransactions`, `uncleBlockAtBlock3afterBlock4`,
`blockChainFrontierWithLargerTDvsHomesteadBlockchain[2]`.

**Fix:** before calling `UpdateForkChoice`, compare the imported chain's
total difficulty against the current head's TD using a shared
`headerdownload.ShouldReorg` helper (extracted from the existing
`FeedHeaderPoW` tie-break: TD → height → lex hash). If the imported
chain doesn't beat the current head, write the headers/bodies/TDs
straight to the DB as a side chain (no execution, no head change) so
future side-chain extensions can still validate. Once a side-chain
extension surpasses the canonical TD, the regular `InsertBlocks` +
`UpdateForkChoice` path triggers the reorg and executes those blocks.
PoS imports (all `difficulty=0`, TD never grows) explicitly bypass this
branch — `ShouldReorg`'s "shorter wins on tie" rule would otherwise
prevent the head from advancing past genesis.

### (b) `execution/vm` — STATICCALL touch for EIP-161 state clearing

`RevertPrecompiledTouch_d3g0v0_{Berlin,Istanbul,London}` and
`RevertPrecompiledTouch_storage_d3g0v0_{Berlin,Istanbul,London}` (**6
tests**) all touch precompile 3 (RIPEMD-160) via STATICCALL inside a
frame that runs out of gas. Expected: ripemd state-cleared (deleted) at
end of tx via the `journal.dirty(ripemd)` consensus quirk. Erigon left
it.

The CALL path in `evm.call` calls `Exist(addr)` first, which loads
ripemd into `stateObjects`; the subsequent `AddBalance(addr, 0)` then
falls through to `TouchAccount` and the famous quirk fires, so
`FinalizeTx` deletes ripemd. But the STATICCALL path skipped `Exist` and
called `AddBalance(addr, 0)` directly — in serial mode that hits the
`versionMap == nil && addr == ripemd && amount.IsZero()` shortcut that
uses `balanceIncrease` instead of `GetOrNewStateObject`. ripemd never
enters `stateObjects`, so on revert `FinalizeTx`'s `if !exist { continue
}` branch skips it.

**Fix:** replace `AddBalance(addr, u256.Num0, …)` with
`TouchAccount(addr)` for STATICCALL — same end behavior as CALL's
post-`Exist` flow (loads the account, hits the dirty quirk on touch).
Identical for non-ripemd / non-serial paths.

`d0` (CALL), `d1` (DELEGATECALL), `d2` (CALLCODE) variants were
unaffected: CALL goes through `Exist`+`Transfer`; DELEGATECALL and
CALLCODE don't touch the callee at all (matching geth and the post-state
expectations).

### (c) `execution/tests` — local regression test for the d3 RIPEMD path

Add `TestLegacyCancunState`, walking
`legacy-tests/LegacyTests/Cancun/GeneralStateTests` in state-test
format. `TestLegacyBlockchain` (`block_test.go`) explicitly skips the
`LegacyTests/` subtree and `TestState` walks the EEST static_tests,
neither of which covers the d3 ripemd-touch case. Verified the new test
fails at baseline (Berlin/1, Istanbul/1, London/1 — the d3 indexes) and
passes with the fix in (b). Refactored the now-three state-test runners
(`TestStateCornerCases` / `TestState` / `TestLegacyCancunState`) to
share a `runStateTests(t, st, dir)` helper plus a `stateTestSetup(t)`
helper for parallel/log/Windows-skip boilerplate.

Six fixtures fail on Constantinople-only post-state-root mismatches
(sstoreGas / *_HighNonce* / Ecrecover_Overflow / ecrecoverShortBuff) —
pre-existing Erigon-side divergences from geth, unrelated to this PR.
Geth doesn't catch them locally because its runner walks
`LegacyTests/Constantinople/GeneralStateTests` (older snapshot, doesn't
include these). Tracked separately in #20894 and `SkipLoad`-ed for now
with a comment pointing at the issue.

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Co-authored-by: info@weblogix.biz <admin@10gbps.weblogix.it>

Author: 3 people

cmd/utils/app/import_cmd.go

@@ -22,6 +22,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"math/big"
 	"os"
 	"os/signal"
 	"strings"
@@ -33,12 +34,14 @@ import (
 
 	"github.com/erigontech/erigon/cmd/erigon/node"
 	"github.com/erigontech/erigon/cmd/utils"
+	"github.com/erigontech/erigon/common"
 	"github.com/erigontech/erigon/common/log/v3"
 	"github.com/erigontech/erigon/db/kv"
 	"github.com/erigontech/erigon/db/rawdb"
 	"github.com/erigontech/erigon/db/services"
 	"github.com/erigontech/erigon/execution/execmodule"
 	"github.com/erigontech/erigon/execution/execmodule/chainreader"
+	"github.com/erigontech/erigon/execution/protocol/rules/ethash"
 	"github.com/erigontech/erigon/execution/rlp"
 	"github.com/erigontech/erigon/execution/tests/blockgen"
 	"github.com/erigontech/erigon/execution/types"
@@ -252,6 +255,92 @@ type stateChangesClient interface {
 }
 
 func InsertChain(ethereum *eth.Ethereum, chain *blockgen.ChainPack, setHead bool) error {
+	if len(chain.Blocks) == 0 {
+		return nil
+	}
+	for _, block := range chain.Blocks {
+		if err := block.HashCheck(true); err != nil {
+			return err
+		}
+	}
+
+	ctx := context.Background()
+
+	// Compare the imported chain's total difficulty against the current canonical
+	// head's via the same PoW fork-choice rule as the legacy header sync
+	// (ethash.ShouldReorg). If the imported chain doesn't win, persist
+	// the blocks as a side chain (without changing head or executing them), so
+	// future imports extending this branch can still be validated. Once a
+	// side-chain extension surpasses the canonical TD, the regular
+	// InsertBlocks + UpdateForkChoice path triggers the reorg and executes
+	// those blocks. This matches what ethereum/tests BlockchainTests with
+	// multi-chain layouts (lotsOfLeafs, ChainAtoChainB, ForkStressTest, etc.)
+	// expect when Hive imports one block per file.
+	firstBlock := chain.Blocks[0]
+	tipBlock := chain.TopBlock
+	var parentTd, currentHeadTd *big.Int
+	var currentHeadHash common.Hash
+	var currentHeadNumber uint64
+	if err := ethereum.ChainDB().View(ctx, func(tx kv.Tx) error {
+		if firstBlock.NumberU64() > 0 {
+			td, readErr := rawdb.ReadTd(tx, firstBlock.ParentHash(), firstBlock.NumberU64()-1)
+			if readErr != nil {
+				return fmt.Errorf("read parent TD: %w", readErr)
+			}
+			parentTd = td
+		} else {
+			parentTd = new(big.Int)
+		}
+		if hash := rawdb.ReadHeadBlockHash(tx); hash != (common.Hash{}) {
+			if num := rawdb.ReadHeaderNumber(tx, hash); num != nil {
+				td, readErr := rawdb.ReadTd(tx, hash, *num)
+				if readErr != nil {
+					return fmt.Errorf("read head TD: %w", readErr)
+				}
+				currentHeadTd = td
+				currentHeadHash = hash
+				currentHeadNumber = *num
+			}
+		}
+		return nil
+	}); err != nil {
+		return err
+	}
+	// Apply the side-chain path only for PoW imports where both TDs are known.
+	// If parent TD is missing (orphan import) or there is no current head yet,
+	// fall through to the regular insert path so any error surfaces normally.
+	// PoS blocks have difficulty=0 so TD never grows; ShouldReorg's PoW
+	// tie-break (shorter chain wins on equal TD) would prevent the head from
+	// ever advancing, so PoS imports skip the side-chain branch and rely on
+	// UpdateForkChoice as before.
+	isPoW := tipBlock.Header().Difficulty.Sign() > 0
+	if setHead && isPoW && parentTd != nil && currentHeadTd != nil {
+		importedTipTd := new(big.Int).Set(parentTd)
+		for _, b := range chain.Blocks {
+			importedTipTd.Add(importedTipTd, b.Header().Difficulty.ToBig())
+		}
+		if !ethash.ShouldReorg(currentHeadTd, currentHeadNumber, currentHeadHash, importedTipTd, tipBlock.NumberU64(), tipBlock.Hash()) {
+			// Side chain — write headers/bodies/TDs directly without executing
+			// or changing head.
+			return ethereum.ChainDB().Update(ctx, func(tx kv.RwTx) error {
+				td := new(big.Int).Set(parentTd)
+				for _, b := range chain.Blocks {
+					td.Add(td, b.Header().Difficulty.ToBig())
+					if err := rawdb.WriteHeader(tx, b.Header()); err != nil {
+						return fmt.Errorf("write side-chain header: %w", err)
+					}
+					if err := rawdb.WriteTd(tx, b.Hash(), b.NumberU64(), td); err != nil {
+						return fmt.Errorf("write side-chain TD: %w", err)
+					}
+					if _, err := rawdb.WriteRawBodyIfNotExists(tx, b.Hash(), b.NumberU64(), b.RawBody()); err != nil {
+						return fmt.Errorf("write side-chain body: %w", err)
+					}
+				}
+				return nil
+			})
+		}
+	}
+
 	streamCtx, cancel := context.WithCancel(ethereum.SentryCtx())
 	defer cancel()
 	stream, err := ethereum.StateDiffClient().StateChanges(streamCtx, &remoteproto.StateChangeRequest{WithStorage: false, WithTransactions: false}, grpc.WaitForReady(true))
@@ -260,17 +349,12 @@ func InsertChain(ethereum *eth.Ethereum, chain *blockgen.ChainPack, setHead bool
 	}
 
 	insertedBlocks := map[uint64]struct{}{}
-
 	for _, block := range chain.Blocks {
-		if err := block.HashCheck(true); err != nil {
-			return err
-		}
 		insertedBlocks[block.NumberU64()] = struct{}{}
 	}
 
 	chainRW := chainreader.NewChainReaderEth1(ethereum.ChainConfig(), ethereum.ExecutionModule(), time.Hour)
 
-	ctx := context.Background()
 	if err := chainRW.InsertBlocksAndWait(ctx, chain.Blocks); err != nil {
 		return err
 	}

execution/protocol/rules/ethash/forkchoice.go

@@ -0,0 +1,42 @@
+// Copyright 2024 The Erigon Authors
+// This file is part of Erigon.
+//
+// Erigon is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Erigon is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with Erigon. If not, see <http://www.gnu.org/licenses/>.
+
+package ethash
+
+import (
+	"bytes"
+	"math/big"
+
+	"github.com/erigontech/erigon/common"
+)
+
+// ShouldReorg reports whether a candidate header should replace the current
+// canonical head per PoW total-difficulty fork choice.
+//
+// The new chain wins if its total difficulty is strictly higher. On equal
+// total difficulty, the shorter chain wins (smaller block height); on equal
+// total difficulty AND equal height, the lexicographically larger block hash
+// wins. This matches geth's tie-break — see
+// https://github.com/maticnetwork/bor/blob/master/core/forkchoice.go#L81.
+func ShouldReorg(localTd *big.Int, localHeight uint64, localHash common.Hash, newTd *big.Int, newHeight uint64, newHash common.Hash) bool {
+	if cmp := newTd.Cmp(localTd); cmp != 0 {
+		return cmp > 0
+	}
+	if newHeight != localHeight {
+		return newHeight < localHeight
+	}
+	return bytes.Compare(localHash.Bytes(), newHash.Bytes()) < 0
+}

execution/protocol/rules/ethash/forkchoice_test.go

@@ -0,0 +1,58 @@
+// Copyright 2024 The Erigon Authors
+// This file is part of Erigon.
+//
+// Erigon is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Lesser General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Erigon is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with Erigon. If not, see <http://www.gnu.org/licenses/>.
+
+package ethash
+
+import (
+	"math/big"
+	"testing"
+
+	"github.com/erigontech/erigon/common"
+)
+
+func TestShouldReorg(t *testing.T) {
+	t.Parallel()
+
+	// Two distinct hashes ordered so hashLow < hashHigh (lex byte compare).
+	hashLow := common.Hash{0x01}
+	hashHigh := common.Hash{0x02}
+
+	tests := []struct {
+		name        string
+		localTd     int64
+		localHeight uint64
+		localHash   common.Hash
+		newTd       int64
+		newHeight   uint64
+		newHash     common.Hash
+		want        bool
+	}{
+		{"new TD strictly higher", 100, 5, hashLow, 101, 5, hashLow, true},
+		{"new TD strictly lower", 100, 5, hashLow, 99, 5, hashLow, false},
+		{"equal TD, new height shallower", 100, 10, hashLow, 100, 5, hashHigh, true},
+		{"equal TD, new height deeper", 100, 5, hashLow, 100, 10, hashHigh, false},
+		{"equal TD, equal height, new hash larger", 100, 5, hashLow, 100, 5, hashHigh, true},
+		{"equal TD, equal height, new hash smaller", 100, 5, hashHigh, 100, 5, hashLow, false},
+		{"equal TD, equal height, equal hash", 100, 5, hashLow, 100, 5, hashLow, false},
+	}
+	for _, tc := range tests {
+		got := ShouldReorg(big.NewInt(tc.localTd), tc.localHeight, tc.localHash,
+			big.NewInt(tc.newTd), tc.newHeight, tc.newHash)
+		if got != tc.want {
+			t.Errorf("%s: got %v, want %v", tc.name, got, tc.want)
+		}
+	}
+}

execution/stagedsync/headerdownload/header_algos.go

@@ -40,6 +40,7 @@ import (
 	"github.com/erigontech/erigon/db/services"
 	"github.com/erigontech/erigon/execution/metrics"
 	"github.com/erigontech/erigon/execution/protocol/rules"
+	"github.com/erigontech/erigon/execution/protocol/rules/ethash"
 	"github.com/erigontech/erigon/execution/rlp"
 	"github.com/erigontech/erigon/execution/stagedsync/dataflow"
 	"github.com/erigontech/erigon/execution/stagedsync/stages"
@@ -944,38 +945,24 @@ func (hi *HeaderInserter) FeedHeaderPoW(db kv.StatelessRwTx, headerReader servic
 	td = new(big.Int).Add(parentTd, header.Difficulty.ToBig())
 
 	// Now we can decide whether this header will create a change in the canonical head
-	if td.Cmp(hi.localTd) >= 0 {
-		reorg := true
-
-		// TODO: Add bor check here if required
-		// Borrowed from https://github.com/maticnetwork/bor/blob/master/core/forkchoice.go#L81
-		if td.Cmp(hi.localTd) == 0 {
-			if blockHeight > hi.highest {
-				reorg = false
-			} else if blockHeight == hi.highest {
-				// Compare hashes of block in case of tie breaker. Lexicographically larger hash wins.
-				reorg = bytes.Compare(hi.highestHash.Bytes(), hash.Bytes()) < 0
-			}
+	// TODO: Add bor check here if required
+	if ethash.ShouldReorg(hi.localTd, hi.highest, hi.highestHash, td, blockHeight, hash) {
+		hi.newCanonical = true
+		forkingPoint, err := hi.ForkingPoint(db, header, parent)
+		if err != nil {
+			return nil, err
 		}
-
-		if reorg {
-			hi.newCanonical = true
-			forkingPoint, err := hi.ForkingPoint(db, header, parent)
-			if err != nil {
-				return nil, err
-			}
-			hi.highest = blockHeight
-			hi.highestHash = hash
-			hi.highestTimestamp = header.Time
-			hi.canonicalCache.Add(blockHeight, hash)
-			// See if the forking point affects the unwindPoint (the block number to which other stages will need to unwind before the new canonical chain is applied)
-			if forkingPoint < hi.unwindPoint {
-				hi.SetUnwindPoint(forkingPoint)
-				hi.unwind = true
-			}
-			// This makes sure we end up choosing the chain with the max total difficulty
-			hi.localTd.Set(td)
+		hi.highest = blockHeight
+		hi.highestHash = hash
+		hi.highestTimestamp = header.Time
+		hi.canonicalCache.Add(blockHeight, hash)
+		// See if the forking point affects the unwindPoint (the block number to which other stages will need to unwind before the new canonical chain is applied)
+		if forkingPoint < hi.unwindPoint {
+			hi.SetUnwindPoint(forkingPoint)
+			hi.unwind = true
 		}
+		// This makes sure we end up choosing the chain with the max total difficulty
+		hi.localTd.Set(td)
 	}
 	if err = rawdb.WriteTd(db, hash, blockHeight, td); err != nil {
 		return nil, fmt.Errorf("[%s] failed to WriteTd: %w", hi.logPrefix, err)