rpc: unify BlockOverrides into a single type with three override methods

Two separate BlockOverrides structs existed in the codebase
(ethapi.BlockOverrides and transactions.BlockOverrides) with overlapping
but divergent fields, different field types, and different JSON tags.
This caused inconsistencies across eth_call, eth_estimateGas,
eth_simulateV1, and eth_callMany.

Changes:
- Merge into a single ethapi.BlockOverrides with all 11 fields:
  Number, Difficulty, Time, GasLimit, FeeRecipient, PrevRandao,
  BaseFeePerGas, BlobBaseFee, BeaconRoot, BlockHash, Withdrawals
- Add ethapi.BlockHashOverrides (was only in transactions package)
- Three methods with clearly separated responsibilities:
  - Override(*BlockContext) error — for eth_call/eth_estimateGas;
    rejects BeaconRoot and Withdrawals (aligned with Geth);
    now propagates error (was silently swallowed before)
  - OverrideHeader(*Header) *Header — for eth_simulateV1 block assembly
  - OverrideBlockContext(*BlockContext, BlockHashOverrides) — for
    eth_simulateV1/eth_callMany; applies all fields including
    BlobBaseFee and BlockHash
- Remove duplicate struct from transactions/call.go
- Replace manual field-by-field application in eth_callMany with
  OverrideBlockContext call
- Add complete unit test suite: 20 tests covering all three methods,
  nil receivers, field isolation, overflow checks, rejection of
  unsupported fields, and BlockHash map merging

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: lupin012

rpc/ethapi/block_overrides.go

@@ -18,6 +18,9 @@ package ethapi
 
 import (
 	"errors"
+	"maps"
+
+	"github.com/holiman/uint256"
 
 	"github.com/erigontech/erigon/common"
 	"github.com/erigontech/erigon/common/hexutil"
@@ -26,55 +29,139 @@ import (
 	"github.com/erigontech/erigon/execution/vm/evmtypes"
 )
 
+// BlockHashOverrides maps block numbers to their hash overrides,
+// used to intercept BLOCKHASH opcode calls during simulation.
+type BlockHashOverrides map[uint64]common.Hash
+
+// BlockOverrides is the unified set of block-level fields that can be
+// overridden during simulation or call execution (eth_call, eth_estimateGas,
+// eth_simulateV1, eth_callMany).
 type BlockOverrides struct {
-	Number        *hexutil.Big        `json:"number"`
-	PrevRanDao    *common.Hash        `json:"prevRandao"`
-	Time          *hexutil.Uint64     `json:"time"`
-	GasLimit      *hexutil.Uint64     `json:"gasLimit"`
-	FeeRecipient  *common.Address     `json:"feeRecipient"`
-	BaseFeePerGas *hexutil.Big        `json:"baseFeePerGas"`
-	BlobBaseFee   *hexutil.Big        `json:"blobBaseFee"`
-	Withdrawals   []*types.Withdrawal `json:"withdrawals"`
+	Number        *hexutil.Big            `json:"number"`
+	Difficulty    *hexutil.Big            `json:"difficulty"`
+	Time          *hexutil.Uint64         `json:"time"`
+	GasLimit      *hexutil.Uint64         `json:"gasLimit"`
+	FeeRecipient  *common.Address         `json:"feeRecipient"`
+	PrevRandao    *common.Hash            `json:"prevRandao"`
+	BaseFeePerGas *hexutil.Big            `json:"baseFeePerGas"`
+	BlobBaseFee   *hexutil.Big            `json:"blobBaseFee"`
+	BeaconRoot    *common.Hash            `json:"beaconRoot"`
+	BlockHash     *map[uint64]common.Hash `json:"blockHash"`
+	Withdrawals   *types.Withdrawals      `json:"withdrawals"`
 }
 
+// Override applies overrides to an EVM block context used in single-call
+// methods (eth_call, eth_estimateGas). BeaconRoot and Withdrawals are
+// rejected because they are not meaningful in a single-call context.
 func (overrides *BlockOverrides) Override(context *evmtypes.BlockContext) error {
-
+	if overrides == nil {
+		return nil
+	}
+	if overrides.BeaconRoot != nil {
+		return errors.New(`block override "beaconRoot" is not supported for this RPC method`)
+	}
+	if overrides.Withdrawals != nil {
+		return errors.New(`block override "withdrawals" is not supported for this RPC method`)
+	}
 	if overrides.Number != nil {
 		context.BlockNumber = overrides.Number.Uint64()
 	}
-
-	if overrides.PrevRanDao != nil {
-		context.PrevRanDao = overrides.PrevRanDao
+	if overrides.Difficulty != nil {
+		context.Difficulty.SetFromBig(overrides.Difficulty.ToInt())
+	}
+	if overrides.PrevRandao != nil {
+		context.PrevRanDao = overrides.PrevRandao
 	}
-
 	if overrides.Time != nil {
-		context.Time = overrides.Time.Uint64()
+		context.Time = uint64(*overrides.Time)
 	}
-
 	if overrides.GasLimit != nil {
-		context.GasLimit = overrides.GasLimit.Uint64()
+		context.GasLimit = uint64(*overrides.GasLimit)
 	}
-
 	if overrides.FeeRecipient != nil {
 		context.Coinbase = accounts.InternAddress(*overrides.FeeRecipient)
 	}
-
 	if overrides.BaseFeePerGas != nil {
-		overflow := context.BaseFee.SetFromBig(overrides.BaseFeePerGas.ToInt())
-		if overflow {
+		if overflow := context.BaseFee.SetFromBig(overrides.BaseFeePerGas.ToInt()); overflow {
 			return errors.New("BlockOverrides.BaseFee uint256 overflow")
 		}
 	}
-
 	if overrides.BlobBaseFee != nil {
-		overflow := context.BlobBaseFee.SetFromBig(overrides.BlobBaseFee.ToInt())
-		if overflow {
+		if overflow := context.BlobBaseFee.SetFromBig(overrides.BlobBaseFee.ToInt()); overflow {
 			return errors.New("BlockOverrides.BlobBaseFee uint256 overflow")
 		}
 	}
+	return nil
+}
 
-	if overrides.Withdrawals != nil {
-		return errors.New("BlockOverrides.Withdrawals not supported")
+// OverrideHeader returns a modified copy of header with the overridden fields
+// applied. Used by eth_simulateV1 to build block headers before execution.
+// BeaconRoot and Withdrawals are handled separately by the caller at the
+// block-assembly level.
+func (overrides *BlockOverrides) OverrideHeader(header *types.Header) *types.Header {
+	if overrides == nil {
+		return header
+	}
+	h := types.CopyHeader(header)
+	if overrides.Number != nil {
+		h.Number.SetFromBig(overrides.Number.ToInt())
+	}
+	if overrides.Difficulty != nil {
+		h.Difficulty.SetFromBig(overrides.Difficulty.ToInt())
+	}
+	if overrides.Time != nil {
+		h.Time = uint64(*overrides.Time)
+	}
+	if overrides.GasLimit != nil {
+		h.GasLimit = uint64(*overrides.GasLimit)
+	}
+	if overrides.FeeRecipient != nil {
+		h.Coinbase = *overrides.FeeRecipient
+	}
+	if overrides.BaseFeePerGas != nil {
+		baseFee := new(uint256.Int)
+		baseFee.SetFromBig(overrides.BaseFeePerGas.ToInt())
+		h.BaseFee = baseFee
+	}
+	if overrides.PrevRandao != nil {
+		h.MixDigest = *overrides.PrevRandao
+	}
+	return h
+}
+
+// OverrideBlockContext applies overrides to an EVM block context used in
+// simulation (eth_simulateV1, eth_callMany). Unlike Override, it does not
+// reject BeaconRoot or Withdrawals — those are handled at the block-assembly
+// level by the caller.
+func (overrides *BlockOverrides) OverrideBlockContext(blockCtx *evmtypes.BlockContext, blockHashOverrides BlockHashOverrides) {
+	if overrides == nil {
+		return
+	}
+	if overrides.Number != nil {
+		blockCtx.BlockNumber = overrides.Number.Uint64()
+	}
+	if overrides.Difficulty != nil {
+		blockCtx.Difficulty.SetFromBig(overrides.Difficulty.ToInt())
+	}
+	if overrides.Time != nil {
+		blockCtx.Time = uint64(*overrides.Time)
+	}
+	if overrides.GasLimit != nil {
+		blockCtx.GasLimit = uint64(*overrides.GasLimit)
+	}
+	if overrides.FeeRecipient != nil {
+		blockCtx.Coinbase = accounts.InternAddress(*overrides.FeeRecipient)
+	}
+	if overrides.PrevRandao != nil {
+		blockCtx.PrevRanDao = overrides.PrevRandao
+	}
+	if overrides.BaseFeePerGas != nil {
+		blockCtx.BaseFee.SetFromBig(overrides.BaseFeePerGas.ToInt())
+	}
+	if overrides.BlobBaseFee != nil {
+		blockCtx.BlobBaseFee.SetFromBig(overrides.BlobBaseFee.ToInt())
+	}
+	if overrides.BlockHash != nil {
+		maps.Copy(blockHashOverrides, *overrides.BlockHash)
 	}
-	return nil
 }