Add detection of Arbos Version to the evaluation of IsPrauge

cmd/evm/internal/t8ntool/execution.go

@@ -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,7 @@ 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) {
+	if chainConfig.IsPrague(vmContext.BlockNumber, vmContext.Time, vmContext.ArbOSVersion) {
 		requests = [][]byte{}
 		// EIP-6110
 		var allLogs []*types.Log

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:

core/chain_makers.go

@@ -314,7 +314,8 @@ func (b *BlockGen) collectRequests(readonly bool) (requests [][]byte) {
 		statedb = statedb.Copy()
 	}
 
-	if b.cm.config.IsPrague(b.header.Number, b.header.Time) {
+	blockContext := NewEVMBlockContext(b.header, b.cm, &b.header.Coinbase)
+	if b.cm.config.IsPrague(b.header.Number, b.header.Time, blockContext.ArbOSVersion) {
 		requests = [][]byte{}
 		// EIP-6110 deposits
 		var blockLogs []*types.Log
@@ -386,9 +387,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)

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
 		}
 	}

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.VersionedArbitrumSigner(p.config, header.Number, header.Time, blockContext.ArbOSVersion)
 	)
 	// Iterate over and process the individual transactions
 	byzantium := p.config.IsByzantium(block.Number())

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.VersionedArbitrumSigner(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,7 @@ 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()) {
+	if p.config.IsPrague(block.Number(), block.Time(), context.ArbOSVersion) {
 		requests = [][]byte{}
 		// EIP-6110
 		if err := ParseDepositLogs(&requests, allLogs, p.config); err != nil {
@@ -213,7 +214,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.VersionedArbitrumSigner(evm.ChainConfig(), header.Number, header.Time, evm.Context.ArbOSVersion), header.BaseFee, runMode)
 	if err != nil {
 		return nil, nil, err
 	}

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

core/types/arbitrum_signer.go

@@ -4,6 +4,7 @@ import (
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/params"
 )
 
 var ArbosAddress = common.HexToAddress("0xa4b05")
@@ -95,3 +96,30 @@ func (s arbitrumSigner) Hash(tx *Transaction) common.Hash {
 	}
 	return s.Signer.Hash(tx)
 }
+
+// VersionedArbitrumSigner wraps the go-ethereum signer in an ArbitrumSigner
+// that can handle both legacy and new transactions.
+func VersionedArbitrumSigner(config *params.ChainConfig, blockNumber *big.Int, blockTime uint64, arbitrumVersion uint64) Signer {
+	var signer Signer
+	switch {
+	case config.IsPrague(blockNumber, blockTime, arbitrumVersion):
+		signer = NewPragueSigner(config.ChainID)
+	// we can use 0 here because arbitrum doesn't support Blob transactions.
+	case config.IsCancun(blockNumber, blockTime, 0):
+		signer = NewCancunSigner(config.ChainID)
+	case config.IsLondon(blockNumber):
+		signer = NewLondonSigner(config.ChainID)
+	case config.IsBerlin(blockNumber):
+		signer = NewEIP2930Signer(config.ChainID)
+	case config.IsEIP155(blockNumber):
+		signer = NewEIP155Signer(config.ChainID)
+	case config.IsHomestead(blockNumber):
+		signer = HomesteadSigner{}
+	default:
+		signer = FrontierSigner{}
+	}
+	if config.IsArbitrum() {
+		signer = NewArbitrumSigner(signer)
+	}
+	return signer
+}

core/types/transaction_signing.go

@@ -37,10 +37,19 @@ type sigCache struct {
 }
 
 // MakeSigner returns a Signer based on the given chain config and block number.
+//
+// Arbitrum: If the signer is being used in any state-transition affecting code,
+// then this is not the right function to use. Instead, use
+// types.VersionedArbitrumSigner(), which will return the correct signer based
+// on the current block number and time, and active arbitrum version.
 func MakeSigner(config *params.ChainConfig, blockNumber *big.Int, blockTime uint64) Signer {
 	var signer Signer
 	switch {
-	case config.IsPrague(blockNumber, blockTime):
+	// Using MaxArbosVersionSupported effectively means that if Arbos is
+	// enabled, and we're running the current version of the OCL fork of
+	// go-ethereum, or the machine with the current wasm root, then, we will use
+	// the Prague signer.
+	case config.IsPrague(blockNumber, blockTime, params.MaxArbosVersionSupported):
 		signer = NewPragueSigner(config.ChainID)
 	// we can use 0 here because arbitrum doesn't support Blob transactions.
 	case config.IsCancun(blockNumber, blockTime, 0):

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.VersionedArbitrumSigner(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

eth/tracers/api.go

@@ -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
@@ -544,7 +544,7 @@ func (api *API) IntermediateRoots(ctx context.Context, hash common.Hash, 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)
 	}
 
@@ -785,7 +785,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() {

internal/ethapi/simulate.go

@@ -168,9 +168,10 @@ func (sim *simulator) processBlock(ctx context.Context, block *simBlock, header,
 			}
 		}
 	}
-	if sim.chainConfig.IsCancun(header.Number, header.Time, types.DeserializeHeaderExtraInformation(header).ArbOSFormatVersion) {
+	arbOSVersion := types.DeserializeHeaderExtraInformation(header).ArbOSFormatVersion
+	if sim.chainConfig.IsCancun(header.Number, header.Time, arbOSVersion) {
 		var excess uint64
-		if sim.chainConfig.IsCancun(parent.Number, parent.Time, types.DeserializeHeaderExtraInformation(parent).ArbOSFormatVersion) {
+		if sim.chainConfig.IsCancun(parent.Number, parent.Time, arbOSVersion) {
 			excess = eip4844.CalcExcessBlobGas(sim.chainConfig, parent, header.Time)
 		}
 		header.ExcessBlobGas = &excess
@@ -206,7 +207,7 @@ func (sim *simulator) processBlock(ctx context.Context, block *simBlock, header,
 	if precompiles != nil {
 		evm.SetPrecompiles(precompiles)
 	}
-	if sim.chainConfig.IsPrague(header.Number, header.Time) || sim.chainConfig.IsVerkle(header.Number, header.Time) {
+	if sim.chainConfig.IsPrague(header.Number, header.Time, arbOSVersion) || sim.chainConfig.IsVerkle(header.Number, header.Time) {
 		core.ProcessParentBlockHash(header.ParentHash, evm)
 	}
 	var allLogs []*types.Log
@@ -256,7 +257,7 @@ func (sim *simulator) processBlock(ctx context.Context, block *simBlock, header,
 	}
 	var requests [][]byte
 	// Process EIP-7685 requests
-	if sim.chainConfig.IsPrague(header.Number, header.Time) {
+	if sim.chainConfig.IsPrague(header.Number, header.Time, arbOSVersion) {
 		requests = [][]byte{}
 		// EIP-6110
 		if err := core.ParseDepositLogs(&requests, allLogs, sim.chainConfig); err != nil {

miner/worker.go

@@ -120,7 +120,9 @@ func (miner *Miner) generateWork(params *generateParams, witness bool) *newPaylo
 
 	// Collect consensus-layer requests if Prague is enabled.
 	var requests [][]byte
-	if miner.chainConfig.IsPrague(work.header.Number, work.header.Time) {
+	parent := miner.chain.CurrentBlock()
+	prevArbOSVersion := types.DeserializeHeaderExtraInformation(parent).ArbOSFormatVersion
+	if miner.chainConfig.IsPrague(work.header.Number, work.header.Time, prevArbOSVersion) {
 		requests = [][]byte{}
 		// EIP-6110 deposits
 		if err := core.ParseDepositLogs(&requests, allLogs, miner.chainConfig); err != nil {
@@ -228,7 +230,7 @@ func (miner *Miner) prepareWork(genParams *generateParams, witness bool) (*envir
 	if header.ParentBeaconRoot != nil {
 		core.ProcessBeaconBlockRoot(*header.ParentBeaconRoot, env.evm)
 	}
-	if miner.chainConfig.IsPrague(header.Number, header.Time) {
+	if miner.chainConfig.IsPrague(header.Number, header.Time, prevArbosVersion) {
 		core.ProcessParentBlockHash(header.ParentHash, env.evm)
 	}
 	return env, nil

params/config.go

@@ -621,7 +621,10 @@ func (c *ChainConfig) IsCancun(num *big.Int, time uint64, currentArbosVersion ui
 }
 
 // IsPrague returns whether time is either equal to the Prague fork time or greater.
-func (c *ChainConfig) IsPrague(num *big.Int, time uint64) bool {
+func (c *ChainConfig) IsPrague(num *big.Int, time uint64, currentArbosVersion uint64) bool {
+	if c.IsArbitrum() {
+		return currentArbosVersion >= ArbosVersion_40
+	}
 	return c.IsLondon(num) && isTimestampForked(c.PragueTime, time)
 }
 
@@ -884,7 +887,7 @@ func (c *ChainConfig) LatestFork(time uint64, currentArbosVersion uint64) forks.
 	switch {
 	case c.IsOsaka(london, time):
 		return forks.Osaka
-	case c.IsPrague(london, time):
+	case c.IsPrague(london, time, currentArbosVersion):
 		return forks.Prague
 	case c.IsCancun(london, time, currentArbosVersion):
 		return forks.Cancun
@@ -1069,7 +1072,7 @@ func (c *ChainConfig) Rules(num *big.Int, isMerge bool, timestamp uint64, curren
 		IsMerge:          isMerge,
 		IsShanghai:       isMerge && c.IsShanghai(num, timestamp, currentArbosVersion),
 		IsCancun:         isMerge && c.IsCancun(num, timestamp, currentArbosVersion),
-		IsPrague:         isMerge && c.IsPrague(num, timestamp),
+		IsPrague:         isMerge && c.IsPrague(num, timestamp, currentArbosVersion),
 		IsOsaka:          isMerge && c.IsOsaka(num, timestamp),
 		IsVerkle:         isVerkle,
 		IsEIP4762:        isVerkle,