Merge branch 'master' into use-cloudflare-bn256

eljobe · web-flow · commit 009cc4ba6b40 · 2025-04-03T11:54:19.000+02:00
diff --git a/arbitrum/conditionaltx.go b/arbitrum/conditionaltx.go
@@ -44,7 +44,8 @@ func SubmitConditionalTransaction(ctx context.Context, b *APIBackend, tx *types.
 		return common.Hash{}, err
 	}
 	// Print a log with full tx details for manual investigations and interventions
-	signer := types.MakeSigner(b.ChainConfig(), b.CurrentBlock().Number, b.CurrentBlock().Time)
+	arbosVersion := types.DeserializeHeaderExtraInformation(b.CurrentBlock()).ArbOSFormatVersion
+	signer := types.MakeSigner(b.ChainConfig(), b.CurrentBlock().Number, b.CurrentBlock().Time, arbosVersion)
 	from, err := types.Sender(signer, tx)
 	if err != nil {
 		return common.Hash{}, err
diff --git a/cmd/evm/internal/t8ntool/execution.go b/cmd/evm/internal/t8ntool/execution.go
@@ -147,7 +147,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 	}
 	var (
 		statedb     = MakePreState(rawdb.NewMemoryDatabase(), pre.Pre)
-		signer      = types.MakeSigner(chainConfig, new(big.Int).SetUint64(pre.Env.Number), pre.Env.Timestamp)
+		signer      = types.MakeSigner(chainConfig, new(big.Int).SetUint64(pre.Env.Number), pre.Env.Timestamp, params.MaxArbosVersionSupported)
 		gaspool     = new(core.GasPool)
 		blockHash   = common.Hash{0x13, 0x37}
 		rejectedTxs []*rejectedTx
@@ -216,7 +216,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 	if beaconRoot := pre.Env.ParentBeaconBlockRoot; beaconRoot != nil {
 		core.ProcessBeaconBlockRoot(*beaconRoot, evm)
 	}
-	if pre.Env.BlockHashes != nil && chainConfig.IsPrague(new(big.Int).SetUint64(pre.Env.Number), pre.Env.Timestamp) {
+	if pre.Env.BlockHashes != nil && chainConfig.IsPrague(new(big.Int).SetUint64(pre.Env.Number), pre.Env.Timestamp, vmContext.ArbOSVersion) {
 		var (
 			prevNumber = pre.Env.Number - 1
 			prevHash   = pre.Env.BlockHashes[math.HexOrDecimal64(prevNumber)]
@@ -355,7 +355,8 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 
 	// Gather the execution-layer triggered requests.
 	var requests [][]byte
-	if chainConfig.IsPrague(vmContext.BlockNumber, vmContext.Time) {
+	// Arbitrum doesn't support Deposit/Withdrawal/Consolidation requests.
+	if !chainConfig.IsArbitrum() && chainConfig.IsPrague(vmContext.BlockNumber, vmContext.Time, vmContext.ArbOSVersion) {
 		requests = [][]byte{}
 		// EIP-6110
 		var allLogs []*types.Log
diff --git a/cmd/evm/internal/t8ntool/transaction.go b/cmd/evm/internal/t8ntool/transaction.go
@@ -105,7 +105,7 @@ func Transaction(ctx *cli.Context) error {
 			return NewError(ErrorIO, errors.New("only rlp supported"))
 		}
 	}
-	signer := types.MakeSigner(chainConfig, new(big.Int), 0)
+	signer := types.MakeSigner(chainConfig, new(big.Int), 0, params.MaxArbosVersionSupported)
 
 	// We now have the transactions in 'body', which is supposed to be an
 	// rlp list of transactions
diff --git a/consensus/misc/eip4844/eip4844.go b/consensus/misc/eip4844/eip4844.go
@@ -107,7 +107,8 @@ func MaxBlobsPerBlock(cfg *params.ChainConfig, time uint64) int {
 	switch {
 	case cfg.IsOsaka(london, time) && s.Osaka != nil:
 		return s.Osaka.Max
-	case cfg.IsPrague(london, time) && s.Prague != nil:
+	// we can use 0 here because arbitrum doesn't support Blob transactions.
+	case cfg.IsPrague(london, time, 0) && s.Prague != nil:
 		return s.Prague.Max
 	// we can use 0 here because arbitrum doesn't support Blob transactions.
 	case cfg.IsCancun(london, time, 0) && s.Cancun != nil:
@@ -153,7 +154,8 @@ func targetBlobsPerBlock(cfg *params.ChainConfig, time uint64) int {
 	switch {
 	case cfg.IsOsaka(london, time) && s.Osaka != nil:
 		return s.Osaka.Target
-	case cfg.IsPrague(london, time) && s.Prague != nil:
+	// we can use 0 here because arbitrum doesn't support Blob transactions.
+	case cfg.IsPrague(london, time, 0) && s.Prague != nil:
 		return s.Prague.Target
 	// we can use 0 here because arbitrum doesn't support Blob transactions.
 	case cfg.IsCancun(london, time, 0) && s.Cancun != nil:
diff --git a/core/blockchain.go b/core/blockchain.go
@@ -1743,7 +1743,8 @@ func (bc *BlockChain) insertChain(chain types.Blocks, setHead bool, makeWitness
 		return nil, 0, nil
 	}
 	// Start a parallel signature recovery (signer will fluke on fork transition, minimal perf loss)
-	SenderCacher().RecoverFromBlocks(types.MakeSigner(bc.chainConfig, chain[0].Number(), chain[0].Time()), chain)
+	arbosVersion := types.DeserializeHeaderExtraInformation(chain[0].Header()).ArbOSFormatVersion
+	SenderCacher().RecoverFromBlocks(types.MakeSigner(bc.chainConfig, chain[0].Number(), chain[0].Time(), arbosVersion), chain)
 
 	var (
 		stats     = insertStats{startTime: mclock.Now()}
diff --git a/core/chain_makers.go b/core/chain_makers.go
@@ -201,7 +201,8 @@ func (b *BlockGen) Gas() uint64 {
 
 // Signer returns a valid signer instance for the current block.
 func (b *BlockGen) Signer() types.Signer {
-	return types.MakeSigner(b.cm.config, b.header.Number, b.header.Time)
+	arbosVersion := types.DeserializeHeaderExtraInformation(b.header).ArbOSFormatVersion
+	return types.MakeSigner(b.cm.config, b.header.Number, b.header.Time, arbosVersion)
 }
 
 // AddUncheckedReceipt forcefully adds a receipts to the block without a
@@ -314,7 +315,9 @@ func (b *BlockGen) collectRequests(readonly bool) (requests [][]byte) {
 		statedb = statedb.Copy()
 	}
 
-	if b.cm.config.IsPrague(b.header.Number, b.header.Time) {
+	arbosVersion := types.DeserializeHeaderExtraInformation(b.header).ArbOSFormatVersion
+	// Arbitrum doesn't support Deposit, Withdrawal, or Consolidation requests.
+	if !b.cm.config.IsArbitrum() && b.cm.config.IsPrague(b.header.Number, b.header.Time, arbosVersion) {
 		requests = [][]byte{}
 		// EIP-6110 deposits
 		var blockLogs []*types.Log
@@ -386,9 +389,9 @@ func GenerateChain(config *params.ChainConfig, parent *types.Block, engine conse
 			misc.ApplyDAOHardFork(statedb)
 		}
 
-		if config.IsPrague(b.header.Number, b.header.Time) || config.IsVerkle(b.header.Number, b.header.Time) {
+		blockContext := NewEVMBlockContext(b.header, cm, &b.header.Coinbase)
+		if config.IsPrague(b.header.Number, b.header.Time, blockContext.ArbOSVersion) || config.IsVerkle(b.header.Number, b.header.Time) {
 			// EIP-2935
-			blockContext := NewEVMBlockContext(b.header, cm, &b.header.Coinbase)
 			blockContext.Random = &common.Hash{} // enable post-merge instruction set
 			evm := vm.NewEVM(blockContext, statedb, cm.config, vm.Config{})
 			ProcessParentBlockHash(b.header.ParentHash, evm)
diff --git a/core/genesis.go b/core/genesis.go
@@ -508,7 +508,7 @@ func (g *Genesis) toBlockWithRoot(root common.Hash) *types.Block {
 				head.BlobGasUsed = new(uint64)
 			}
 		}
-		if conf.IsPrague(num, g.Timestamp) {
+		if conf.IsPrague(num, g.Timestamp, arbosVersion) {
 			head.RequestsHash = &types.EmptyRequestsHash
 		}
 	}
diff --git a/core/state_prefetcher.go b/core/state_prefetcher.go
@@ -50,7 +50,7 @@ func (p *statePrefetcher) Prefetch(block *types.Block, statedb *state.StateDB, c
 		gaspool      = new(GasPool).AddGas(block.GasLimit())
 		blockContext = NewEVMBlockContext(header, p.chain, nil)
 		evm          = vm.NewEVM(blockContext, statedb, p.config, cfg)
-		signer       = types.MakeSigner(p.config, header.Number, header.Time)
+		signer       = types.MakeSigner(p.config, header.Number, header.Time, blockContext.ArbOSVersion)
 	)
 	// Iterate over and process the individual transactions
 	byzantium := p.config.IsByzantium(block.Number())
diff --git a/core/state_processor.go b/core/state_processor.go
@@ -70,7 +70,6 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 	}
 	var (
 		context vm.BlockContext
-		signer  = types.MakeSigner(p.config, header.Number, header.Time)
 	)
 
 	// Apply pre-execution system calls.
@@ -81,10 +80,12 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 	context = NewEVMBlockContext(header, p.chain, nil)
 	evm := vm.NewEVM(context, tracingStateDB, p.config, cfg)
 
+	signer := types.MakeSigner(p.config, header.Number, header.Time, context.ArbOSVersion)
+
 	if beaconRoot := block.BeaconRoot(); beaconRoot != nil {
 		ProcessBeaconBlockRoot(*beaconRoot, evm)
 	}
-	if p.config.IsPrague(block.Number(), block.Time()) || p.config.IsVerkle(block.Number(), block.Time()) {
+	if p.config.IsPrague(block.Number(), block.Time(), context.ArbOSVersion) || p.config.IsVerkle(block.Number(), block.Time()) {
 		ProcessParentBlockHash(block.ParentHash(), evm)
 	}
 
@@ -106,7 +107,8 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg
 
 	// Read requests if Prague is enabled.
 	var requests [][]byte
-	if p.config.IsPrague(block.Number(), block.Time()) {
+	// Arbitrum has no Deposit, Witdrawal, or Consolidation requests.
+	if !p.config.IsArbitrum() && p.config.IsPrague(block.Number(), block.Time(), context.ArbOSVersion) {
 		requests = [][]byte{}
 		// EIP-6110
 		if err := ParseDepositLogs(&requests, allLogs, p.config); err != nil {
@@ -213,7 +215,7 @@ func ApplyTransaction(evm *vm.EVM, gp *GasPool, statedb *state.StateDB, header *
 }
 
 func ApplyTransactionWithResultFilter(evm *vm.EVM, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, runMode MessageRunMode, resultFilter func(*ExecutionResult) error) (*types.Receipt, *ExecutionResult, error) {
-	msg, err := TransactionToMessage(tx, types.MakeSigner(evm.ChainConfig(), header.Number, header.Time), header.BaseFee, runMode)
+	msg, err := TransactionToMessage(tx, types.MakeSigner(evm.ChainConfig(), header.Number, header.Time, evm.Context.ArbOSVersion), header.BaseFee, runMode)
 	if err != nil {
 		return nil, nil, err
 	}
diff --git a/core/txpool/validation.go b/core/txpool/validation.go
@@ -121,7 +121,7 @@ func ValidateTransaction(tx *types.Transaction, head *types.Header, signer types
 		return fmt.Errorf("%w: gas %v, minimum needed %v", core.ErrIntrinsicGas, tx.Gas(), intrGas)
 	}
 	// Ensure the transaction can cover floor data gas.
-	if opts.Config.IsPrague(head.Number, head.Time) {
+	if opts.Config.IsPrague(head.Number, head.Time, arbosVersion) {
 		floorDataGas, err := core.FloorDataGas(tx.Data())
 		if err != nil {
 			return err
diff --git a/core/types/receipt.go b/core/types/receipt.go
@@ -400,7 +400,7 @@ func (rs Receipts) EncodeIndex(i int, w *bytes.Buffer) {
 // DeriveFields fills the receipts with their computed fields based on consensus
 // data and contextual infos like containing block and transactions.
 func (rs Receipts) DeriveFields(config *params.ChainConfig, hash common.Hash, number uint64, time uint64, baseFee *big.Int, blobGasPrice *big.Int, txs []*Transaction) error {
-	signer := MakeSigner(config, new(big.Int).SetUint64(number), time)
+	signer := MakeSigner(config, new(big.Int).SetUint64(number), time, params.MaxArbosVersionSupported)
 
 	logIndex := uint(0)
 	if len(txs) != len(rs) {
diff --git a/core/types/transaction_signing.go b/core/types/transaction_signing.go
@@ -37,10 +37,15 @@ type sigCache struct {
 }
 
 // MakeSigner returns a Signer based on the given chain config and block number.
-func MakeSigner(config *params.ChainConfig, blockNumber *big.Int, blockTime uint64) Signer {
+//
+// Arbitrum: If the signer is being used in any state-transition affecting code,
+// then the active arbos version must be passed in. In places which don't affect
+// the state transition function, it is okay to pass in
+// params.MaxArbosVersionSupported.
+func MakeSigner(config *params.ChainConfig, blockNumber *big.Int, blockTime uint64, arbosVersion uint64) Signer {
 	var signer Signer
 	switch {
-	case config.IsPrague(blockNumber, blockTime):
+	case config.IsPrague(blockNumber, blockTime, arbosVersion):
 		signer = NewPragueSigner(config.ChainID)
 	// we can use 0 here because arbitrum doesn't support Blob transactions.
 	case config.IsCancun(blockNumber, blockTime, 0):
diff --git a/eth/downloader/queue_test.go b/eth/downloader/queue_test.go
@@ -44,7 +44,7 @@ func makeChain(n int, seed byte, parent *types.Block, empty bool) ([]*types.Bloc
 		block.SetCoinbase(common.Address{seed})
 		// Add one tx to every secondblock
 		if !empty && i%2 == 0 {
-			signer := types.MakeSigner(params.TestChainConfig, block.Number(), block.Timestamp())
+			signer := types.MakeSigner(params.TestChainConfig, block.Number(), block.Timestamp(), params.MaxArbosVersionSupported)
 			tx, err := types.SignTx(types.NewTransaction(block.TxNonce(testAddress), common.Address{seed}, big.NewInt(1000), params.TxGas, block.BaseFee(), nil), signer, testKey)
 			if err != nil {
 				panic(err)
diff --git a/eth/downloader/testchain_test.go b/eth/downloader/testchain_test.go
@@ -168,7 +168,7 @@ func (tc *testChain) generate(n int, seed byte, parent *types.Block, heavy bool)
 		}
 		// Include transactions to the miner to make blocks more interesting.
 		if parent == tc.blocks[0] && i%22 == 0 {
-			signer := types.MakeSigner(params.TestChainConfig, block.Number(), block.Timestamp())
+			signer := types.MakeSigner(params.TestChainConfig, block.Number(), block.Timestamp(), params.MaxArbosVersionSupported)
 			tx, err := types.SignTx(types.NewTransaction(block.TxNonce(testAddress), common.Address{seed}, big.NewInt(1000), params.TxGas, block.BaseFee(), nil), signer, testKey)
 			if err != nil {
 				panic(err)
diff --git a/eth/gasprice/gasprice.go b/eth/gasprice/gasprice.go
@@ -250,7 +250,8 @@ func (oracle *Oracle) getBlockValues(ctx context.Context, blockNum uint64, limit
 		}
 		return
 	}
-	signer := types.MakeSigner(oracle.backend.ChainConfig(), block.Number(), block.Time())
+	arbosVersion := types.DeserializeHeaderExtraInformation(block.Header()).ArbOSFormatVersion
+	signer := types.MakeSigner(oracle.backend.ChainConfig(), block.Number(), block.Time(), arbosVersion)
 
 	// Sort the transaction by effective tip in ascending sort.
 	txs := block.Transactions()
diff --git a/eth/state_accessor.go b/eth/state_accessor.go
@@ -261,14 +261,14 @@ func (eth *Ethereum) stateAtTransaction(ctx context.Context, block *types.Block,
 		core.ProcessBeaconBlockRoot(*beaconRoot, evm)
 	}
 	// If prague hardfork, insert parent block hash in the state as per EIP-2935.
-	if eth.blockchain.Config().IsPrague(block.Number(), block.Time()) {
+	if eth.blockchain.Config().IsPrague(block.Number(), block.Time(), context.ArbOSVersion) {
 		core.ProcessParentBlockHash(block.ParentHash(), evm)
 	}
 	if txIndex == 0 && len(block.Transactions()) == 0 {
 		return nil, vm.BlockContext{}, statedb, release, nil
 	}
 	// Recompute transactions up to the target index.
-	signer := types.MakeSigner(eth.blockchain.Config(), block.Number(), block.Time())
+	signer := types.MakeSigner(eth.blockchain.Config(), block.Number(), block.Time(), evm.Context.ArbOSVersion)
 	for idx, tx := range block.Transactions() {
 		if idx == txIndex {
 			return tx, context, statedb, release, nil
diff --git a/eth/tracers/api.go b/eth/tracers/api.go
@@ -271,8 +271,8 @@ func (api *API) traceChain(start, end *types.Block, config *TraceConfig, closed
 			// Fetch and execute the block trace taskCh
 			for task := range taskCh {
 				var (
-					signer   = types.MakeSigner(api.backend.ChainConfig(), task.block.Number(), task.block.Time())
 					blockCtx = core.NewEVMBlockContext(task.block.Header(), api.chainContext(ctx), nil)
+					signer   = types.MakeSigner(api.backend.ChainConfig(), task.block.Number(), task.block.Time(), blockCtx.ArbOSVersion)
 				)
 				// Trace all the transactions contained within
 				for i, tx := range task.block.Transactions() {
@@ -389,7 +389,7 @@ func (api *API) traceChain(start, end *types.Block, config *TraceConfig, closed
 				core.ProcessBeaconBlockRoot(*beaconRoot, evm)
 			}
 			// Insert parent hash in history contract.
-			if api.backend.ChainConfig().IsPrague(next.Number(), next.Time()) {
+			if api.backend.ChainConfig().IsPrague(next.Number(), next.Time(), context.ArbOSVersion) {
 				core.ProcessParentBlockHash(next.ParentHash(), evm)
 			}
 			// Clean out any pending release functions of trace state. Note this
@@ -535,16 +535,16 @@ func (api *API) IntermediateRoots(ctx context.Context, hash common.Hash, config
 	defer release()
 	var (
 		roots              []common.Hash
-		signer             = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
-		chainConfig        = api.backend.ChainConfig()
 		vmctx              = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
+		signer             = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time(), vmctx.ArbOSVersion)
+		chainConfig        = api.backend.ChainConfig()
 		deleteEmptyObjects = chainConfig.IsEIP158(block.Number())
 	)
 	evm := vm.NewEVM(vmctx, statedb, chainConfig, vm.Config{})
 	if beaconRoot := block.BeaconRoot(); beaconRoot != nil {
 		core.ProcessBeaconBlockRoot(*beaconRoot, evm)
 	}
-	if chainConfig.IsPrague(block.Number(), block.Time()) {
+	if chainConfig.IsPrague(block.Number(), block.Time(), vmctx.ArbOSVersion) {
 		core.ProcessParentBlockHash(block.ParentHash(), evm)
 	}
 	for i, tx := range block.Transactions() {
@@ -608,7 +608,7 @@ func (api *API) traceBlock(ctx context.Context, block *types.Block, config *Trac
 	if beaconRoot := block.BeaconRoot(); beaconRoot != nil {
 		core.ProcessBeaconBlockRoot(*beaconRoot, evm)
 	}
-	if api.backend.ChainConfig().IsPrague(block.Number(), block.Time()) {
+	if api.backend.ChainConfig().IsPrague(block.Number(), block.Time(), blockCtx.ArbOSVersion) {
 		core.ProcessParentBlockHash(block.ParentHash(), evm)
 	}
 
@@ -622,10 +622,11 @@ func (api *API) traceBlock(ctx context.Context, block *types.Block, config *Trac
 	}
 	// Native tracers have low overhead
 	var (
-		txs       = block.Transactions()
-		blockHash = block.Hash()
-		signer    = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
-		results   = make([]*txTraceResult, len(txs))
+		txs          = block.Transactions()
+		blockHash    = block.Hash()
+		arbosVersion = types.DeserializeHeaderExtraInformation(block.Header()).ArbOSFormatVersion
+		signer       = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time(), arbosVersion)
+		results      = make([]*txTraceResult, len(txs))
 	)
 	for i, tx := range txs {
 		// Generate the next state snapshot fast without tracing
@@ -651,11 +652,12 @@ func (api *API) traceBlock(ctx context.Context, block *types.Block, config *Trac
 func (api *API) traceBlockParallel(ctx context.Context, block *types.Block, statedb *state.StateDB, config *TraceConfig) ([]*txTraceResult, error) {
 	// Execute all the transaction contained within the block concurrently
 	var (
-		txs       = block.Transactions()
-		blockHash = block.Hash()
-		signer    = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
-		results   = make([]*txTraceResult, len(txs))
-		pend      sync.WaitGroup
+		txs          = block.Transactions()
+		blockHash    = block.Hash()
+		arbosVersion = types.DeserializeHeaderExtraInformation(block.Header()).ArbOSFormatVersion
+		signer       = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time(), arbosVersion)
+		results      = make([]*txTraceResult, len(txs))
+		pend         sync.WaitGroup
 	)
 	threads := runtime.NumCPU()
 	if threads > len(txs) {
@@ -767,9 +769,9 @@ func (api *API) standardTraceBlockToFile(ctx context.Context, block *types.Block
 	// Execute transaction, either tracing all or just the requested one
 	var (
 		dumps       []string
-		signer      = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time())
-		chainConfig = api.backend.ChainConfig()
 		vmctx       = core.NewEVMBlockContext(block.Header(), api.chainContext(ctx), nil)
+		signer      = types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time(), vmctx.ArbOSVersion)
+		chainConfig = api.backend.ChainConfig()
 		canon       = true
 	)
 	// Check if there are any overrides: the caller may wish to enable a future
@@ -785,7 +787,7 @@ func (api *API) standardTraceBlockToFile(ctx context.Context, block *types.Block
 	if beaconRoot := block.BeaconRoot(); beaconRoot != nil {
 		core.ProcessBeaconBlockRoot(*beaconRoot, evm)
 	}
-	if chainConfig.IsPrague(block.Number(), block.Time()) {
+	if chainConfig.IsPrague(block.Number(), block.Time(), vmctx.ArbOSVersion) {
 		core.ProcessParentBlockHash(block.ParentHash(), evm)
 	}
 	for i, tx := range block.Transactions() {
@@ -887,7 +889,7 @@ func (api *API) TraceTransaction(ctx context.Context, hash common.Hash, config *
 		return nil, err
 	}
 	defer release()
-	msg, err := core.TransactionToMessage(tx, types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time()), block.BaseFee(), core.MessageReplayMode)
+	msg, err := core.TransactionToMessage(tx, types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time(), vmctx.ArbOSVersion), block.BaseFee(), core.MessageReplayMode)
 	if err != nil {
 		return nil, err
 	}
diff --git a/eth/tracers/api_test.go b/eth/tracers/api_test.go
@@ -176,8 +176,8 @@ func (b *testBackend) StateAtTransaction(ctx context.Context, block *types.Block
 		return nil, vm.BlockContext{}, statedb, release, nil
 	}
 	// Recompute transactions up to the target index.
-	signer := types.MakeSigner(b.chainConfig, block.Number(), block.Time())
 	context := core.NewEVMBlockContext(block.Header(), b.chain, nil)
+	signer := types.MakeSigner(b.chainConfig, block.Number(), block.Time(), context.ArbOSVersion)
 	evm := vm.NewEVM(context, statedb, b.chainConfig, vm.Config{})
 	for idx, tx := range block.Transactions() {
 		if idx == txIndex {
diff --git a/eth/tracers/internal/tracetest/calltrace_test.go b/eth/tracers/internal/tracetest/calltrace_test.go
diff --git a/eth/tracers/internal/tracetest/flat_calltrace_test.go b/eth/tracers/internal/tracetest/flat_calltrace_test.go
diff --git a/eth/tracers/internal/tracetest/prestate_test.go b/eth/tracers/internal/tracetest/prestate_test.go
diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go
diff --git a/internal/ethapi/api_test.go b/internal/ethapi/api_test.go
diff --git a/internal/ethapi/simulate.go b/internal/ethapi/simulate.go
diff --git a/miner/worker.go b/miner/worker.go
diff --git a/params/config.go b/params/config.go

Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ func Transaction(ctx *cli.Context) error {`
`105`	`105`	`return NewError(ErrorIO, errors.New("only rlp supported"))`
`106`	`106`	`}`
`107`	`107`	`}`
`108`		`- signer := types.MakeSigner(chainConfig, new(big.Int), 0)`
	`108`	`+ signer := types.MakeSigner(chainConfig, new(big.Int), 0, params.MaxArbosVersionSupported)`
`109`	`109`
`110`	`110`	`// We now have the transactions in 'body', which is supposed to be an`
`111`	`111`	`// rlp list of transactions`
Original file line number	Diff line number	Diff line change
`@@ -1743,7 +1743,8 @@ func (bc *BlockChain) insertChain(chain types.Blocks, setHead bool, makeWitness`
`1743`	`1743`	`return nil, 0, nil`
`1744`	`1744`	`}`
`1745`	`1745`	`// Start a parallel signature recovery (signer will fluke on fork transition, minimal perf loss)`
`1746`		`- SenderCacher().RecoverFromBlocks(types.MakeSigner(bc.chainConfig, chain[0].Number(), chain[0].Time()), chain)`
	`1746`	`+ arbosVersion := types.DeserializeHeaderExtraInformation(chain[0].Header()).ArbOSFormatVersion`
	`1747`	`+ SenderCacher().RecoverFromBlocks(types.MakeSigner(bc.chainConfig, chain[0].Number(), chain[0].Time(), arbosVersion), chain)`
`1747`	`1748`
`1748`	`1749`	`var (`
`1749`	`1750`	`stats = insertStats{startTime: mclock.Now()}`
Original file line number	Diff line number	Diff line change
`@@ -508,7 +508,7 @@ func (g Genesis) toBlockWithRoot(root common.Hash) types.Block {`
`508`	`508`	`head.BlobGasUsed = new(uint64)`
`509`	`509`	`}`
`510`	`510`	`}`
`511`		`- if conf.IsPrague(num, g.Timestamp) {`
	`511`	`+ if conf.IsPrague(num, g.Timestamp, arbosVersion) {`
`512`	`512`	`head.RequestsHash = &types.EmptyRequestsHash`
`513`	`513`	`}`
`514`	`514`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ func (p statePrefetcher) Prefetch(block types.Block, statedb *state.StateDB, c`
`50`	`50`	`gaspool = new(GasPool).AddGas(block.GasLimit())`
`51`	`51`	`blockContext = NewEVMBlockContext(header, p.chain, nil)`
`52`	`52`	`evm = vm.NewEVM(blockContext, statedb, p.config, cfg)`
`53`		`- signer = types.MakeSigner(p.config, header.Number, header.Time)`
	`53`	`+ signer = types.MakeSigner(p.config, header.Number, header.Time, blockContext.ArbOSVersion)`
`54`	`54`	`)`
`55`	`55`	`// Iterate over and process the individual transactions`
`56`	`56`	`byzantium := p.config.IsByzantium(block.Number())`
Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,6 @@ func (p StateProcessor) Process(block types.Block, statedb *state.StateDB, cfg`
`70`	`70`	`}`
`71`	`71`	`var (`
`72`	`72`	`context vm.BlockContext`
`73`		`- signer = types.MakeSigner(p.config, header.Number, header.Time)`
`74`	`73`	`)`
`75`	`74`
`76`	`75`	`// Apply pre-execution system calls.`
`@@ -81,10 +80,12 @@ func (p StateProcessor) Process(block types.Block, statedb *state.StateDB, cfg`
`81`	`80`	`context = NewEVMBlockContext(header, p.chain, nil)`
`82`	`81`	`evm := vm.NewEVM(context, tracingStateDB, p.config, cfg)`
`83`	`82`
	`83`	`+ signer := types.MakeSigner(p.config, header.Number, header.Time, context.ArbOSVersion)`
	`84`	`+`
`84`	`85`	`if beaconRoot := block.BeaconRoot(); beaconRoot != nil {`
`85`	`86`	`ProcessBeaconBlockRoot(*beaconRoot, evm)`
`86`	`87`	`}`
`87`		`- if p.config.IsPrague(block.Number(), block.Time()) \|\| p.config.IsVerkle(block.Number(), block.Time()) {`
	`88`	`+ if p.config.IsPrague(block.Number(), block.Time(), context.ArbOSVersion) \|\| p.config.IsVerkle(block.Number(), block.Time()) {`
`88`	`89`	`ProcessParentBlockHash(block.ParentHash(), evm)`
`89`	`90`	`}`
`90`	`91`
`@@ -106,7 +107,8 @@ func (p StateProcessor) Process(block types.Block, statedb *state.StateDB, cfg`
`106`	`107`
`107`	`108`	`// Read requests if Prague is enabled.`
`108`	`109`	`var requests [][]byte`
`109`		`- if p.config.IsPrague(block.Number(), block.Time()) {`
	`110`	`+ // Arbitrum has no Deposit, Witdrawal, or Consolidation requests.`
	`111`	`+ if !p.config.IsArbitrum() && p.config.IsPrague(block.Number(), block.Time(), context.ArbOSVersion) {`
`110`	`112`	`requests = [][]byte{}`
`111`	`113`	`// EIP-6110`
`112`	`114`	`if err := ParseDepositLogs(&requests, allLogs, p.config); err != nil {`
`@@ -213,7 +215,7 @@ func ApplyTransaction(evm vm.EVM, gp GasPool, statedb state.StateDB, header `
`213`	`215`	`}`
`214`	`216`
`215`	`217`	`func ApplyTransactionWithResultFilter(evm vm.EVM, gp GasPool, statedb state.StateDB, header types.Header, tx types.Transaction, usedGas uint64, runMode MessageRunMode, resultFilter func(ExecutionResult) error) (types.Receipt, *ExecutionResult, error) {`
`216`		`- msg, err := TransactionToMessage(tx, types.MakeSigner(evm.ChainConfig(), header.Number, header.Time), header.BaseFee, runMode)`
	`218`	`+ msg, err := TransactionToMessage(tx, types.MakeSigner(evm.ChainConfig(), header.Number, header.Time, evm.Context.ArbOSVersion), header.BaseFee, runMode)`
`217`	`219`	`if err != nil {`
`218`	`220`	`return nil, nil, err`
`219`	`221`	`}`
Original file line number	Diff line number	Diff line change
`@@ -121,7 +121,7 @@ func ValidateTransaction(tx types.Transaction, head types.Header, signer types`
`121`	`121`	`return fmt.Errorf("%w: gas %v, minimum needed %v", core.ErrIntrinsicGas, tx.Gas(), intrGas)`
`122`	`122`	`}`
`123`	`123`	`// Ensure the transaction can cover floor data gas.`
`124`		`- if opts.Config.IsPrague(head.Number, head.Time) {`
	`124`	`+ if opts.Config.IsPrague(head.Number, head.Time, arbosVersion) {`
`125`	`125`	`floorDataGas, err := core.FloorDataGas(tx.Data())`
`126`	`126`	`if err != nil {`
`127`	`127`	`return err`