use MessageRunContext struct

arbnode/api.go

@@ -8,7 +8,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/ethereum/go-ethereum/ethdb"
+	"github.com/ethereum/go-ethereum/core/rawdb"
 
 	"github.com/offchainlabs/nitro/arbutil"
 	"github.com/offchainlabs/nitro/staker"
@@ -55,7 +55,7 @@ func (a *BlockValidatorDebugAPI) ValidateMessageNumber(
 	return result, err
 }
 
-func (a *BlockValidatorDebugAPI) ValidationInputsAt(ctx context.Context, msgNum hexutil.Uint64, target ethdb.WasmTarget,
+func (a *BlockValidatorDebugAPI) ValidationInputsAt(ctx context.Context, msgNum hexutil.Uint64, target rawdb.WasmTarget,
 ) (server_api.InputJSON, error) {
 	return a.val.ValidationInputsAt(ctx, arbutil.MessageIndex(msgNum), target)
 }

arbos/block_processor.go

@@ -145,7 +145,7 @@ func ProduceBlock(
 	statedb *state.StateDB,
 	chainContext core.ChainContext,
 	isMsgForPrefetch bool,
-	runMode core.MessageRunMode,
+	runCtx *core.MessageRunContext,
 ) (*types.Block, types.Receipts, error) {
 	chainConfig := chainContext.Config()
 	txes, err := ParseL2Transactions(message, chainConfig.ChainID)
@@ -156,7 +156,7 @@ func ProduceBlock(
 
 	hooks := NoopSequencingHooks()
 	return ProduceBlockAdvanced(
-		message.Header, txes, delayedMessagesRead, lastBlockHeader, statedb, chainContext, hooks, isMsgForPrefetch, runMode,
+		message.Header, txes, delayedMessagesRead, lastBlockHeader, statedb, chainContext, hooks, isMsgForPrefetch, runCtx,
 	)
 }
 
@@ -170,7 +170,7 @@ func ProduceBlockAdvanced(
 	chainContext core.ChainContext,
 	sequencingHooks *SequencingHooks,
 	isMsgForPrefetch bool,
-	runMode core.MessageRunMode,
+	runCtx *core.MessageRunContext,
 ) (*types.Block, types.Receipts, error) {
 
 	arbState, err := arbosState.OpenSystemArbosState(statedb, nil, true)
@@ -324,7 +324,7 @@ func ProduceBlockAdvanced(
 				header,
 				tx,
 				&header.GasUsed,
-				runMode,
+				runCtx,
 				func(result *core.ExecutionResult) error {
 					return hooks.PostTxFilter(header, statedb, arbState, tx, sender, dataGas, result)
 				},

arbos/l1pricing/l1pricing.go

@@ -562,7 +562,7 @@ func makeFakeTxForMessage(message *core.Message) *types.Transaction {
 	}
 	// During gas estimation, we don't want the gas limit variability to change the L1 cost.
 	gas := message.GasLimit
-	if gas == 0 || message.TxRunMode == core.MessageGasEstimationMode {
+	if gas == 0 || message.TxRunContext.IsGasEstimation() {
 		gas = RandomGas
 	}
 	return types.NewTx(&types.DynamicFeeTx{

arbos/programs/native.go

@@ -28,7 +28,6 @@ import (
 	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/vm"
-	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/metrics"
 
@@ -71,10 +70,10 @@ func activateProgram(
 	arbosVersionForGas uint64,
 	debug bool,
 	burner burn.Burner,
+	runCtx *core.MessageRunContext,
 ) (*activationInfo, error) {
-	targets := db.Database().WasmTargets()
 	moduleActivationMandatory := true
-	info, asmMap, err := activateProgramInternal(program, codehash, wasm, page_limit, stylusVersion, arbosVersionForGas, debug, burner.GasLeft(), targets, moduleActivationMandatory)
+	info, asmMap, err := activateProgramInternal(program, codehash, wasm, page_limit, stylusVersion, arbosVersionForGas, debug, burner.GasLeft(), runCtx, moduleActivationMandatory)
 	if err != nil {
 		return nil, err
 	}
@@ -134,7 +133,7 @@ func compileNative(
 	wasm []byte,
 	stylusVersion uint16,
 	debug bool,
-	target ethdb.WasmTarget,
+	target rawdb.WasmTarget,
 ) ([]byte, error) {
 	output := &rustBytes{}
 	status_asm := C.stylus_compile(
@@ -160,11 +159,12 @@ func activateProgramInternal(
 	arbosVersionForGas uint64,
 	debug bool,
 	gasLeft *uint64,
-	targets []ethdb.WasmTarget,
+	runCtx *core.MessageRunContext,
 	moduleActivationMandatory bool,
-) (*activationInfo, map[ethdb.WasmTarget][]byte, error) {
+) (*activationInfo, map[rawdb.WasmTarget][]byte, error) {
+	targets := runCtx.WasmTargets()
 	var wavmFound bool
-	var nativeTargets []ethdb.WasmTarget
+	var nativeTargets []rawdb.WasmTarget
 	for _, target := range targets {
 		if target == rawdb.TargetWavm {
 			wavmFound = true
@@ -173,14 +173,14 @@ func activateProgramInternal(
 		}
 	}
 	type result struct {
-		target ethdb.WasmTarget
+		target rawdb.WasmTarget
 		asm    []byte
 		err    error
 	}
 	results := make(chan result)
 	// info will be set in separate thread, make sure to wait before reading
 	var info *activationInfo
-	asmMap := make(map[ethdb.WasmTarget][]byte, len(nativeTargets)+1)
+	asmMap := make(map[rawdb.WasmTarget][]byte, len(nativeTargets)+1)
 	if moduleActivationMandatory || wavmFound {
 		go func() {
 			var err error
@@ -233,7 +233,7 @@ func activateProgramInternal(
 	return info, asmMap, err
 }
 
-func getLocalAsm(statedb vm.StateDB, moduleHash common.Hash, addressForLogging common.Address, code []byte, codehash common.Hash, maxWasmSize uint32, pagelimit uint16, time uint64, debugMode bool, program Program) ([]byte, error) {
+func getLocalAsm(statedb vm.StateDB, moduleHash common.Hash, addressForLogging common.Address, code []byte, codehash common.Hash, maxWasmSize uint32, pagelimit uint16, time uint64, debugMode bool, program Program, runCtx *core.MessageRunContext) ([]byte, error) {
 	localTarget := rawdb.LocalTarget()
 	localAsm, err := statedb.TryGetActivatedAsm(localTarget, moduleHash)
 	if err == nil && len(localAsm) > 0 {
@@ -251,10 +251,9 @@ func getLocalAsm(statedb vm.StateDB, moduleHash common.Hash, addressForLogging c
 	zeroArbosVersion := uint64(0)
 	zeroGas := uint64(0)
 
-	targets := statedb.Database().WasmTargets()
 	// we know program is activated, so it must be in correct version and not use too much memory
 	moduleActivationMandatory := false
-	info, asmMap, err := activateProgramInternal(addressForLogging, codehash, wasm, pagelimit, program.version, zeroArbosVersion, debugMode, &zeroGas, targets, moduleActivationMandatory)
+	info, asmMap, err := activateProgramInternal(addressForLogging, codehash, wasm, pagelimit, program.version, zeroArbosVersion, debugMode, &zeroGas, runCtx, moduleActivationMandatory)
 	if err != nil {
 		log.Error("failed to reactivate program", "address", addressForLogging, "expected moduleHash", moduleHash, "err", err)
 		return nil, fmt.Errorf("failed to reactivate program address: %v err: %w", addressForLogging, err)
@@ -281,7 +280,7 @@ func getLocalAsm(statedb vm.StateDB, moduleHash common.Hash, addressForLogging c
 	}
 	asm, exists := asmMap[localTarget]
 	if !exists {
-		var availableTargets []ethdb.WasmTarget
+		var availableTargets []rawdb.WasmTarget
 		for target := range asmMap {
 			availableTargets = append(availableTargets, target)
 		}
@@ -302,7 +301,7 @@ func callProgram(
 	evmData *EvmData,
 	stylusParams *ProgParams,
 	memoryModel *MemoryModel,
-	arbos_tag uint32,
+	runCtx *core.MessageRunContext,
 ) ([]byte, error) {
 	db := interpreter.Evm().StateDB
 	debug := stylusParams.DebugMode
@@ -312,8 +311,10 @@ func callProgram(
 		panic("missing asm")
 	}
 
-	if stateDb, ok := db.(*state.StateDB); ok {
-		stateDb.RecordProgram(db.Database().WasmTargets(), moduleHash)
+	if runCtx.IsRecording() {
+		if stateDb, ok := db.(*state.StateDB); ok {
+			stateDb.RecordProgram(runCtx.WasmTargets(), moduleHash)
+		}
 	}
 
 	evmApi := newApi(interpreter, tracingInfo, scope, memoryModel)
@@ -329,7 +330,7 @@ func callProgram(
 		cbool(debug),
 		output,
 		(*u64)(&scope.Contract.Gas),
-		u32(arbos_tag),
+		u32(runCtx.WasmCacheTag()),
 	))
 
 	depth := interpreter.Depth()
@@ -356,24 +357,24 @@ func handleReqImpl(apiId usize, req_type u32, data *rustSlice, costPtr *u64, out
 
 // Caches a program in Rust. We write a record so that we can undo on revert.
 // For gas estimation and eth_call, we ignore permanent updates and rely on Rust's LRU.
-func cacheProgram(db vm.StateDB, module common.Hash, program Program, addressForLogging common.Address, code []byte, codehash common.Hash, params *StylusParams, debug bool, time uint64, runMode core.MessageRunMode) {
-	if runMode == core.MessageCommitMode {
+func cacheProgram(db vm.StateDB, module common.Hash, program Program, addressForLogging common.Address, code []byte, codehash common.Hash, params *StylusParams, debug bool, time uint64, runCtx *core.MessageRunContext) {
+	if runCtx.IsCommitMode() {
 		// address is only used for logging
-		asm, err := getLocalAsm(db, module, addressForLogging, code, codehash, params.MaxWasmSize, params.PageLimit, time, debug, program)
+		asm, err := getLocalAsm(db, module, addressForLogging, code, codehash, params.MaxWasmSize, params.PageLimit, time, debug, program, runCtx)
 		if err != nil {
 			panic("unable to recreate wasm")
 		}
-		tag := db.Database().WasmCacheTag()
+		tag := runCtx.WasmCacheTag()
 		state.CacheWasmRust(asm, module, program.version, tag, debug)
 		db.RecordCacheWasm(state.CacheWasm{ModuleHash: module, Version: program.version, Tag: tag, Debug: debug})
 	}
 }
 
 // Evicts a program in Rust. We write a record so that we can undo on revert, unless we don't need to (e.g. expired)
 // For gas estimation and eth_call, we ignore permanent updates and rely on Rust's LRU.
-func evictProgram(db vm.StateDB, module common.Hash, version uint16, debug bool, runMode core.MessageRunMode, forever bool) {
-	if runMode == core.MessageCommitMode {
-		tag := db.Database().WasmCacheTag()
+func evictProgram(db vm.StateDB, module common.Hash, version uint16, debug bool, runCtx *core.MessageRunContext, forever bool) {
+	if runCtx.IsCommitMode() {
+		tag := runCtx.WasmCacheTag()
 		state.EvictWasmRust(module, version, tag, debug)
 		if !forever {
 			db.RecordEvictWasm(state.EvictWasm{ModuleHash: module, Version: version, Tag: tag, Debug: debug})
@@ -463,7 +464,7 @@ func GetEntrySizeEstimateBytes(module []byte, version uint16, debug bool) uint64
 const DefaultTargetDescriptionArm = "arm64-linux-unknown+neon"
 const DefaultTargetDescriptionX86 = "x86_64-linux-unknown+sse4.2+lzcnt+bmi"
 
-func SetTarget(name ethdb.WasmTarget, description string, native bool) error {
+func SetTarget(name rawdb.WasmTarget, description string, native bool) error {
 	output := &rustBytes{}
 	status := userStatus(C.stylus_target_set(
 		goSlice([]byte(name)),

arbos/programs/programs.go

@@ -86,7 +86,7 @@ func (p Programs) CacheManagers() *addressSet.AddressSet {
 	return p.cacheManagers
 }
 
-func (p Programs) ActivateProgram(evm *vm.EVM, address common.Address, runMode core.MessageRunMode, debugMode bool) (
+func (p Programs) ActivateProgram(evm *vm.EVM, address common.Address, runCtx *core.MessageRunContext, debugMode bool) (
 	uint16, common.Hash, common.Hash, *big.Int, bool, error,
 ) {
 	statedb := evm.StateDB
@@ -120,7 +120,7 @@ func (p Programs) ActivateProgram(evm *vm.EVM, address common.Address, runMode c
 	// require the program's footprint not exceed the remaining memory budget
 	pageLimit := am.SaturatingUSub(params.PageLimit, statedb.GetStylusPagesOpen())
 
-	info, err := activateProgram(statedb, address, codeHash, wasm, pageLimit, stylusVersion, p.ArbosVersion, debugMode, burner)
+	info, err := activateProgram(statedb, address, codeHash, wasm, pageLimit, stylusVersion, p.ArbosVersion, debugMode, burner, runCtx)
 	if err != nil {
 		return 0, codeHash, common.Hash{}, nil, true, err
 	}
@@ -132,7 +132,7 @@ func (p Programs) ActivateProgram(evm *vm.EVM, address common.Address, runMode c
 			return 0, codeHash, common.Hash{}, nil, true, err
 		}
 
-		evictProgram(statedb, oldModuleHash, currentVersion, debugMode, runMode, expired)
+		evictProgram(statedb, oldModuleHash, currentVersion, debugMode, runCtx, expired)
 	}
 	if err := p.moduleHashes.Set(codeHash, info.moduleHash); err != nil {
 		return 0, codeHash, common.Hash{}, nil, true, err
@@ -160,35 +160,20 @@ func (p Programs) ActivateProgram(evm *vm.EVM, address common.Address, runMode c
 	// replace the cached asm
 	if cached {
 		code := statedb.GetCode(address)
-		cacheProgram(statedb, info.moduleHash, programData, address, code, codeHash, params, debugMode, time, runMode)
+		cacheProgram(statedb, info.moduleHash, programData, address, code, codeHash, params, debugMode, time, runCtx)
 	}
 
 	return stylusVersion, codeHash, info.moduleHash, dataFee, false, p.setProgram(codeHash, programData)
 }
 
-func runModeToString(runMode core.MessageRunMode) string {
-	switch runMode {
-	case core.MessageCommitMode:
-		return "commit_runmode"
-	case core.MessageGasEstimationMode:
-		return "gas_estimation_runmode"
-	case core.MessageEthcallMode:
-		return "eth_call_runmode"
-	case core.MessageReplayMode:
-		return "replay_runmode"
-	default:
-		return "unknown_runmode"
-	}
-}
-
 func (p Programs) CallProgram(
 	scope *vm.ScopeContext,
 	statedb vm.StateDB,
 	interpreter *vm.EVMInterpreter,
 	tracingInfo *util.TracingInfo,
 	calldata []byte,
 	reentrant bool,
-	runMode core.MessageRunMode,
+	runCtx *core.MessageRunContext,
 ) ([]byte, error) {
 	evm := interpreter.Evm()
 	contract := scope.Contract
@@ -234,7 +219,7 @@ func (p Programs) CallProgram(
 	statedb.AddStylusPages(program.footprint)
 	defer statedb.SetStylusPagesOpen(open)
 
-	localAsm, err := getLocalAsm(statedb, moduleHash, contract.Address(), contract.Code, contract.CodeHash, params.MaxWasmSize, params.PageLimit, evm.Context.Time, debugMode, program)
+	localAsm, err := getLocalAsm(statedb, moduleHash, contract.Address(), contract.Code, contract.CodeHash, params.MaxWasmSize, params.PageLimit, evm.Context.Time, debugMode, program, runCtx)
 	if err != nil {
 		panic("failed to get local wasm for activated program: " + contract.Address().Hex())
 	}
@@ -259,27 +244,22 @@ func (p Programs) CallProgram(
 	}
 
 	address := contract.Address()
-	var arbos_tag uint32
-	if runMode == core.MessageCommitMode {
-		arbos_tag = statedb.Database().WasmCacheTag()
-	}
-
-	metrics.GetOrRegisterCounter(fmt.Sprintf("arb/arbos/stylus/program_calls/%s", runModeToString(runMode)), nil).Inc(1)
-	ret, err := callProgram(address, moduleHash, localAsm, scope, interpreter, tracingInfo, calldata, evmData, goParams, model, arbos_tag)
+	metrics.GetOrRegisterCounter(fmt.Sprintf("arb/arbos/stylus/program_calls/%s", runCtx.RunModeMetricName()), nil).Inc(1)
+	ret, err := callProgram(address, moduleHash, localAsm, scope, interpreter, tracingInfo, calldata, evmData, goParams, model, runCtx)
 	if len(ret) > 0 && p.ArbosVersion >= gethParams.ArbosVersion_StylusFixes {
 		// Ensure that return data costs as least as much as it would in the EVM.
 		evmCost := evmMemoryCost(uint64(len(ret)))
 		if startingGas < evmCost {
 			contract.Gas = 0
 			// #nosec G115
-			metrics.GetOrRegisterCounter(fmt.Sprintf("arb/arbos/stylus/gas_used/%s", runModeToString(runMode)), nil).Inc(int64(startingGas))
+			metrics.GetOrRegisterCounter(fmt.Sprintf("arb/arbos/stylus/gas_used/%s", runCtx.RunModeMetricName()), nil).Inc(int64(startingGas))
 			return nil, vm.ErrOutOfGas
 		}
 		maxGasToReturn := startingGas - evmCost
 		contract.Gas = am.MinInt(contract.Gas, maxGasToReturn)
 	}
 	// #nosec G115
-	metrics.GetOrRegisterCounter(fmt.Sprintf("arb/arbos/stylus/gas_used/%s", runModeToString(runMode)), nil).Inc(int64(startingGas - contract.Gas))
+	metrics.GetOrRegisterCounter(fmt.Sprintf("arb/arbos/stylus/gas_used/%s", runCtx.RunModeMetricName()), nil).Inc(int64(startingGas - contract.Gas))
 	return ret, err
 }
 
@@ -417,7 +397,7 @@ func (p Programs) SetProgramCached(
 	cache bool,
 	time uint64,
 	params *StylusParams,
-	runMode core.MessageRunMode,
+	runCtx *core.MessageRunContext,
 	debug bool,
 ) error {
 	program, err := p.getProgram(codeHash, time)
@@ -453,9 +433,9 @@ func (p Programs) SetProgramCached(
 		if err != nil {
 			return err
 		}
-		cacheProgram(db, moduleHash, program, address, code, codeHash, params, debug, time, runMode)
+		cacheProgram(db, moduleHash, program, address, code, codeHash, params, debug, time, runCtx)
 	} else {
-		evictProgram(db, moduleHash, program.version, debug, runMode, expired)
+		evictProgram(db, moduleHash, program.version, debug, runCtx, expired)
 	}
 	program.cached = cache
 	return p.setProgram(codeHash, program)

arbos/programs/wasm.go

@@ -64,6 +64,7 @@ func activateProgram(
 	arbosVersion uint64,
 	debug bool,
 	burner burn.Burner,
+	runCtx *core.MessageRunContext,
 ) (*activationInfo, error) {
 	errBuf := make([]byte, 1024)
 	debugMode := arbmath.BoolToUint32(debug)
@@ -98,9 +99,9 @@ func activateProgram(
 }
 
 // stub any non-consensus, Rust-side caching updates
-func cacheProgram(db vm.StateDB, module common.Hash, program Program, addressForLogging common.Address, code []byte, codeHash common.Hash, params *StylusParams, debug bool, time uint64, runMode core.MessageRunMode) {
+func cacheProgram(db vm.StateDB, module common.Hash, program Program, addressForLogging common.Address, code []byte, codeHash common.Hash, params *StylusParams, debug bool, time uint64, runCtx *core.MessageRunContext) {
 }
-func evictProgram(db vm.StateDB, module common.Hash, version uint16, debug bool, mode core.MessageRunMode, forever bool) {
+func evictProgram(db vm.StateDB, module common.Hash, version uint16, debug bool, runCtx *core.MessageRunContext, forever bool) {
 }
 
 //go:wasmimport programs new_program
@@ -131,7 +132,7 @@ func startProgram(module uint32) uint32
 //go:wasmimport programs send_response
 func sendResponse(req_id uint32) uint32
 
-func getLocalAsm(statedb vm.StateDB, moduleHash common.Hash, addressForLogging common.Address, code []byte, codeHash common.Hash, maxWasmSize uint32, pagelimit uint16, time uint64, debugMode bool, program Program) ([]byte, error) {
+func getLocalAsm(statedb vm.StateDB, moduleHash common.Hash, addressForLogging common.Address, code []byte, codeHash common.Hash, maxWasmSize uint32, pagelimit uint16, time uint64, debugMode bool, program Program, runCtx *core.MessageRunContext) ([]byte, error) {
 	return nil, nil
 }
 
@@ -146,7 +147,7 @@ func callProgram(
 	evmData *EvmData,
 	params *ProgParams,
 	memoryModel *MemoryModel,
-	_arbos_tag uint32,
+	runCtx *core.MessageRunContext,
 ) ([]byte, error) {
 	reqHandler := newApiClosures(interpreter, tracingInfo, scope, memoryModel)
 	gasLeft, retData, err := CallProgramLoop(moduleHash, calldata, scope.Contract.Gas, evmData, params, reqHandler)