execution/stagedsync: drop dead finalizeWithIBS + finalizeTx (delta-args) and their tests

First incremental cut toward the structural goal of #21138: one finalize
function per parallel-exec result, with no IntraBlockState used outside
workers. This commit removes two finalize variants that are unreachable
from production code:

* finalizeWithIBS (~120 LOC) — full IBS reconstruction path that was kept
  around for the BAL-compat strip→rebase→merge route. Zero callers on
  main since the BAL fix in #21177 + the parallel-exec stack in #21153
  rerouted that flow through finalizeTxSimple.
* finalizeTx (delta-args variant, ~250 LOC) — direct-fee-balance path
  consumed only by TestFinalizeTx_AllScenarios and its
  hasCoinbaseDelta / adjustForTransferDelta helpers. Production calls
  finalizeTxSimple via the dispatch in `finalize`; this variant was
  test-only by 958b2fb.

Test cleanup removes:

* runFinalizeTx test runner
* TestFinalizeTx_SimpleTransfer, TestFinalizeTx_London,
  TestFinalizeTx_AllScenarios
* coinbaseIsRecipientScenario, selfTransferScenario fixture builders
* hasCoinbaseDelta, adjustForTransferDelta, buildWriteMap, fmtWriteVal,
  extractBalanceReads helpers that had no other consumers

Live finalizeTxSimple tests (TestFinalizeTxSimple_*) and the surviving
TestResolveStorageWrites_*, TestNormalizeWriteSet_*, TestSelfDestructPath_*
families are untouched. Updates one stale comment in
engine_api_bal_test.go that referenced finalizeWithIBS.

Verified: make lint clean; full execution/{stagedsync,state,tests} and
rpc/jsonrpc test packages green under EXEC3_PARALLEL=true; BAL family
8/8 parallel; EIP-7708 burn-log family green.

No semantic change — dead code removal only.

Author: mh0lt

execution/engineapi/engine_api_bal_test.go

@@ -44,7 +44,7 @@ import (
 // TestEngineApiBALMultiSenderBlock packs transfers from many independent senders
 // into a single block. Because the senders are independent the parallel executor
 // speculatively executes them concurrently, exercising the coinbase-balance
-// strip→rebase→merge path in finalizeWithIBS. Any divergence between the
+// fee-aggregation path in finalizeTxSimple. Any divergence between the
 // assembler's BAL (sequential) and the parallel executor's BAL surfaces as a
 // BAL hash mismatch returned by ProcessBAL.
 func TestEngineApiBALMultiSenderBlock(t *testing.T) {

execution/stagedsync/exec3_finalize_test.go

@@ -167,39 +167,6 @@ func (s *testFinalizeScenario) buildExecResult() *execResult {
 	return &execResult{TxResult: txResult}
 }
 
-// runFinalizeTx runs the direct finalize path.
-func (s *testFinalizeScenario) runFinalizeTx(t *testing.T) (state.ReadSet, state.VersionedWrites) {
-	t.Helper()
-	result := s.buildExecResult()
-	result.TxIn = copyReadSet(s.txIn)
-	result.TxOut = copyWrites(s.txOut)
-	if s.collectorWrites != nil {
-		result.CollectorWrites = copyWrites(s.collectorWrites)
-	}
-	vm := state.NewVersionMap(nil)
-	reader := s.makeReader()
-
-	// Strip coinbase/burnt.
-	txOut, coinbaseDelta, coinbaseDeltaIncrease, hasCoinbaseDelta := result.TxOut.StripBalanceWrite(result.Coinbase, result.TxIn)
-	result.TxOut = txOut
-	txOut, burntDelta, burntDeltaIncrease, hasBurntDelta := result.TxOut.StripBalanceWrite(result.ExecutionResult.BurntContractAddress, result.TxIn)
-	result.TxOut = txOut
-	result.TxIn.Delete(result.Coinbase, state.AccountKey{Path: state.BalancePath})
-	result.TxIn.Delete(result.ExecutionResult.BurntContractAddress, state.AccountKey{Path: state.BalancePath})
-
-	task := result.Task.(*taskVersion)
-	txTask := task.Task.(*exec.TxTask)
-
-	_, reads, writes, err := result.finalizeTx(
-		task, txTask, nil, nil, vm, reader,
-		coinbaseDelta, coinbaseDeltaIncrease, hasCoinbaseDelta,
-		burntDelta, burntDeltaIncrease, hasBurntDelta,
-		s.rules, false, "",
-	)
-	require.NoError(t, err)
-	return reads, writes
-}
-
 func fAddr(name string) accounts.Address {
 	var a [20]byte
 	copy(a[:], name)
@@ -312,246 +279,6 @@ func londonTransferScenario() *testFinalizeScenario {
 	return s
 }
 
-// TestFinalizeTx_SimpleTransfer verifies the direct finalize path produces
-// expected reads and writes for a simple ETH transfer.
-func TestFinalizeTx_SimpleTransfer(t *testing.T) {
-	t.Parallel()
-	s := simpleTransferScenario()
-	reads, writes := s.runFinalizeTx(t)
-
-	assert.NotNil(t, reads, "direct path should produce reads")
-	assert.Greater(t, len(writes), 0, "direct path should produce writes")
-
-	coinbaseWrite := findWrite(writes, s.coinbase, state.BalancePath)
-	require.NotNil(t, coinbaseWrite, "should have coinbase balance write")
-	coinbaseBalance := coinbaseWrite.Val.(uint256.Int)
-	assert.Equal(t, s.feeTipped, coinbaseBalance, "coinbase should receive the tip")
-}
-
-// TestFinalizeTx_London verifies the direct finalize path with burnt fees.
-func TestFinalizeTx_London(t *testing.T) {
-	t.Parallel()
-	s := londonTransferScenario()
-	reads, writes := s.runFinalizeTx(t)
-
-	assert.NotNil(t, reads)
-	assert.Greater(t, len(writes), 0)
-
-	burntWrite := findWrite(writes, s.burntAddr, state.BalancePath)
-	require.NotNil(t, burntWrite, "should have burnt contract balance write")
-	burntBalance := burntWrite.Val.(uint256.Int)
-	expected := new(uint256.Int).Add(uint256.NewInt(500_000), &s.feeBurnt)
-	assert.Equal(t, *expected, burntBalance, "burnt contract should receive base fee")
-}
-
-// coinbaseIsRecipientScenario: coinbase is the recipient of the transfer.
-// Coinbase balance in TxOut has the transfer amount (from execution) plus
-// it will get the tip from finalize. The StripBalanceWrite must correctly
-// handle the case where coinbase has a real balance change from execution.
-func coinbaseIsRecipientScenario() *testFinalizeScenario {
-	sender := fAddr("sender")
-	coinbase := fAddr("coinbase") // coinbase is also the recipient
-
-	senderBal := uint256.NewInt(100_000_000_000)
-	coinbaseBal := uint256.NewInt(5_000_000_000)
-	transferAmt := uint256.NewInt(1_000_000_000)
-	tip := uint256.NewInt(21_000)
-
-	// During calcFees=false execution:
-	// - sender loses transfer amount (but NOT gas — fees deferred)
-	// - coinbase gains transfer amount (but NOT tip — fees deferred)
-	newSenderBal := new(uint256.Int).Sub(senderBal, transferAmt)
-	newCoinbaseBal := new(uint256.Int).Add(coinbaseBal, transferAmt)
-
-	rules := &chain.Rules{IsSpuriousDragon: true}
-	config := &chain.Config{ChainID: big.NewInt(1)}
-
-	txIn := state.ReadSet{}
-	txIn.Set(state.VersionedRead{Address: sender, Path: state.AddressPath, Val: fMakeAccount(senderBal.Uint64(), 0)})
-	txIn.Set(state.VersionedRead{Address: sender, Path: state.BalancePath, Val: *senderBal})
-	txIn.Set(state.VersionedRead{Address: sender, Path: state.NoncePath, Val: uint64(0)})
-	// Coinbase IS touched during execution (as transfer recipient).
-	txIn.Set(state.VersionedRead{Address: coinbase, Path: state.AddressPath, Val: fMakeAccount(coinbaseBal.Uint64(), 0)})
-	txIn.Set(state.VersionedRead{Address: coinbase, Path: state.BalancePath, Val: *coinbaseBal})
-
-	// TxOut: coinbase has transfer amount but NOT tip (fees deferred).
-	txOut := state.VersionedWrites{
-		{Address: sender, Path: state.BalancePath, Val: *newSenderBal, Reason: tracing.BalanceDecreaseGasBuy},
-		{Address: sender, Path: state.NoncePath, Val: uint64(1)},
-		{Address: coinbase, Path: state.BalancePath, Val: *newCoinbaseBal, Reason: tracing.BalanceChangeTransfer},
-	}
-
-	collectorWrites := state.VersionedWrites{
-		{Address: sender, Path: state.BalancePath, Val: *newSenderBal},
-		{Address: sender, Path: state.NoncePath, Val: uint64(1)},
-		{Address: sender, Path: state.IncarnationPath, Val: uint64(1)},
-		{Address: sender, Path: state.CodeHashPath, Val: accounts.EmptyCodeHash},
-		{Address: coinbase, Path: state.BalancePath, Val: *newCoinbaseBal},
-		{Address: coinbase, Path: state.NoncePath, Val: uint64(0)},
-		{Address: coinbase, Path: state.IncarnationPath, Val: uint64(1)},
-		{Address: coinbase, Path: state.CodeHashPath, Val: accounts.EmptyCodeHash},
-	}
-
-	return &testFinalizeScenario{
-		name: "coinbase_is_recipient",
-		accts: map[accounts.Address]*accounts.Account{
-			sender:   fMakeAccount(senderBal.Uint64(), 0),
-			coinbase: fMakeAccount(coinbaseBal.Uint64(), 0),
-		},
-		txIn:            txIn,
-		txOut:           txOut,
-		collectorWrites: collectorWrites,
-		feeTipped:       *tip,
-		coinbase:        coinbase,
-		burntAddr:       accounts.NilAddress,
-		rules:           rules,
-		config:          config,
-		header: &types.Header{
-			Number:   *uint256.NewInt(1),
-			GasLimit: 30_000_000,
-			GasUsed:  21000,
-		},
-	}
-}
-
-// selfTransferScenario: sender sends ETH to themselves. Coinbase is separate.
-// Tests that same-address sender+recipient doesn't confuse the finalize logic.
-func selfTransferScenario() *testFinalizeScenario {
-	sender := fAddr("sender")
-	coinbase := fAddr("coinbase")
-
-	senderBal := uint256.NewInt(100_000_000_000)
-
-	// Self-transfer: balance doesn't change (transfer cancels out).
-	// Gas is NOT deducted during calcFees=false, so balance stays the same.
-	// But nonce increments.
-	rules := &chain.Rules{IsSpuriousDragon: true}
-	config := &chain.Config{ChainID: big.NewInt(1)}
-	tip := uint256.NewInt(21_000)
-
-	txIn := state.ReadSet{}
-	txIn.Set(state.VersionedRead{Address: sender, Path: state.AddressPath, Val: fMakeAccount(senderBal.Uint64(), 0)})
-	txIn.Set(state.VersionedRead{Address: sender, Path: state.BalancePath, Val: *senderBal})
-	txIn.Set(state.VersionedRead{Address: sender, Path: state.NoncePath, Val: uint64(0)})
-
-	txOut := state.VersionedWrites{
-		{Address: sender, Path: state.BalancePath, Val: *senderBal, Reason: tracing.BalanceChangeTransfer},
-		{Address: sender, Path: state.NoncePath, Val: uint64(1)},
-	}
-
-	collectorWrites := state.VersionedWrites{
-		{Address: sender, Path: state.BalancePath, Val: *senderBal},
-		{Address: sender, Path: state.NoncePath, Val: uint64(1)},
-		{Address: sender, Path: state.IncarnationPath, Val: uint64(1)},
-		{Address: sender, Path: state.CodeHashPath, Val: accounts.EmptyCodeHash},
-	}
-
-	return &testFinalizeScenario{
-		name: "self_transfer",
-		accts: map[accounts.Address]*accounts.Account{
-			sender:   fMakeAccount(senderBal.Uint64(), 0),
-			coinbase: fMakeAccount(0, 0),
-		},
-		txIn:            txIn,
-		txOut:           txOut,
-		collectorWrites: collectorWrites,
-		feeTipped:       *tip,
-		coinbase:        coinbase,
-		burntAddr:       accounts.NilAddress,
-		rules:           rules,
-		config:          config,
-		header: &types.Header{
-			Number:   *uint256.NewInt(1),
-			GasLimit: 30_000_000,
-			GasUsed:  21000,
-		},
-	}
-}
-
-// TestFinalizeTx_AllScenarios verifies the direct finalize path produces
-// correct writes and reads across all test scenarios.
-func TestFinalizeTx_AllScenarios(t *testing.T) {
-	t.Parallel()
-	scenarios := []*testFinalizeScenario{
-		simpleTransferScenario(),
-		londonTransferScenario(),
-		coinbaseIsRecipientScenario(),
-		selfTransferScenario(),
-	}
-
-	for _, s := range scenarios {
-		t.Run(s.name, func(t *testing.T) {
-			// TODO(#20962): when coinbase is also the transfer recipient,
-			// finalizeTx no longer adds the tip on top of the existing TxOut
-			// coinbase write. Either StripBalanceWrite or the post-strip
-			// re-credit shifted; re-validate before un-skipping.
-			if s.name == "coinbase_is_recipient" {
-				t.Skip("stale coinbase-is-recipient expectation, see #20962")
-			}
-			reads, writes := s.runFinalizeTx(t)
-
-			assert.NotNil(t, reads, "should produce reads")
-			assert.Greater(t, len(writes), 0, "should produce writes")
-
-			// Coinbase must receive the tip.
-			coinbaseWrite := findWrite(writes, s.coinbase, state.BalancePath)
-			require.NotNil(t, coinbaseWrite, "should have coinbase balance write")
-			coinbaseBalance := coinbaseWrite.Val.(uint256.Int)
-
-			expectedCoinbase := new(uint256.Int).Set(&s.feeTipped)
-			if acc, ok := s.accts[s.coinbase]; ok {
-				expectedCoinbase.Add(expectedCoinbase, &acc.Balance)
-			}
-			// If coinbase was also a transfer recipient, add the delta.
-			if hasCoinbaseDelta(s) {
-				expectedCoinbase = adjustForTransferDelta(s, expectedCoinbase)
-			}
-			assert.Equal(t, *expectedCoinbase, coinbaseBalance,
-				"coinbase balance should be original + tip (+ transfer delta if recipient)")
-
-			// If London: burnt contract must receive base fee.
-			if s.rules.IsLondon && s.burntAddr != accounts.NilAddress {
-				burntWrite := findWrite(writes, s.burntAddr, state.BalancePath)
-				require.NotNil(t, burntWrite, "should have burnt contract balance write")
-				burntBalance := burntWrite.Val.(uint256.Int)
-				expectedBurnt := new(uint256.Int).Add(&s.accts[s.burntAddr].Balance, &s.feeBurnt)
-				assert.Equal(t, *expectedBurnt, burntBalance,
-					"burnt contract should receive base fee")
-			}
-
-			// BalancePath reads must include coinbase.
-			balReads := extractBalanceReads(reads)
-			_, hasCoinbaseRead := balReads[s.coinbase]
-			assert.True(t, hasCoinbaseRead, "should read coinbase balance")
-		})
-	}
-}
-
-// hasCoinbaseDelta checks if coinbase was touched during execution (transfer recipient).
-func hasCoinbaseDelta(s *testFinalizeScenario) bool {
-	for _, w := range s.txOut {
-		if w.Address == s.coinbase && w.Path == state.BalancePath {
-			return true
-		}
-	}
-	return false
-}
-
-// adjustForTransferDelta computes the expected coinbase balance when coinbase
-// is also the transfer recipient. The delta is the difference between the
-// execution-written balance and the original balance.
-func adjustForTransferDelta(s *testFinalizeScenario, base *uint256.Int) *uint256.Int {
-	for _, w := range s.txOut {
-		if w.Address == s.coinbase && w.Path == state.BalancePath {
-			execBal := w.Val.(uint256.Int)
-			origBal := s.accts[s.coinbase].Balance
-			delta := new(uint256.Int).Sub(&execBal, &origBal)
-			return new(uint256.Int).Add(base, delta)
-		}
-	}
-	return base
-}
-
 func findWrite(writes state.VersionedWrites, addr accounts.Address, path state.AccountPath) *state.VersionedWrite {
 	for _, w := range writes {
 		if w.Address == addr && w.Path == path {
@@ -561,49 +288,6 @@ func findWrite(writes state.VersionedWrites, addr accounts.Address, path state.A
 	return nil
 }
 
-func buildWriteMap(writes state.VersionedWrites) map[string]string {
-	m := make(map[string]string, len(writes))
-	for _, w := range writes {
-		key := w.Address.String() + ":" + w.Path.String() + ":" + w.Key.String()
-		m[key] = fmtWriteVal(w)
-	}
-	return m
-}
-
-func fmtWriteVal(w *state.VersionedWrite) string {
-	switch v := w.Val.(type) {
-	case uint256.Int:
-		return v.Hex()
-	case uint64:
-		return uint256.NewInt(v).Hex()
-	case bool:
-		if v {
-			return "true"
-		}
-		return "false"
-	case accounts.CodeHash:
-		return v.String()
-	default:
-		return "<unknown>"
-	}
-}
-
-func extractBalanceReads(reads state.ReadSet) map[accounts.Address]string {
-	m := make(map[accounts.Address]string)
-	if reads == nil {
-		return m
-	}
-	reads.Scan(func(vr *state.VersionedRead) bool {
-		if vr.Path == state.BalancePath {
-			if val, ok := vr.Val.(uint256.Int); ok {
-				m[vr.Address] = val.Hex()
-			}
-		}
-		return true
-	})
-	return m
-}
-
 // --- finalizeTxSimple tests ---
 // These test the split fee logic: worker debits sender only,
 // finalize credits coinbase/burnt. No StripBalanceWrite or delta computation.