replace MessageRunMode with a struct

arbitrum/apibackend.go

@@ -47,8 +47,6 @@ var (
 type APIBackend struct {
 	b *Backend
 
-	dbForAPICalls ethdb.Database
-
 	fallbackClient        types.FallbackClient
 	archiveClientsManager *archiveFallbackClientsManager
 	sync                  SyncProgressBackend
@@ -131,12 +129,6 @@ func createRegisterAPIBackend(backend *Backend, filterConfig filters.Config, fal
 	if err != nil {
 		return nil, err
 	}
-	// discard stylus-tag on any call made from api database
-	dbForAPICalls := backend.chainDb
-	wasmStore, tag := backend.chainDb.WasmDataBase()
-	if tag != 0 || len(backend.chainDb.WasmTargets()) > 1 {
-		dbForAPICalls = rawdb.WrapDatabaseWithWasm(backend.chainDb, wasmStore, 0, []ethdb.WasmTarget{rawdb.LocalTarget()})
-	}
 	var archiveClientsManager *archiveFallbackClientsManager
 	if len(archiveRedirects) != 0 {
 		archiveClientsManager, err = newArchiveFallbackClientsManager(archiveRedirects)
@@ -146,7 +138,6 @@ func createRegisterAPIBackend(backend *Backend, filterConfig filters.Config, fal
 	}
 	backend.apiBackend = &APIBackend{
 		b:                     backend,
-		dbForAPICalls:         dbForAPICalls,
 		fallbackClient:        fallbackClient,
 		archiveClientsManager: archiveClientsManager,
 	}
@@ -371,7 +362,7 @@ func (a *APIBackend) BlobBaseFee(ctx context.Context) *big.Int {
 }
 
 func (a *APIBackend) ChainDb() ethdb.Database {
-	return a.dbForAPICalls
+	return a.b.chainDb
 }
 
 func (a *APIBackend) AccountManager() *accounts.Manager {

arbitrum/recordingdb.go

@@ -266,7 +266,7 @@ func (r *RecordingDatabase) PrepareRecording(ctx context.Context, lastBlockHeade
 	defer func() { r.Dereference(finalDereference) }()
 	recordingKeyValue := newRecordingKV(r.db.TrieDB(), r.db.DiskDB())
 
-	recordingStateDatabase := state.NewDatabase(triedb.NewDatabase(rawdb.WrapDatabaseWithWasm(rawdb.NewDatabase(recordingKeyValue), r.db.WasmStore(), 0, r.db.WasmTargets()), nil), nil)
+	recordingStateDatabase := state.NewDatabase(triedb.NewDatabase(rawdb.WrapDatabaseWithWasm(rawdb.NewDatabase(recordingKeyValue), r.db.WasmStore()), nil), nil)
 	var prevRoot common.Hash
 	if lastBlockHeader != nil {
 		prevRoot = lastBlockHeader.Root

cmd/evm/internal/t8ntool/execution.go

@@ -236,7 +236,7 @@ func (pre *Prestate) Apply(vmConfig vm.Config, chainConfig *params.ChainConfig,
 			rejectedTxs = append(rejectedTxs, &rejectedTx{i, errMsg})
 			continue
 		}
-		msg, err := core.TransactionToMessage(tx, signer, pre.Env.BaseFee, core.MessageCommitMode)
+		msg, err := core.TransactionToMessage(tx, signer, pre.Env.BaseFee, core.NewMessageCommitContext(nil))
 		if err != nil {
 			log.Warn("rejected tx", "index", i, "hash", tx.Hash(), "error", err)
 			rejectedTxs = append(rejectedTxs, &rejectedTx{i, err.Error()})

core/rawdb/accessors_state_arbitrum.go

@@ -26,14 +26,16 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 )
 
+type WasmTarget string
+
 const (
-	TargetWavm  ethdb.WasmTarget = "wavm"
-	TargetArm64 ethdb.WasmTarget = "arm64"
-	TargetAmd64 ethdb.WasmTarget = "amd64"
-	TargetHost  ethdb.WasmTarget = "host"
+	TargetWavm  WasmTarget = "wavm"
+	TargetArm64 WasmTarget = "arm64"
+	TargetAmd64 WasmTarget = "amd64"
+	TargetHost  WasmTarget = "host"
 )
 
-func LocalTarget() ethdb.WasmTarget {
+func LocalTarget() WasmTarget {
 	if runtime.GOOS == "linux" {
 		switch runtime.GOARCH {
 		case "arm64":
@@ -45,7 +47,7 @@ func LocalTarget() ethdb.WasmTarget {
 	return TargetHost
 }
 
-func activatedAsmKeyPrefix(target ethdb.WasmTarget) (WasmPrefix, error) {
+func activatedAsmKeyPrefix(target WasmTarget) (WasmPrefix, error) {
 	var prefix WasmPrefix
 	switch target {
 	case TargetWavm:
@@ -62,19 +64,19 @@ func activatedAsmKeyPrefix(target ethdb.WasmTarget) (WasmPrefix, error) {
 	return prefix, nil
 }
 
-func IsSupportedWasmTarget(target ethdb.WasmTarget) bool {
+func IsSupportedWasmTarget(target WasmTarget) bool {
 	_, err := activatedAsmKeyPrefix(target)
 	return err == nil
 }
 
-func WriteActivation(db ethdb.KeyValueWriter, moduleHash common.Hash, asmMap map[ethdb.WasmTarget][]byte) {
+func WriteActivation(db ethdb.KeyValueWriter, moduleHash common.Hash, asmMap map[WasmTarget][]byte) {
 	for target, asm := range asmMap {
 		WriteActivatedAsm(db, target, moduleHash, asm)
 	}
 }
 
 // Stores the activated asm for a given moduleHash and target
-func WriteActivatedAsm(db ethdb.KeyValueWriter, target ethdb.WasmTarget, moduleHash common.Hash, asm []byte) {
+func WriteActivatedAsm(db ethdb.KeyValueWriter, target WasmTarget, moduleHash common.Hash, asm []byte) {
 	prefix, err := activatedAsmKeyPrefix(target)
 	if err != nil {
 		log.Crit("Failed to store activated wasm asm", "err", err)
@@ -86,7 +88,7 @@ func WriteActivatedAsm(db ethdb.KeyValueWriter, target ethdb.WasmTarget, moduleH
 }
 
 // Retrieves the activated asm for a given moduleHash and target
-func ReadActivatedAsm(db ethdb.KeyValueReader, target ethdb.WasmTarget, moduleHash common.Hash) []byte {
+func ReadActivatedAsm(db ethdb.KeyValueReader, target WasmTarget, moduleHash common.Hash) []byte {
 	prefix, err := activatedAsmKeyPrefix(target)
 	if err != nil {
 		log.Crit("Failed to read activated wasm asm", "err", err)

core/rawdb/database.go

@@ -46,11 +46,11 @@ type freezerdb struct {
 	ancientRoot string
 }
 
-func (frdb *freezerdb) WasmDataBase() (ethdb.KeyValueStore, uint32) {
-	return frdb, 0
+func (frdb *freezerdb) WasmDataBase() ethdb.KeyValueStore {
+	return frdb
 }
 
-func (frdb *freezerdb) WasmTargets() []ethdb.WasmTarget {
+func (frdb *freezerdb) WasmTargets() []WasmTarget {
 	return nil
 }
 
@@ -165,11 +165,11 @@ func (db *nofreezedb) AncientDatadir() (string, error) {
 	return "", errNotSupported
 }
 
-func (db *nofreezedb) WasmDataBase() (ethdb.KeyValueStore, uint32) {
-	return db, 0
+func (db *nofreezedb) WasmDataBase() ethdb.KeyValueStore {
+	return db
 }
 
-func (db *nofreezedb) WasmTargets() []ethdb.WasmTarget {
+func (db *nofreezedb) WasmTargets() []WasmTarget {
 	return nil
 }
 
@@ -181,17 +181,11 @@ func NewDatabase(db ethdb.KeyValueStore) ethdb.Database {
 
 type dbWithWasmEntry struct {
 	ethdb.Database
-	wasmDb       ethdb.KeyValueStore
-	wasmCacheTag uint32
-	wasmTargets  []ethdb.WasmTarget
+	wasmDb ethdb.KeyValueStore
 }
 
-func (db *dbWithWasmEntry) WasmDataBase() (ethdb.KeyValueStore, uint32) {
-	return db.wasmDb, db.wasmCacheTag
-}
-
-func (db *dbWithWasmEntry) WasmTargets() []ethdb.WasmTarget {
-	return db.wasmTargets
+func (db *dbWithWasmEntry) WasmDataBase() ethdb.KeyValueStore {
+	return db.wasmDb
 }
 
 func (db *dbWithWasmEntry) Close() error {
@@ -203,8 +197,8 @@ func (db *dbWithWasmEntry) Close() error {
 	return wasmErr
 }
 
-func WrapDatabaseWithWasm(db ethdb.Database, wasm ethdb.KeyValueStore, cacheTag uint32, targets []ethdb.WasmTarget) ethdb.Database {
-	return &dbWithWasmEntry{db, wasm, cacheTag, targets}
+func WrapDatabaseWithWasm(db ethdb.Database, wasm ethdb.KeyValueStore) ethdb.Database {
+	return &dbWithWasmEntry{db, wasm}
 }
 
 // resolveChainFreezerDir is a helper function which resolves the absolute path

core/rawdb/table.go

@@ -40,14 +40,10 @@ func (t *table) Close() error {
 	return nil
 }
 
-func (t *table) WasmDataBase() (ethdb.KeyValueStore, uint32) {
+func (t *table) WasmDataBase() ethdb.KeyValueStore {
 	return t.db.WasmDataBase()
 }
 
-func (t *table) WasmTargets() []ethdb.WasmTarget {
-	return t.db.WasmTargets()
-}
-
 // Has retrieves if a prefixed version of a key is present in the database.
 func (t *table) Has(key []byte) (bool, error) {
 	return t.db.Has(append([]byte(t.prefix), key...))

core/state/database.go

@@ -49,10 +49,8 @@ const (
 // Database wraps access to tries and contract code.
 type Database interface {
 	// Arbitrum: Read activated Stylus contracts
-	ActivatedAsm(target ethdb.WasmTarget, moduleHash common.Hash) (asm []byte, err error)
+	ActivatedAsm(target rawdb.WasmTarget, moduleHash common.Hash) (asm []byte, err error)
 	WasmStore() ethdb.KeyValueStore
-	WasmCacheTag() uint32
-	WasmTargets() []ethdb.WasmTarget
 
 	// Reader returns a state reader associated with the specified state root.
 	Reader(root common.Hash) (Reader, error)
@@ -155,17 +153,15 @@ type Trie interface {
 
 type activatedAsmCacheKey struct {
 	moduleHash common.Hash
-	target     ethdb.WasmTarget
+	target     rawdb.WasmTarget
 }
 
 // CachingDB is an implementation of Database interface. It leverages both trie and
 // state snapshot to provide functionalities for state access. It's meant to be a
 // long-live object and has a few caches inside for sharing between blocks.
 type CachingDB struct {
 	// Arbitrum
-	activatedAsmCache     *lru.SizeConstrainedCache[activatedAsmCacheKey, []byte]
-	wasmTag               uint32
-	wasmDatabaseRetriever ethdb.WasmDataBaseRetriever
+	activatedAsmCache *lru.SizeConstrainedCache[activatedAsmCacheKey, []byte]
 
 	disk          ethdb.KeyValueStore
 	wasmdb        ethdb.KeyValueStore
@@ -178,12 +174,10 @@ type CachingDB struct {
 
 // NewDatabase creates a state database with the provided data sources.
 func NewDatabase(triedb *triedb.Database, snap *snapshot.Tree) *CachingDB {
-	wasmdb, wasmTag := triedb.Disk().WasmDataBase()
+	wasmdb := triedb.Disk().WasmDataBase()
 	return &CachingDB{
 		// Arbitrum only
-		activatedAsmCache:     lru.NewSizeConstrainedCache[activatedAsmCacheKey, []byte](activatedWasmCacheSize),
-		wasmTag:               wasmTag,
-		wasmDatabaseRetriever: triedb.Disk(),
+		activatedAsmCache: lru.NewSizeConstrainedCache[activatedAsmCacheKey, []byte](activatedWasmCacheSize),
 
 		disk:          triedb.Disk(),
 		wasmdb:        wasmdb,
@@ -312,14 +306,6 @@ func (db *CachingDB) WasmStore() ethdb.KeyValueStore {
 	return db.wasmdb
 }
 
-func (db *CachingDB) WasmCacheTag() uint32 {
-	return db.wasmTag
-}
-
-func (db *CachingDB) WasmTargets() []ethdb.WasmTarget {
-	return db.wasmDatabaseRetriever.WasmTargets()
-}
-
 func (db *CachingDB) DiskDB() ethdb.KeyValueStore {
 	return db.disk
 }

core/state/database_arbitrum.go

@@ -5,10 +5,9 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/rawdb"
-	"github.com/ethereum/go-ethereum/ethdb"
 )
 
-func (db *CachingDB) ActivatedAsm(target ethdb.WasmTarget, moduleHash common.Hash) ([]byte, error) {
+func (db *CachingDB) ActivatedAsm(target rawdb.WasmTarget, moduleHash common.Hash) ([]byte, error) {
 	cacheKey := activatedAsmCacheKey{moduleHash, target}
 	if asm, _ := db.activatedAsmCache.Get(cacheKey); len(asm) > 0 {
 		return asm, nil

core/state/statedb_arbitrum.go

@@ -27,8 +27,8 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/lru"
+	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/ethereum/go-ethereum/trie"
@@ -50,7 +50,7 @@ var (
 	StylusDiscriminant = []byte{stylusEOFMagic, stylusEOFMagicSuffix, stylusEOFVersion}
 )
 
-type ActivatedWasm map[ethdb.WasmTarget][]byte
+type ActivatedWasm map[rawdb.WasmTarget][]byte
 
 // checks if a valid Stylus prefix is present
 func IsStylusProgram(b []byte) bool {
@@ -74,7 +74,7 @@ func NewStylusPrefix(dictionary byte) []byte {
 	return append(prefix, dictionary)
 }
 
-func (s *StateDB) ActivateWasm(moduleHash common.Hash, asmMap map[ethdb.WasmTarget][]byte) {
+func (s *StateDB) ActivateWasm(moduleHash common.Hash, asmMap map[rawdb.WasmTarget][]byte) {
 	_, exists := s.arbExtraData.activatedWasms[moduleHash]
 	if exists {
 		return
@@ -85,7 +85,7 @@ func (s *StateDB) ActivateWasm(moduleHash common.Hash, asmMap map[ethdb.WasmTarg
 	})
 }
 
-func (s *StateDB) TryGetActivatedAsm(target ethdb.WasmTarget, moduleHash common.Hash) ([]byte, error) {
+func (s *StateDB) TryGetActivatedAsm(target rawdb.WasmTarget, moduleHash common.Hash) ([]byte, error) {
 	asmMap, exists := s.arbExtraData.activatedWasms[moduleHash]
 	if exists {
 		if asm, exists := asmMap[target]; exists {
@@ -95,7 +95,7 @@ func (s *StateDB) TryGetActivatedAsm(target ethdb.WasmTarget, moduleHash common.
 	return s.db.ActivatedAsm(target, moduleHash)
 }
 
-func (s *StateDB) TryGetActivatedAsmMap(targets []ethdb.WasmTarget, moduleHash common.Hash) (map[ethdb.WasmTarget][]byte, error) {
+func (s *StateDB) TryGetActivatedAsmMap(targets []rawdb.WasmTarget, moduleHash common.Hash) (map[rawdb.WasmTarget][]byte, error) {
 	asmMap := s.arbExtraData.activatedWasms[moduleHash]
 	if asmMap != nil {
 		for _, target := range targets {
@@ -106,7 +106,7 @@ func (s *StateDB) TryGetActivatedAsmMap(targets []ethdb.WasmTarget, moduleHash c
 		return asmMap, nil
 	}
 	var err error
-	asmMap = make(map[ethdb.WasmTarget][]byte, len(targets))
+	asmMap = make(map[rawdb.WasmTarget][]byte, len(targets))
 	for _, target := range targets {
 		asm, dbErr := s.db.ActivatedAsm(target, moduleHash)
 		if dbErr == nil {
@@ -267,7 +267,7 @@ func (s *StateDB) StartRecording() {
 	s.arbExtraData.userWasms = make(UserWasms)
 }
 
-func (s *StateDB) RecordProgram(targets []ethdb.WasmTarget, moduleHash common.Hash) {
+func (s *StateDB) RecordProgram(targets []rawdb.WasmTarget, moduleHash common.Hash) {
 	if len(targets) == 0 {
 		// nothing to record
 		return

core/state/statedb_hooked.go

@@ -20,11 +20,11 @@ import (
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/stateless"
 	"github.com/ethereum/go-ethereum/core/tracing"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/ethdb"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/trie/utils"
 	"github.com/holiman/uint256"
@@ -278,7 +278,7 @@ func (s *hookedStateDB) Finalise(deleteEmptyObjects bool) {
 	}
 }
 
-func (s *hookedStateDB) ActivateWasm(moduleHash common.Hash, asmMap map[ethdb.WasmTarget][]byte) {
+func (s *hookedStateDB) ActivateWasm(moduleHash common.Hash, asmMap map[rawdb.WasmTarget][]byte) {
 	s.inner.ActivateWasm(moduleHash, asmMap)
 }
 
@@ -290,11 +290,11 @@ func (s *hookedStateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash {
 	return s.inner.IntermediateRoot(deleteEmptyObjects)
 }
 
-func (s *hookedStateDB) TryGetActivatedAsm(target ethdb.WasmTarget, moduleHash common.Hash) (asm []byte, err error) {
+func (s *hookedStateDB) TryGetActivatedAsm(target rawdb.WasmTarget, moduleHash common.Hash) (asm []byte, err error) {
 	return s.inner.TryGetActivatedAsm(target, moduleHash)
 }
 
-func (s *hookedStateDB) TryGetActivatedAsmMap(targets []ethdb.WasmTarget, moduleHash common.Hash) (asmMap map[ethdb.WasmTarget][]byte, err error) {
+func (s *hookedStateDB) TryGetActivatedAsmMap(targets []rawdb.WasmTarget, moduleHash common.Hash) (asmMap map[rawdb.WasmTarget][]byte, err error) {
 	return s.inner.TryGetActivatedAsmMap(targets, moduleHash)
 }
 

core/state_prefetcher.go

@@ -54,13 +54,14 @@ func (p *statePrefetcher) Prefetch(block *types.Block, statedb *state.StateDB, c
 	)
 	// Iterate over and process the individual transactions
 	byzantium := p.config.IsByzantium(block.Number())
+	runCtx := NewMessageEthcallContext()
 	for i, tx := range block.Transactions() {
 		// If block precaching was interrupted, abort
 		if interrupt != nil && interrupt.Load() {
 			return
 		}
 		// Convert the transaction into an executable message and pre-cache its sender
-		msg, err := TransactionToMessage(tx, signer, header.BaseFee, MessageEthcallMode)
+		msg, err := TransactionToMessage(tx, signer, header.BaseFee, runCtx)
 		if err != nil {
 			return // Also invalid block, bail out
 		}