Fix eth_simulateV1 after Jovian fork (#732)

* fix(eth_simulatev1): Create synthetic Jovian Deposit TX, to not fail in the CalcDAFootprint() function.

* fix(eth_simulatev1): Return block without synthetic Jovian deposit tx.

* fix(eth_simulatev1): Extract JovianDepositTx() from tests, activate Jovian fork based on parent.Time.

* Inject L1 attributes tx in Optimism simulation

* Unexport JovianDepositTx and move to tests

Remove exported JovianDepositTx from core/types and add a local
jovianDepositTx helper in miner tests. Also remove the unused
encoding/binary import from the core/types file and add it to the test
files where needed.

* Pass nil options to sim.execute in test

* Pass nil as second argument in simulation test

* Embed L1 attributes tx in simulator

* Handle Optimism genesis without L1 tx

* Rename finalTxes to prependedTxes

* Remove nil argument from sim.execute calls

* Update internal/ethapi/api.go

Co-authored-by: kustrun <[email protected]>

---------

Co-authored-by: geoknee <[email protected]>

Author: kustrun

internal/ethapi/api.go

@@ -921,6 +921,18 @@ func (api *BlockChainAPI) SimulateV1(ctx context.Context, opts simOpts, blockNrO
 		validate:       opts.Validation,
 		fullTx:         opts.ReturnFullTransactions,
 	}
+	if api.b.ChainConfig().IsOptimism() {
+		block, err := api.b.BlockByNumberOrHash(ctx, *blockNrOrHash)
+		if err != nil {
+			return nil, err
+		}
+		if len(block.Transactions()) > 0 {
+			// For the special case of the genesis block, there are no transactions
+			// so we won't set the l1AttributesTx and the simulation will
+			// likely fail.
+			sim.l1AttributesTx = block.Transactions()[0]
+		}
+	}
 	return sim.execute(ctx, opts.BlockStateCalls)
 }
 

internal/ethapi/simulate.go

@@ -36,6 +36,7 @@ import (
 	"github.com/ethereum/go-ethereum/internal/ethapi/override"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rpc"
+	"github.com/ethereum/go-ethereum/trie"
 )
 
 const (
@@ -174,9 +175,14 @@ type simulator struct {
 	traceTransfers bool
 	validate       bool
 	fullTx         bool
+
+	// OP-Stack diff
+	l1AttributesTx *types.Transaction
 }
 
 // execute runs the simulation of a series of blocks.
+// OPStack-diff: execute accepts an l1 attributes transaction which (if non-nil) will be injected into each block
+// at position 0.
 func (sim *simulator) execute(ctx context.Context, blocks []simBlock) ([]*simBlockResult, error) {
 	if err := ctx.Err(); err != nil {
 		return nil, err
@@ -220,6 +226,8 @@ func (sim *simulator) execute(ctx context.Context, blocks []simBlock) ([]*simBlo
 	return results, nil
 }
 
+// OP-Stack diff: proceesBlock accepts an l1 attributes transaction which (if non-nil) will be injected into the block
+// at position 0.
 func (sim *simulator) processBlock(ctx context.Context, block *simBlock, header, parent *types.Header, headers []*types.Header, timeout time.Duration) (*types.Block, []simCallResult, map[common.Hash]common.Address, types.Receipts, error) {
 	// Set header fields that depend only on parent block.
 	// Parent hash is needed for evm.GetHashFn to work.
@@ -359,12 +367,36 @@ func (sim *simulator) processBlock(ctx context.Context, block *simBlock, header,
 		reqHash := types.CalcRequestsHash(requests)
 		header.RequestsHash = &reqHash
 	}
-	blockBody := &types.Body{Transactions: txes, Withdrawals: *block.BlockOverrides.Withdrawals}
+
+	// For Optimism blocks, inject the provided l1 attributes transaction at the beginning of the block.
+	// This is required because CalcDAFootprint (called by FinalizeAndAssemble for Jovian blocks)
+	// expects the first transaction to be a deposit transaction containing L1 attributes data.
+	isOptimism := sim.chainConfig.IsOptimism()
+	prependedTxes := txes
+	if isOptimism && sim.l1AttributesTx != nil {
+		prependedTxes = append([]*types.Transaction{sim.l1AttributesTx}, txes...)
+	}
+
+	blockBody := &types.Body{Transactions: prependedTxes, Withdrawals: *block.BlockOverrides.Withdrawals}
 	chainHeadReader := &simChainHeadReader{ctx, sim.b}
 	b, err := sim.b.Engine().FinalizeAndAssemble(chainHeadReader, header, sim.state, blockBody, receipts)
 	if err != nil {
 		return nil, nil, nil, nil, err
 	}
+
+	// For Optimism blocks, reconstruct the block without the l1 attributes transaction
+	// to maintain consistent indexing between transactions and receipts.
+	// We must use types.NewBlock to recompute TxHash correctly for the user transactions only.
+	if isOptimism && sim.l1AttributesTx != nil {
+		b = types.NewBlock(
+			b.Header(),
+			&types.Body{Transactions: txes, Withdrawals: *block.BlockOverrides.Withdrawals},
+			receipts,
+			trie.NewStackTrie(nil),
+			sim.chainConfig,
+		)
+	}
+
 	repairLogs(callResults, b.Hash())
 	return b, callResults, senders, receipts, nil
 }