feat(eth/tracers): Allow header overwrites (#295)

## Why this should be merged

The `types.Header` must be altered in SAE to return the appropriate
state root and base fee, so that the API can accurately find the these
values for execution. However, this will modify the block hash (since
this is found runtime in the header), so this provides the option to
overwrite the block hash via an optional interface. Instead of getting
the block hash from the header, an implementer can retrieve the block
again, and use the original hash instead.

## How this works

Use optional interface for every call of `block.Hash()`

## How this was tested

New UT

---------

Signed-off-by: Tsvetan Dimitrov (tsvetan.dimitrov@avalabs.org)
Co-authored-by: Tsvetan Dimitrov <tsvetan.dimitrov23@gmail.com>

Author: alarso16

eth/tracers/api.go

@@ -141,7 +141,7 @@ func (api *API) blockByNumberAndHash(ctx context.Context, number rpc.BlockNumber
 	if err != nil {
 		return nil, err
 	}
-	if block.Hash() == hash {
+	if api.blockHash(block) == hash {
 		return block, nil
 	}
 	return api.blockByHash(ctx, hash)
@@ -272,7 +272,7 @@ func (api *API) traceChain(start, end *types.Block, config *TraceConfig, closed
 				for i, tx := range task.block.Transactions() {
 					msg, _ := core.TransactionToMessage(tx, signer, task.block.BaseFee())
 					txctx := &Context{
-						BlockHash:   task.block.Hash(),
+						BlockHash:   api.blockHash(task.block),
 						BlockNumber: task.block.Number(),
 						TxIndex:     i,
 						TxHash:      tx.Hash(),
@@ -407,7 +407,7 @@ func (api *API) traceChain(start, end *types.Block, config *TraceConfig, closed
 			// Queue up next received result
 			result := &blockTraceResult{
 				Block:  hexutil.Uint64(res.block.NumberU64()),
-				Hash:   res.block.Hash(),
+				Hash:   api.blockHash(res.block),
 				Traces: res.results,
 			}
 			done[uint64(result.Block)] = result
@@ -597,7 +597,7 @@ func (api *API) traceBlock(ctx context.Context, block *types.Block, config *Trac
 	// Native tracers have low overhead
 	var (
 		txs       = block.Transactions()
-		blockHash = block.Hash()
+		blockHash = api.blockHash(block)
 		is158     = api.backend.ChainConfig().IsEIP158(block.Number())
 		blockCtx  = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
 		signer    = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
@@ -631,7 +631,7 @@ func (api *API) traceBlockParallel(ctx context.Context, block *types.Block, stat
 	// Execute all the transaction contained within the block concurrently
 	var (
 		txs       = block.Transactions()
-		blockHash = block.Hash()
+		blockHash = api.blockHash(block)
 		blockCtx  = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
 		signer    = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
 		results   = make([]*txTraceResult, len(txs))
@@ -769,7 +769,7 @@ func (api *API) standardTraceBlockToFile(ctx context.Context, block *types.Block
 		// If the transaction needs tracing, swap out the configs
 		if tx.Hash() == txHash || txHash == (common.Hash{}) {
 			// Generate a unique temporary file to dump it into
-			prefix := fmt.Sprintf("block_%#x-%d-%#x-", block.Hash().Bytes()[:4], i, tx.Hash().Bytes()[:4])
+			prefix := fmt.Sprintf("block_%#x-%d-%#x-", api.blockHash(block).Bytes()[:4], i, tx.Hash().Bytes()[:4])
 			if !canon {
 				prefix = fmt.Sprintf("%valt-", prefix)
 			}

eth/tracers/api.libevm.go

@@ -0,0 +1,42 @@
+// Copyright 2026 the libevm authors.
+//
+// The libevm additions to go-ethereum are free software: you can redistribute
+// them and/or modify them 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.
+//
+// The libevm additions are distributed in the hope that they 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 the go-ethereum library. If not, see
+// <http://www.gnu.org/licenses/>.
+
+package tracers
+
+import (
+	"github.com/ava-labs/libevm/common"
+	"github.com/ava-labs/libevm/core/types"
+)
+
+// BlockHashOverrider is an optional extension to [Backend], allowing an
+// arbitrary block hash to be returned for a block. If not implemented,
+// [types.Block.Hash] is used instead.
+//
+// This would be used in the case that the [types.Header] is manipulated in the
+// [Backend] for tracer-specific behavior. However, all hashes directly
+// returned by the [Backend] are expected to be correct.
+type BlockHashOverrider interface {
+	// BlockHash returns the hash of the provided block.
+	BlockHash(*types.Block) common.Hash
+}
+
+func (a *API) blockHash(block *types.Block) common.Hash {
+	overrider, ok := a.backend.(BlockHashOverrider)
+	if !ok {
+		return block.Hash()
+	}
+	return overrider.BlockHash(block)
+}