From 2c2bf887e066a3879b2e57b5223aa7af3ebf233d Mon Sep 17 00:00:00 2001 From: Maciej Kulawik Date: Fri, 8 Nov 2024 16:34:47 +0200 Subject: [PATCH 01/12] draft MessageRunMode struct --- arbitrum/apibackend.go | 4 +- arbitrum/recordingdb.go | 2 +- core/rawdb/database.go | 9 +-- core/rawdb/table.go | 4 - core/state/database.go | 5 -- core/state_prefetcher.go | 3 +- core/state_processor.go | 9 ++- core/state_transition.go | 81 ++++++++++++++++--- eth/gasestimator/gasestimator.go | 4 +- eth/state_accessor.go | 4 +- eth/tracers/api.go | 24 ++++-- eth/tracers/api_test.go | 3 +- .../internal/tracetest/calltrace_test.go | 7 +- .../internal/tracetest/flat_calltrace_test.go | 3 +- .../internal/tracetest/prestate_test.go | 3 +- eth/tracers/tracers_test.go | 3 +- ethdb/database.go | 1 - ethdb/remotedb/remotedb.go | 4 - graphql/graphql.go | 4 +- internal/ethapi/api.go | 17 ++-- internal/ethapi/transaction_args.go | 2 +- 21 files changed, 127 insertions(+), 69 deletions(-) diff --git a/arbitrum/apibackend.go b/arbitrum/apibackend.go index a31fcd30a0..3d278fcd0e 100644 --- a/arbitrum/apibackend.go +++ b/arbitrum/apibackend.go @@ -106,8 +106,8 @@ func createRegisterAPIBackend(backend *Backend, filterConfig filters.Config, fal // 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()}) + if tag != 0 { + dbForAPICalls = rawdb.WrapDatabaseWithWasm(backend.chainDb, wasmStore, 0) } backend.apiBackend = &APIBackend{ b: backend, diff --git a/arbitrum/recordingdb.go b/arbitrum/recordingdb.go index f7fd017520..0f1a48361a 100644 --- a/arbitrum/recordingdb.go +++ b/arbitrum/recordingdb.go @@ -258,7 +258,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(rawdb.WrapDatabaseWithWasm(rawdb.NewDatabase(recordingKeyValue), r.db.WasmStore(), 0, r.db.WasmTargets())) + recordingStateDatabase := state.NewDatabase(rawdb.WrapDatabaseWithWasm(rawdb.NewDatabase(recordingKeyValue), r.db.WasmStore(), 0)) var prevRoot common.Hash if lastBlockHeader != nil { prevRoot = lastBlockHeader.Root diff --git a/core/rawdb/database.go b/core/rawdb/database.go index 9bb80cc8be..f2e71c6d6d 100644 --- a/core/rawdb/database.go +++ b/core/rawdb/database.go @@ -184,17 +184,12 @@ type dbWithWasmEntry struct { ethdb.Database wasmDb ethdb.KeyValueStore wasmCacheTag uint32 - wasmTargets []ethdb.WasmTarget } func (db *dbWithWasmEntry) WasmDataBase() (ethdb.KeyValueStore, uint32) { return db.wasmDb, db.wasmCacheTag } -func (db *dbWithWasmEntry) WasmTargets() []ethdb.WasmTarget { - return db.wasmTargets -} - func (db *dbWithWasmEntry) Close() error { dbErr := db.Database.Close() wasmErr := db.wasmDb.Close() @@ -204,8 +199,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, cacheTag uint32) ethdb.Database { + return &dbWithWasmEntry{db, wasm, cacheTag} } // resolveChainFreezerDir is a helper function which resolves the absolute path diff --git a/core/rawdb/table.go b/core/rawdb/table.go index 7d21e5e5eb..5f09b48203 100644 --- a/core/rawdb/table.go +++ b/core/rawdb/table.go @@ -44,10 +44,6 @@ func (t *table) WasmDataBase() (ethdb.KeyValueStore, uint32) { 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...)) diff --git a/core/state/database.go b/core/state/database.go index 6ded7db3b6..f0bf0f08d4 100644 --- a/core/state/database.go +++ b/core/state/database.go @@ -56,7 +56,6 @@ type Database interface { ActivatedAsm(target ethdb.WasmTarget, moduleHash common.Hash) (asm []byte, err error) WasmStore() ethdb.KeyValueStore WasmCacheTag() uint32 - WasmTargets() []ethdb.WasmTarget // OpenTrie opens the main account trie. OpenTrie(root common.Hash) (Trie, error) @@ -221,10 +220,6 @@ func (db *cachingDB) WasmCacheTag() uint32 { return db.wasmTag } -func (db *cachingDB) WasmTargets() []ethdb.WasmTarget { - return db.wasmDatabaseRetriever.WasmTargets() -} - // OpenTrie opens the main account trie at a specific root hash. func (db *cachingDB) OpenTrie(root common.Hash) (Trie, error) { if db.triedb.IsVerkle() { diff --git a/core/state_prefetcher.go b/core/state_prefetcher.go index 572b715506..cd5ae60bba 100644 --- a/core/state_prefetcher.go +++ b/core/state_prefetcher.go @@ -57,13 +57,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()) + runMode := NewMessageEthcallMode() 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, runMode) if err != nil { return // Also invalid block, bail out } diff --git a/core/state_processor.go b/core/state_processor.go index b43e75dab1..0d0c25bd70 100644 --- a/core/state_processor.go +++ b/core/state_processor.go @@ -24,9 +24,11 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/consensus" "github.com/ethereum/go-ethereum/consensus/misc" + "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" + "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/params" ) @@ -79,9 +81,10 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg if beaconRoot := block.BeaconRoot(); beaconRoot != nil { ProcessBeaconBlockRoot(*beaconRoot, vmenv, statedb) } + runMode := NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()}) // Iterate over and process the individual transactions for i, tx := range block.Transactions() { - msg, err := TransactionToMessage(tx, signer, header.BaseFee, MessageReplayMode) + msg, err := TransactionToMessage(tx, signer, header.BaseFee, runMode) if err != nil { return nil, nil, 0, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err) } @@ -179,10 +182,10 @@ func ApplyTransactionWithEVM(msg *Message, config *params.ChainConfig, gp *GasPo // for the transaction, gas used and an error if the transaction failed, // indicating the block was invalid. func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config) (*types.Receipt, *ExecutionResult, error) { - return ApplyTransactionWithResultFilter(config, bc, author, gp, statedb, header, tx, usedGas, cfg, MessageReplayMode, nil) + return ApplyTransactionWithResultFilter(config, bc, author, gp, statedb, header, tx, usedGas, cfg, NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()}), nil) } -func ApplyTransactionWithResultFilter(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config, runMode MessageRunMode, resultFilter func(*ExecutionResult) error) (*types.Receipt, *ExecutionResult, error) { +func ApplyTransactionWithResultFilter(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config, runMode *MessageRunMode, resultFilter func(*ExecutionResult) error) (*types.Receipt, *ExecutionResult, error) { msg, err := TransactionToMessage(tx, types.MakeSigner(config, header.Number, header.Time), header.BaseFee, runMode) if err != nil { return nil, nil, err diff --git a/core/state_transition.go b/core/state_transition.go index 8c01b2c285..cc2877f752 100644 --- a/core/state_transition.go +++ b/core/state_transition.go @@ -23,10 +23,12 @@ import ( "github.com/ethereum/go-ethereum/common" cmath "github.com/ethereum/go-ethereum/common/math" + "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/tracing" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/crypto/kzg4844" + "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/params" "github.com/holiman/uint256" ) @@ -135,7 +137,7 @@ func toWordSize(size uint64) uint64 { // processing. type Message struct { // Arbitrum-specific - TxRunMode MessageRunMode + TxRunMode *MessageRunMode Tx *types.Transaction To *common.Address @@ -160,24 +162,79 @@ type Message struct { SkipL1Charging bool } -type MessageRunMode uint8 +type MessageRunMode struct { + chainTip bool + call bool // TODO: rename or refactor the bool flags + mutating bool + executedOnChain bool + gasEstimation bool // TODO: rename + wasmTargets []ethdb.WasmTarget +} -const ( - MessageCommitMode MessageRunMode = iota - MessageGasEstimationMode - MessageEthcallMode - MessageReplayMode -) +func NewMessageCommitMode(wasmTargets []ethdb.WasmTarget) *MessageRunMode { + return &MessageRunMode{ + chainTip: true, + mutating: true, + executedOnChain: true, + wasmTargets: wasmTargets, + } +} + +func NewMessageReplayMode(wasmTargets []ethdb.WasmTarget) *MessageRunMode { + return &MessageRunMode{ + mutating: true, + executedOnChain: true, + wasmTargets: wasmTargets, + } +} + +func NewMessagePrefetchMode(wasmTargets []ethdb.WasmTarget) *MessageRunMode { + return NewMessageReplayMode(wasmTargets) +} + +func NewMessageEthcallMode() *MessageRunMode { + return &MessageRunMode{ + call: true, + wasmTargets: []ethdb.WasmTarget{rawdb.LocalTarget()}, + } +} + +func NewMessageGasEstimationMode() *MessageRunMode { + return &MessageRunMode{ + gasEstimation: true, + wasmTargets: []ethdb.WasmTarget{rawdb.LocalTarget()}, + } +} + +func (m *MessageRunMode) IsChainTip() bool { + return m.chainTip +} // these message modes are executed onchain so cannot make any gas shortcuts -func (m MessageRunMode) ExecutedOnChain() bool { - return m == MessageCommitMode || m == MessageReplayMode +func (m *MessageRunMode) ExecutedOnChain() bool { + return m.executedOnChain +} + +func (m *MessageRunMode) IsGasEstimation() bool { + return m.gasEstimation +} + +func (m *MessageRunMode) IsMutating() bool { + return m.mutating +} + +func (m *MessageRunMode) IsCall() bool { + return m.call +} + +func (m *MessageRunMode) WasmTargets() []ethdb.WasmTarget { + return m.wasmTargets } // TransactionToMessage converts a transaction into a Message. -func TransactionToMessage(tx *types.Transaction, s types.Signer, baseFee *big.Int, runmode MessageRunMode) (*Message, error) { +func TransactionToMessage(tx *types.Transaction, s types.Signer, baseFee *big.Int, runMode *MessageRunMode) (*Message, error) { msg := &Message{ - TxRunMode: runmode, + TxRunMode: runMode, Tx: tx, diff --git a/eth/gasestimator/gasestimator.go b/eth/gasestimator/gasestimator.go index f6d8358574..85661ebc10 100644 --- a/eth/gasestimator/gasestimator.go +++ b/eth/gasestimator/gasestimator.go @@ -47,7 +47,7 @@ type Options struct { Header *types.Header // Header defining the block context to execute in State *state.StateDB // Pre-state on top of which to estimate the gas Backend core.NodeInterfaceBackendAPI - RunScheduledTxes func(context.Context, core.NodeInterfaceBackendAPI, *state.StateDB, *types.Header, vm.BlockContext, core.MessageRunMode, *core.ExecutionResult) (*core.ExecutionResult, error) + RunScheduledTxes func(context.Context, core.NodeInterfaceBackendAPI, *state.StateDB, *types.Header, vm.BlockContext, *core.MessageRunMode, *core.ExecutionResult) (*core.ExecutionResult, error) ErrorRatio float64 // Allowed overestimation ratio for faster estimation termination } @@ -245,7 +245,7 @@ func run(ctx context.Context, call *core.Message, opts *Options) (*core.Executio } // Arbitrum: a tx can schedule another (see retryables) - result, err = opts.RunScheduledTxes(ctx, opts.Backend, dirtyState, opts.Header, evmContext, core.MessageGasEstimationMode, result) + result, err = opts.RunScheduledTxes(ctx, opts.Backend, dirtyState, opts.Header, evmContext, core.NewMessageGasEstimationMode(), result) if err != nil { return nil, err } diff --git a/eth/state_accessor.go b/eth/state_accessor.go index 5b6b1fcaa0..0f867e9f8f 100644 --- a/eth/state_accessor.go +++ b/eth/state_accessor.go @@ -29,6 +29,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/eth/tracers" + "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/metrics" "github.com/ethereum/go-ethereum/trie" @@ -264,9 +265,10 @@ func (eth *Ethereum) stateAtTransaction(ctx context.Context, block *types.Block, } // Recompute transactions up to the target index. signer := types.MakeSigner(eth.blockchain.Config(), block.Number(), block.Time()) + runMode := core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()}) for idx, tx := range block.Transactions() { // Assemble the transaction call message and return if the requested offset - msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), core.MessageReplayMode) + msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), runMode) txContext := core.NewEVMTxContext(msg) context := core.NewEVMBlockContext(block.Header(), eth.blockchain, nil) if idx == txIndex { diff --git a/eth/tracers/api.go b/eth/tracers/api.go index 94307f3f06..1c930709ca 100644 --- a/eth/tracers/api.go +++ b/eth/tracers/api.go @@ -262,6 +262,9 @@ func (api *API) traceChain(start, end *types.Block, config *TraceConfig, closed resCh = make(chan *blockTraceTask, threads) tracker = newStateTracker(maximumPendingTraceStates, start.NumberU64()) ) + + runMode := core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()}) + for th := 0; th < threads; th++ { pend.Add(1) go func() { @@ -275,7 +278,7 @@ func (api *API) traceChain(start, end *types.Block, config *TraceConfig, closed ) // Trace all the transactions contained within for i, tx := range task.block.Transactions() { - msg, _ := core.TransactionToMessage(tx, signer, task.block.BaseFee(), core.MessageReplayMode) + msg, _ := core.TransactionToMessage(tx, signer, task.block.BaseFee(), runMode) txctx := &Context{ BlockHash: task.block.Hash(), BlockNumber: task.block.Number(), @@ -539,12 +542,13 @@ func (api *API) IntermediateRoots(ctx context.Context, hash common.Hash, config vmenv := vm.NewEVM(vmctx, vm.TxContext{}, statedb, chainConfig, vm.Config{}) core.ProcessBeaconBlockRoot(*beaconRoot, vmenv, statedb) } + runMode := core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()}) for i, tx := range block.Transactions() { if err := ctx.Err(); err != nil { return nil, err } var ( - msg, _ = core.TransactionToMessage(tx, signer, block.BaseFee(), core.MessageReplayMode) + msg, _ = core.TransactionToMessage(tx, signer, block.BaseFee(), runMode) txContext = core.NewEVMTxContext(msg) vmenv = vm.NewEVM(vmctx, txContext, statedb, chainConfig, vm.Config{}) ) @@ -618,9 +622,10 @@ func (api *API) traceBlock(ctx context.Context, block *types.Block, config *Trac vmenv := vm.NewEVM(blockCtx, vm.TxContext{}, statedb, api.backend.ChainConfig(), vm.Config{}) core.ProcessBeaconBlockRoot(*beaconRoot, vmenv, statedb) } + runMode := core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()}) for i, tx := range txs { // Generate the next state snapshot fast without tracing - msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), core.MessageReplayMode) + msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), runMode) txctx := &Context{ BlockHash: blockHash, BlockNumber: block.Number(), @@ -648,6 +653,7 @@ func (api *API) traceBlockParallel(ctx context.Context, block *types.Block, stat results = make([]*txTraceResult, len(txs)) pend sync.WaitGroup ) + runMode := core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()}) threads := runtime.NumCPU() if threads > len(txs) { threads = len(txs) @@ -659,7 +665,7 @@ func (api *API) traceBlockParallel(ctx context.Context, block *types.Block, stat defer pend.Done() // Fetch and execute the next transaction trace tasks for task := range jobs { - msg, _ := core.TransactionToMessage(txs[task.index], signer, block.BaseFee(), core.MessageReplayMode) + msg, _ := core.TransactionToMessage(txs[task.index], signer, block.BaseFee(), runMode) txctx := &Context{ BlockHash: blockHash, BlockNumber: block.Number(), @@ -696,7 +702,7 @@ txloop: } // Generate the next state snapshot fast without tracing - msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), core.MessageReplayMode) + msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), runMode) statedb.SetTxContext(tx.Hash(), i) vmenv := vm.NewEVM(blockCtx, core.NewEVMTxContext(msg), statedb, api.backend.ChainConfig(), vm.Config{}) if _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(msg.GasLimit)); err != nil { @@ -776,10 +782,12 @@ func (api *API) standardTraceBlockToFile(ctx context.Context, block *types.Block vmenv := vm.NewEVM(vmctx, vm.TxContext{}, statedb, chainConfig, vm.Config{}) core.ProcessBeaconBlockRoot(*beaconRoot, vmenv, statedb) } + + runMode := core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()}) for i, tx := range block.Transactions() { // Prepare the transaction for un-traced execution var ( - msg, _ = core.TransactionToMessage(tx, signer, block.BaseFee(), core.MessageReplayMode) + msg, _ = core.TransactionToMessage(tx, signer, block.BaseFee(), runMode) txContext = core.NewEVMTxContext(msg) vmConf vm.Config dump *os.File @@ -873,7 +881,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()), block.BaseFee(), core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()})) if err != nil { return nil, err } @@ -949,7 +957,7 @@ func (api *API) TraceCall(ctx context.Context, args ethapi.TransactionArgs, bloc return nil, err } var ( - msg = args.ToMessage(vmctx.BaseFee, api.backend.RPCGasCap(), block.Header(), statedb, core.MessageEthcallMode) + msg = args.ToMessage(vmctx.BaseFee, api.backend.RPCGasCap(), block.Header(), statedb, core.NewMessageEthcallMode()) tx = args.ToTransaction() traceConfig *TraceConfig ) diff --git a/eth/tracers/api_test.go b/eth/tracers/api_test.go index 4455fe6196..52d13b95d0 100644 --- a/eth/tracers/api_test.go +++ b/eth/tracers/api_test.go @@ -174,8 +174,9 @@ func (b *testBackend) StateAtTransaction(ctx context.Context, block *types.Block } // Recompute transactions up to the target index. signer := types.MakeSigner(b.chainConfig, block.Number(), block.Time()) + runMode := core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()}) for idx, tx := range block.Transactions() { - msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), core.MessageReplayMode) + msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), runMode) txContext := core.NewEVMTxContext(msg) context := core.NewEVMBlockContext(block.Header(), b.chain, nil) if idx == txIndex { diff --git a/eth/tracers/internal/tracetest/calltrace_test.go b/eth/tracers/internal/tracetest/calltrace_test.go index a682cf06af..1e130a1ad6 100644 --- a/eth/tracers/internal/tracetest/calltrace_test.go +++ b/eth/tracers/internal/tracetest/calltrace_test.go @@ -33,6 +33,7 @@ import ( "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/eth/tracers" + "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/tests" @@ -138,7 +139,7 @@ func testCallTracer(tracerName string, dirPath string, t *testing.T) { } state.StateDB.SetLogger(tracer.Hooks) - msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.MessageReplayMode) + msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()})) if err != nil { t.Fatalf("failed to prepare transaction for tracing: %v", err) } @@ -230,7 +231,7 @@ func benchTracer(tracerName string, test *callTracerTest, b *testing.B) { Difficulty: (*big.Int)(test.Context.Difficulty), GasLimit: uint64(test.Context.GasLimit), } - msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.MessageReplayMode) + msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()})) if err != nil { b.Fatalf("failed to prepare transaction for tracing: %v", err) } @@ -387,7 +388,7 @@ func TestInternals(t *testing.T) { GasPrice: tx.GasPrice(), } evm := vm.NewEVM(context, txContext, state.StateDB, config, vm.Config{Tracer: tc.tracer.Hooks}) - msg, err := core.TransactionToMessage(tx, signer, big.NewInt(0), core.MessageReplayMode) + msg, err := core.TransactionToMessage(tx, signer, big.NewInt(0), core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()})) if err != nil { t.Fatalf("test %v: failed to create message: %v", tc.name, err) } diff --git a/eth/tracers/internal/tracetest/flat_calltrace_test.go b/eth/tracers/internal/tracetest/flat_calltrace_test.go index c56eae3e74..b6ea16fa67 100644 --- a/eth/tracers/internal/tracetest/flat_calltrace_test.go +++ b/eth/tracers/internal/tracetest/flat_calltrace_test.go @@ -17,6 +17,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/eth/tracers" + "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/tests" ) @@ -95,7 +96,7 @@ func flatCallTracerTestRunner(tracerName string, filename string, dirPath string } state.StateDB.SetLogger(tracer.Hooks) - msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.MessageReplayMode) + msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()})) if err != nil { return fmt.Errorf("failed to prepare transaction for tracing: %v", err) } diff --git a/eth/tracers/internal/tracetest/prestate_test.go b/eth/tracers/internal/tracetest/prestate_test.go index 101211d620..396558f09d 100644 --- a/eth/tracers/internal/tracetest/prestate_test.go +++ b/eth/tracers/internal/tracetest/prestate_test.go @@ -30,6 +30,7 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/eth/tracers" + "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/tests" ) @@ -104,7 +105,7 @@ func testPrestateDiffTracer(tracerName string, dirPath string, t *testing.T) { } state.StateDB.SetLogger(tracer.Hooks) - msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.MessageReplayMode) + msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()})) if err != nil { t.Fatalf("failed to prepare transaction for tracing: %v", err) } diff --git a/eth/tracers/tracers_test.go b/eth/tracers/tracers_test.go index bdb591340f..f5db043ac6 100644 --- a/eth/tracers/tracers_test.go +++ b/eth/tracers/tracers_test.go @@ -27,6 +27,7 @@ import ( "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/eth/tracers/logger" + "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/tests" ) @@ -90,7 +91,7 @@ func BenchmarkTransactionTrace(b *testing.B) { //EnableReturnData: false, }) evm := vm.NewEVM(context, txContext, state.StateDB, params.AllEthashProtocolChanges, vm.Config{Tracer: tracer.Hooks()}) - msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.MessageReplayMode) + msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()})) if err != nil { b.Fatalf("failed to prepare transaction for tracing: %v", err) } diff --git a/ethdb/database.go b/ethdb/database.go index e846767243..76f3fe6b6f 100644 --- a/ethdb/database.go +++ b/ethdb/database.go @@ -181,7 +181,6 @@ type AncientStore interface { type WasmTarget string type WasmDataBaseRetriever interface { WasmDataBase() (KeyValueStore, uint32) - WasmTargets() []WasmTarget } // Database contains all the methods required by the high level database to not diff --git a/ethdb/remotedb/remotedb.go b/ethdb/remotedb/remotedb.go index 0168aefef8..ef38ce786d 100644 --- a/ethdb/remotedb/remotedb.go +++ b/ethdb/remotedb/remotedb.go @@ -43,10 +43,6 @@ func (t *Database) WasmDataBase() (ethdb.KeyValueStore, uint32) { return t, 0 } -func (t *Database) WasmTargets() []ethdb.WasmTarget { - return nil -} - func (db *Database) Get(key []byte) ([]byte, error) { var resp hexutil.Bytes err := db.remote.Call(&resp, "debug_dbGet", hexutil.Bytes(key)) diff --git a/graphql/graphql.go b/graphql/graphql.go index 466ec46529..04b33afea3 100644 --- a/graphql/graphql.go +++ b/graphql/graphql.go @@ -1198,7 +1198,7 @@ func (c *CallResult) Status() hexutil.Uint64 { func (b *Block) Call(ctx context.Context, args struct { Data ethapi.TransactionArgs }) (*CallResult, error) { - result, err := ethapi.DoCall(ctx, b.r.backend, args.Data, *b.numberOrHash, nil, nil, b.r.backend.RPCEVMTimeout(), b.r.backend.RPCGasCap(), core.MessageEthcallMode) + result, err := ethapi.DoCall(ctx, b.r.backend, args.Data, *b.numberOrHash, nil, nil, b.r.backend.RPCEVMTimeout(), b.r.backend.RPCGasCap(), core.NewMessageEthcallMode()) if err != nil { return nil, err } @@ -1261,7 +1261,7 @@ func (p *Pending) Call(ctx context.Context, args struct { Data ethapi.TransactionArgs }) (*CallResult, error) { pendingBlockNr := rpc.BlockNumberOrHashWithNumber(rpc.PendingBlockNumber) - result, err := ethapi.DoCall(ctx, p.r.backend, args.Data, pendingBlockNr, nil, nil, p.r.backend.RPCEVMTimeout(), p.r.backend.RPCGasCap(), core.MessageEthcallMode) + result, err := ethapi.DoCall(ctx, p.r.backend, args.Data, pendingBlockNr, nil, nil, p.r.backend.RPCEVMTimeout(), p.r.backend.RPCGasCap(), core.NewMessageEthcallMode()) if err != nil { return nil, err } diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go index 5ce1e3d7db..7741991dbe 100644 --- a/internal/ethapi/api.go +++ b/internal/ethapi/api.go @@ -1107,7 +1107,7 @@ func (context *ChainContext) GetHeader(hash common.Hash, number uint64) *types.H return header } -func doCall(ctx context.Context, b Backend, args TransactionArgs, state *state.StateDB, header *types.Header, overrides *StateOverride, blockOverrides *BlockOverrides, timeout time.Duration, globalGasCap uint64, runMode core.MessageRunMode) (*core.ExecutionResult, error) { +func doCall(ctx context.Context, b Backend, args TransactionArgs, state *state.StateDB, header *types.Header, overrides *StateOverride, blockOverrides *BlockOverrides, timeout time.Duration, globalGasCap uint64, runMode *core.MessageRunMode) (*core.ExecutionResult, error) { if err := overrides.Apply(state); err != nil { return nil, err } @@ -1167,7 +1167,7 @@ func doCall(ctx context.Context, b Backend, args TransactionArgs, state *state.S } // Arbitrum: a tx can schedule another (see retryables) - result, err = runScheduledTxes(ctx, b, state, header, blockCtx, core.MessageGasEstimationMode, result) + result, err = runScheduledTxes(ctx, b, state, header, blockCtx, core.NewMessageGasEstimationMode(), result) // TODO: why do we use GasEstimationMode here? if err != nil { return nil, err } @@ -1175,9 +1175,9 @@ func doCall(ctx context.Context, b Backend, args TransactionArgs, state *state.S return result, nil } -func runScheduledTxes(ctx context.Context, b core.NodeInterfaceBackendAPI, state *state.StateDB, header *types.Header, blockCtx vm.BlockContext, runMode core.MessageRunMode, result *core.ExecutionResult) (*core.ExecutionResult, error) { +func runScheduledTxes(ctx context.Context, b core.NodeInterfaceBackendAPI, state *state.StateDB, header *types.Header, blockCtx vm.BlockContext, runMode *core.MessageRunMode, result *core.ExecutionResult) (*core.ExecutionResult, error) { scheduled := result.ScheduledTxes - for runMode == core.MessageGasEstimationMode && len(scheduled) > 0 { + for runMode.IsGasEstimation() && len(scheduled) > 0 { // This will panic if the scheduled tx is signed, but we only schedule unsigned ones msg, err := core.TransactionToMessage(scheduled[0], types.NewArbitrumSigner(nil), header.BaseFee, runMode) if err != nil { @@ -1230,7 +1230,7 @@ func updateHeaderForPendingBlocks(blockNrOrHash rpc.BlockNumberOrHash, header *t return header } -func DoCall(ctx context.Context, b Backend, args TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides *StateOverride, blockOverrides *BlockOverrides, timeout time.Duration, globalGasCap uint64, runMode core.MessageRunMode) (*core.ExecutionResult, error) { +func DoCall(ctx context.Context, b Backend, args TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides *StateOverride, blockOverrides *BlockOverrides, timeout time.Duration, globalGasCap uint64, runMode *core.MessageRunMode) (*core.ExecutionResult, error) { defer func(start time.Time) { log.Debug("Executing EVM call finished", "runtime", time.Since(start)) }(time.Now()) state, header, err := b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash) @@ -1253,7 +1253,7 @@ func (s *BlockChainAPI) Call(ctx context.Context, args TransactionArgs, blockNrO latest := rpc.BlockNumberOrHashWithNumber(rpc.LatestBlockNumber) blockNrOrHash = &latest } - result, err := DoCall(ctx, s.b, args, *blockNrOrHash, overrides, blockOverrides, s.b.RPCEVMTimeout(), s.b.RPCGasCap(), core.MessageEthcallMode) + result, err := DoCall(ctx, s.b, args, *blockNrOrHash, overrides, blockOverrides, s.b.RPCEVMTimeout(), s.b.RPCGasCap(), core.NewMessageEthcallMode()) if err != nil { if client := fallbackClientFor(s.b, err); client != nil { var res hexutil.Bytes @@ -1300,7 +1300,7 @@ func DoEstimateGas(ctx context.Context, b Backend, args TransactionArgs, blockNr } // Run the gas estimation andwrap any revertals into a custom return // Arbitrum: this also appropriately recursively calls another args.ToMessage with increased gasCap by posterCostInL2Gas amount - call := args.ToMessage(header.BaseFee, gasCap, header, state, core.MessageGasEstimationMode) + call := args.ToMessage(header.BaseFee, gasCap, header, state, core.NewMessageGasEstimationMode()) // Arbitrum: raise the gas cap to ignore L1 costs so that it's compute-only { @@ -1742,6 +1742,7 @@ func AccessList(ctx context.Context, b Backend, blockNrOrHash rpc.BlockNumberOrH if args.AccessList != nil { prevTracer = logger.NewAccessListTracer(*args.AccessList, args.from(), to, precompiles) } + runMode := core.NewMessageEthcallMode() for { // Retrieve the current access list to expand accessList := prevTracer.AccessList() @@ -1751,7 +1752,7 @@ func AccessList(ctx context.Context, b Backend, blockNrOrHash rpc.BlockNumberOrH statedb := db.Copy() // Set the accesslist to the last al args.AccessList = &accessList - msg := args.ToMessage(header.BaseFee, b.RPCGasCap(), header, statedb, core.MessageEthcallMode) + msg := args.ToMessage(header.BaseFee, b.RPCGasCap(), header, statedb, runMode) // Apply the transaction with the access list tracer tracer := logger.NewAccessListTracer(accessList, args.from(), to, precompiles) diff --git a/internal/ethapi/transaction_args.go b/internal/ethapi/transaction_args.go index 197584a74e..91c219f760 100644 --- a/internal/ethapi/transaction_args.go +++ b/internal/ethapi/transaction_args.go @@ -436,7 +436,7 @@ func (args *TransactionArgs) CallDefaults(globalGasCap uint64, baseFee *big.Int, } // Assumes that fields are not nil, i.e. setDefaults or CallDefaults has been called. -func (args *TransactionArgs) ToMessage(baseFee *big.Int, globalGasCap uint64, header *types.Header, state *state.StateDB, runMode core.MessageRunMode) *core.Message { +func (args *TransactionArgs) ToMessage(baseFee *big.Int, globalGasCap uint64, header *types.Header, state *state.StateDB, runMode *core.MessageRunMode) *core.Message { var ( gasPrice *big.Int gasFeeCap *big.Int From a2455c59682a9f16ae66c040d0cfce92ae760514 Mon Sep 17 00:00:00 2001 From: Maciej Kulawik Date: Fri, 8 Nov 2024 17:38:09 +0100 Subject: [PATCH 02/12] use NewMessageCommitMode in t8ntool execution --- cmd/evm/internal/t8ntool/execution.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/evm/internal/t8ntool/execution.go b/cmd/evm/internal/t8ntool/execution.go index 77f0da49ae..1c76f669aa 100644 --- a/cmd/evm/internal/t8ntool/execution.go +++ b/cmd/evm/internal/t8ntool/execution.go @@ -213,7 +213,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.NewMessageCommitMode(nil)) // TODO: do we need to specify wasm targets here if chainConfig.IsArbitrum == false? if err != nil { log.Warn("rejected tx", "index", i, "hash", tx.Hash(), "error", err) rejectedTxs = append(rejectedTxs, &rejectedTx{i, err.Error()}) From 06eae43fc68a1dcc82644b863ab2482dac734a8f Mon Sep 17 00:00:00 2001 From: Maciej Kulawik Date: Fri, 8 Nov 2024 20:12:11 +0100 Subject: [PATCH 03/12] rename MessageRunMode -> MessageRunContext --- core/state_prefetcher.go | 4 +-- core/state_processor.go | 10 +++---- core/state_transition.go | 42 ++++++++++++++--------------- eth/gasestimator/gasestimator.go | 4 +-- eth/state_accessor.go | 4 +-- eth/tracers/api.go | 26 +++++++++--------- eth/tracers/api_test.go | 4 +-- graphql/graphql.go | 4 +-- internal/ethapi/api.go | 24 ++++++++--------- internal/ethapi/transaction_args.go | 4 +-- 10 files changed, 63 insertions(+), 63 deletions(-) diff --git a/core/state_prefetcher.go b/core/state_prefetcher.go index cd5ae60bba..8ea16e77d0 100644 --- a/core/state_prefetcher.go +++ b/core/state_prefetcher.go @@ -57,14 +57,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()) - runMode := NewMessageEthcallMode() + 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, runMode) + msg, err := TransactionToMessage(tx, signer, header.BaseFee, runCtx) if err != nil { return // Also invalid block, bail out } diff --git a/core/state_processor.go b/core/state_processor.go index 0d0c25bd70..55b8e81feb 100644 --- a/core/state_processor.go +++ b/core/state_processor.go @@ -81,10 +81,10 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg if beaconRoot := block.BeaconRoot(); beaconRoot != nil { ProcessBeaconBlockRoot(*beaconRoot, vmenv, statedb) } - runMode := NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()}) + runCtx := NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()}) // Iterate over and process the individual transactions for i, tx := range block.Transactions() { - msg, err := TransactionToMessage(tx, signer, header.BaseFee, runMode) + msg, err := TransactionToMessage(tx, signer, header.BaseFee, runCtx) if err != nil { return nil, nil, 0, fmt.Errorf("could not apply tx %d [%v]: %w", i, tx.Hash().Hex(), err) } @@ -182,11 +182,11 @@ func ApplyTransactionWithEVM(msg *Message, config *params.ChainConfig, gp *GasPo // for the transaction, gas used and an error if the transaction failed, // indicating the block was invalid. func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config) (*types.Receipt, *ExecutionResult, error) { - return ApplyTransactionWithResultFilter(config, bc, author, gp, statedb, header, tx, usedGas, cfg, NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()}), nil) + return ApplyTransactionWithResultFilter(config, bc, author, gp, statedb, header, tx, usedGas, cfg, NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()}), nil) } -func ApplyTransactionWithResultFilter(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config, runMode *MessageRunMode, resultFilter func(*ExecutionResult) error) (*types.Receipt, *ExecutionResult, error) { - msg, err := TransactionToMessage(tx, types.MakeSigner(config, header.Number, header.Time), header.BaseFee, runMode) +func ApplyTransactionWithResultFilter(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config, runCtx *MessageRunContext, resultFilter func(*ExecutionResult) error) (*types.Receipt, *ExecutionResult, error) { + msg, err := TransactionToMessage(tx, types.MakeSigner(config, header.Number, header.Time), header.BaseFee, runCtx) if err != nil { return nil, nil, err } diff --git a/core/state_transition.go b/core/state_transition.go index cc2877f752..effebc7c3b 100644 --- a/core/state_transition.go +++ b/core/state_transition.go @@ -137,8 +137,8 @@ func toWordSize(size uint64) uint64 { // processing. type Message struct { // Arbitrum-specific - TxRunMode *MessageRunMode - Tx *types.Transaction + TxRunContext *MessageRunContext + Tx *types.Transaction To *common.Address From common.Address @@ -162,7 +162,7 @@ type Message struct { SkipL1Charging bool } -type MessageRunMode struct { +type MessageRunContext struct { chainTip bool call bool // TODO: rename or refactor the bool flags mutating bool @@ -171,8 +171,8 @@ type MessageRunMode struct { wasmTargets []ethdb.WasmTarget } -func NewMessageCommitMode(wasmTargets []ethdb.WasmTarget) *MessageRunMode { - return &MessageRunMode{ +func NewMessageCommitContext(wasmTargets []ethdb.WasmTarget) *MessageRunContext { + return &MessageRunContext{ chainTip: true, mutating: true, executedOnChain: true, @@ -180,61 +180,61 @@ func NewMessageCommitMode(wasmTargets []ethdb.WasmTarget) *MessageRunMode { } } -func NewMessageReplayMode(wasmTargets []ethdb.WasmTarget) *MessageRunMode { - return &MessageRunMode{ +func NewMessageReplayContext(wasmTargets []ethdb.WasmTarget) *MessageRunContext { + return &MessageRunContext{ mutating: true, executedOnChain: true, wasmTargets: wasmTargets, } } -func NewMessagePrefetchMode(wasmTargets []ethdb.WasmTarget) *MessageRunMode { - return NewMessageReplayMode(wasmTargets) +func NewMessagePrefetchContext(wasmTargets []ethdb.WasmTarget) *MessageRunContext { + return NewMessageReplayContext(wasmTargets) } -func NewMessageEthcallMode() *MessageRunMode { - return &MessageRunMode{ +func NewMessageEthcallContext() *MessageRunContext { + return &MessageRunContext{ call: true, wasmTargets: []ethdb.WasmTarget{rawdb.LocalTarget()}, } } -func NewMessageGasEstimationMode() *MessageRunMode { - return &MessageRunMode{ +func NewMessageGasEstimationContext() *MessageRunContext { + return &MessageRunContext{ gasEstimation: true, wasmTargets: []ethdb.WasmTarget{rawdb.LocalTarget()}, } } -func (m *MessageRunMode) IsChainTip() bool { +func (m *MessageRunContext) IsChainTip() bool { return m.chainTip } // these message modes are executed onchain so cannot make any gas shortcuts -func (m *MessageRunMode) ExecutedOnChain() bool { +func (m *MessageRunContext) ExecutedOnChain() bool { return m.executedOnChain } -func (m *MessageRunMode) IsGasEstimation() bool { +func (m *MessageRunContext) IsGasEstimation() bool { return m.gasEstimation } -func (m *MessageRunMode) IsMutating() bool { +func (m *MessageRunContext) IsMutating() bool { return m.mutating } -func (m *MessageRunMode) IsCall() bool { +func (m *MessageRunContext) IsCall() bool { return m.call } -func (m *MessageRunMode) WasmTargets() []ethdb.WasmTarget { +func (m *MessageRunContext) WasmTargets() []ethdb.WasmTarget { return m.wasmTargets } // TransactionToMessage converts a transaction into a Message. -func TransactionToMessage(tx *types.Transaction, s types.Signer, baseFee *big.Int, runMode *MessageRunMode) (*Message, error) { +func TransactionToMessage(tx *types.Transaction, s types.Signer, baseFee *big.Int, runCtx *MessageRunContext) (*Message, error) { msg := &Message{ - TxRunMode: runMode, + TxRunContext: runCtx, Tx: tx, diff --git a/eth/gasestimator/gasestimator.go b/eth/gasestimator/gasestimator.go index 85661ebc10..2832668183 100644 --- a/eth/gasestimator/gasestimator.go +++ b/eth/gasestimator/gasestimator.go @@ -47,7 +47,7 @@ type Options struct { Header *types.Header // Header defining the block context to execute in State *state.StateDB // Pre-state on top of which to estimate the gas Backend core.NodeInterfaceBackendAPI - RunScheduledTxes func(context.Context, core.NodeInterfaceBackendAPI, *state.StateDB, *types.Header, vm.BlockContext, *core.MessageRunMode, *core.ExecutionResult) (*core.ExecutionResult, error) + RunScheduledTxes func(context.Context, core.NodeInterfaceBackendAPI, *state.StateDB, *types.Header, vm.BlockContext, *core.MessageRunContext, *core.ExecutionResult) (*core.ExecutionResult, error) ErrorRatio float64 // Allowed overestimation ratio for faster estimation termination } @@ -245,7 +245,7 @@ func run(ctx context.Context, call *core.Message, opts *Options) (*core.Executio } // Arbitrum: a tx can schedule another (see retryables) - result, err = opts.RunScheduledTxes(ctx, opts.Backend, dirtyState, opts.Header, evmContext, core.NewMessageGasEstimationMode(), result) + result, err = opts.RunScheduledTxes(ctx, opts.Backend, dirtyState, opts.Header, evmContext, core.NewMessageGasEstimationContext(), result) if err != nil { return nil, err } diff --git a/eth/state_accessor.go b/eth/state_accessor.go index 0f867e9f8f..12506ab2e0 100644 --- a/eth/state_accessor.go +++ b/eth/state_accessor.go @@ -265,10 +265,10 @@ func (eth *Ethereum) stateAtTransaction(ctx context.Context, block *types.Block, } // Recompute transactions up to the target index. signer := types.MakeSigner(eth.blockchain.Config(), block.Number(), block.Time()) - runMode := core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()}) + runCtx := core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()}) for idx, tx := range block.Transactions() { // Assemble the transaction call message and return if the requested offset - msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), runMode) + msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), runCtx) txContext := core.NewEVMTxContext(msg) context := core.NewEVMBlockContext(block.Header(), eth.blockchain, nil) if idx == txIndex { diff --git a/eth/tracers/api.go b/eth/tracers/api.go index 1c930709ca..1714232dd3 100644 --- a/eth/tracers/api.go +++ b/eth/tracers/api.go @@ -263,7 +263,7 @@ func (api *API) traceChain(start, end *types.Block, config *TraceConfig, closed tracker = newStateTracker(maximumPendingTraceStates, start.NumberU64()) ) - runMode := core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()}) + runCtx := core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()}) for th := 0; th < threads; th++ { pend.Add(1) @@ -278,7 +278,7 @@ func (api *API) traceChain(start, end *types.Block, config *TraceConfig, closed ) // Trace all the transactions contained within for i, tx := range task.block.Transactions() { - msg, _ := core.TransactionToMessage(tx, signer, task.block.BaseFee(), runMode) + msg, _ := core.TransactionToMessage(tx, signer, task.block.BaseFee(), runCtx) txctx := &Context{ BlockHash: task.block.Hash(), BlockNumber: task.block.Number(), @@ -542,13 +542,13 @@ func (api *API) IntermediateRoots(ctx context.Context, hash common.Hash, config vmenv := vm.NewEVM(vmctx, vm.TxContext{}, statedb, chainConfig, vm.Config{}) core.ProcessBeaconBlockRoot(*beaconRoot, vmenv, statedb) } - runMode := core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()}) + runCtx := core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()}) for i, tx := range block.Transactions() { if err := ctx.Err(); err != nil { return nil, err } var ( - msg, _ = core.TransactionToMessage(tx, signer, block.BaseFee(), runMode) + msg, _ = core.TransactionToMessage(tx, signer, block.BaseFee(), runCtx) txContext = core.NewEVMTxContext(msg) vmenv = vm.NewEVM(vmctx, txContext, statedb, chainConfig, vm.Config{}) ) @@ -622,10 +622,10 @@ func (api *API) traceBlock(ctx context.Context, block *types.Block, config *Trac vmenv := vm.NewEVM(blockCtx, vm.TxContext{}, statedb, api.backend.ChainConfig(), vm.Config{}) core.ProcessBeaconBlockRoot(*beaconRoot, vmenv, statedb) } - runMode := core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()}) + runCtx := core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()}) for i, tx := range txs { // Generate the next state snapshot fast without tracing - msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), runMode) + msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), runCtx) txctx := &Context{ BlockHash: blockHash, BlockNumber: block.Number(), @@ -653,7 +653,7 @@ func (api *API) traceBlockParallel(ctx context.Context, block *types.Block, stat results = make([]*txTraceResult, len(txs)) pend sync.WaitGroup ) - runMode := core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()}) + runCtx := core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()}) threads := runtime.NumCPU() if threads > len(txs) { threads = len(txs) @@ -665,7 +665,7 @@ func (api *API) traceBlockParallel(ctx context.Context, block *types.Block, stat defer pend.Done() // Fetch and execute the next transaction trace tasks for task := range jobs { - msg, _ := core.TransactionToMessage(txs[task.index], signer, block.BaseFee(), runMode) + msg, _ := core.TransactionToMessage(txs[task.index], signer, block.BaseFee(), runCtx) txctx := &Context{ BlockHash: blockHash, BlockNumber: block.Number(), @@ -702,7 +702,7 @@ txloop: } // Generate the next state snapshot fast without tracing - msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), runMode) + msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), runCtx) statedb.SetTxContext(tx.Hash(), i) vmenv := vm.NewEVM(blockCtx, core.NewEVMTxContext(msg), statedb, api.backend.ChainConfig(), vm.Config{}) if _, err := core.ApplyMessage(vmenv, msg, new(core.GasPool).AddGas(msg.GasLimit)); err != nil { @@ -783,11 +783,11 @@ func (api *API) standardTraceBlockToFile(ctx context.Context, block *types.Block core.ProcessBeaconBlockRoot(*beaconRoot, vmenv, statedb) } - runMode := core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()}) + runCtx := core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()}) for i, tx := range block.Transactions() { // Prepare the transaction for un-traced execution var ( - msg, _ = core.TransactionToMessage(tx, signer, block.BaseFee(), runMode) + msg, _ = core.TransactionToMessage(tx, signer, block.BaseFee(), runCtx) txContext = core.NewEVMTxContext(msg) vmConf vm.Config dump *os.File @@ -881,7 +881,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.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()})) + msg, err := core.TransactionToMessage(tx, types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time()), block.BaseFee(), core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()})) if err != nil { return nil, err } @@ -957,7 +957,7 @@ func (api *API) TraceCall(ctx context.Context, args ethapi.TransactionArgs, bloc return nil, err } var ( - msg = args.ToMessage(vmctx.BaseFee, api.backend.RPCGasCap(), block.Header(), statedb, core.NewMessageEthcallMode()) + msg = args.ToMessage(vmctx.BaseFee, api.backend.RPCGasCap(), block.Header(), statedb, core.NewMessageEthcallContext()) tx = args.ToTransaction() traceConfig *TraceConfig ) diff --git a/eth/tracers/api_test.go b/eth/tracers/api_test.go index 52d13b95d0..5fdeb9fda4 100644 --- a/eth/tracers/api_test.go +++ b/eth/tracers/api_test.go @@ -174,9 +174,9 @@ func (b *testBackend) StateAtTransaction(ctx context.Context, block *types.Block } // Recompute transactions up to the target index. signer := types.MakeSigner(b.chainConfig, block.Number(), block.Time()) - runMode := core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()}) + runCtx := core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()}) for idx, tx := range block.Transactions() { - msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), runMode) + msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), runCtx) txContext := core.NewEVMTxContext(msg) context := core.NewEVMBlockContext(block.Header(), b.chain, nil) if idx == txIndex { diff --git a/graphql/graphql.go b/graphql/graphql.go index 04b33afea3..ee2b8f79d4 100644 --- a/graphql/graphql.go +++ b/graphql/graphql.go @@ -1198,7 +1198,7 @@ func (c *CallResult) Status() hexutil.Uint64 { func (b *Block) Call(ctx context.Context, args struct { Data ethapi.TransactionArgs }) (*CallResult, error) { - result, err := ethapi.DoCall(ctx, b.r.backend, args.Data, *b.numberOrHash, nil, nil, b.r.backend.RPCEVMTimeout(), b.r.backend.RPCGasCap(), core.NewMessageEthcallMode()) + result, err := ethapi.DoCall(ctx, b.r.backend, args.Data, *b.numberOrHash, nil, nil, b.r.backend.RPCEVMTimeout(), b.r.backend.RPCGasCap(), core.NewMessageEthcallContext()) if err != nil { return nil, err } @@ -1261,7 +1261,7 @@ func (p *Pending) Call(ctx context.Context, args struct { Data ethapi.TransactionArgs }) (*CallResult, error) { pendingBlockNr := rpc.BlockNumberOrHashWithNumber(rpc.PendingBlockNumber) - result, err := ethapi.DoCall(ctx, p.r.backend, args.Data, pendingBlockNr, nil, nil, p.r.backend.RPCEVMTimeout(), p.r.backend.RPCGasCap(), core.NewMessageEthcallMode()) + result, err := ethapi.DoCall(ctx, p.r.backend, args.Data, pendingBlockNr, nil, nil, p.r.backend.RPCEVMTimeout(), p.r.backend.RPCGasCap(), core.NewMessageEthcallContext()) if err != nil { return nil, err } diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go index 7741991dbe..8136382680 100644 --- a/internal/ethapi/api.go +++ b/internal/ethapi/api.go @@ -1107,7 +1107,7 @@ func (context *ChainContext) GetHeader(hash common.Hash, number uint64) *types.H return header } -func doCall(ctx context.Context, b Backend, args TransactionArgs, state *state.StateDB, header *types.Header, overrides *StateOverride, blockOverrides *BlockOverrides, timeout time.Duration, globalGasCap uint64, runMode *core.MessageRunMode) (*core.ExecutionResult, error) { +func doCall(ctx context.Context, b Backend, args TransactionArgs, state *state.StateDB, header *types.Header, overrides *StateOverride, blockOverrides *BlockOverrides, timeout time.Duration, globalGasCap uint64, runCtx *core.MessageRunContext) (*core.ExecutionResult, error) { if err := overrides.Apply(state); err != nil { return nil, err } @@ -1133,7 +1133,7 @@ func doCall(ctx context.Context, b Backend, args TransactionArgs, state *state.S if err = args.CallDefaults(globalGasCap, blockCtx.BaseFee, b.ChainConfig().ChainID); err != nil { return nil, err } - msg := args.ToMessage(blockCtx.BaseFee, globalGasCap, header, state, runMode) + msg := args.ToMessage(blockCtx.BaseFee, globalGasCap, header, state, runCtx) // Arbitrum: support NodeInterface.sol by swapping out the message if needed var res *core.ExecutionResult @@ -1167,7 +1167,7 @@ func doCall(ctx context.Context, b Backend, args TransactionArgs, state *state.S } // Arbitrum: a tx can schedule another (see retryables) - result, err = runScheduledTxes(ctx, b, state, header, blockCtx, core.NewMessageGasEstimationMode(), result) // TODO: why do we use GasEstimationMode here? + result, err = runScheduledTxes(ctx, b, state, header, blockCtx, core.NewMessageGasEstimationContext(), result) // TODO: why do we use GasEstimationMode here? if err != nil { return nil, err } @@ -1175,11 +1175,11 @@ func doCall(ctx context.Context, b Backend, args TransactionArgs, state *state.S return result, nil } -func runScheduledTxes(ctx context.Context, b core.NodeInterfaceBackendAPI, state *state.StateDB, header *types.Header, blockCtx vm.BlockContext, runMode *core.MessageRunMode, result *core.ExecutionResult) (*core.ExecutionResult, error) { +func runScheduledTxes(ctx context.Context, b core.NodeInterfaceBackendAPI, state *state.StateDB, header *types.Header, blockCtx vm.BlockContext, runCtx *core.MessageRunContext, result *core.ExecutionResult) (*core.ExecutionResult, error) { scheduled := result.ScheduledTxes - for runMode.IsGasEstimation() && len(scheduled) > 0 { + for runCtx.IsGasEstimation() && len(scheduled) > 0 { // This will panic if the scheduled tx is signed, but we only schedule unsigned ones - msg, err := core.TransactionToMessage(scheduled[0], types.NewArbitrumSigner(nil), header.BaseFee, runMode) + msg, err := core.TransactionToMessage(scheduled[0], types.NewArbitrumSigner(nil), header.BaseFee, runCtx) if err != nil { return nil, err } @@ -1230,7 +1230,7 @@ func updateHeaderForPendingBlocks(blockNrOrHash rpc.BlockNumberOrHash, header *t return header } -func DoCall(ctx context.Context, b Backend, args TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides *StateOverride, blockOverrides *BlockOverrides, timeout time.Duration, globalGasCap uint64, runMode *core.MessageRunMode) (*core.ExecutionResult, error) { +func DoCall(ctx context.Context, b Backend, args TransactionArgs, blockNrOrHash rpc.BlockNumberOrHash, overrides *StateOverride, blockOverrides *BlockOverrides, timeout time.Duration, globalGasCap uint64, runCtx *core.MessageRunContext) (*core.ExecutionResult, error) { defer func(start time.Time) { log.Debug("Executing EVM call finished", "runtime", time.Since(start)) }(time.Now()) state, header, err := b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash) @@ -1239,7 +1239,7 @@ func DoCall(ctx context.Context, b Backend, args TransactionArgs, blockNrOrHash } header = updateHeaderForPendingBlocks(blockNrOrHash, header) - return doCall(ctx, b, args, state, header, overrides, blockOverrides, timeout, globalGasCap, runMode) + return doCall(ctx, b, args, state, header, overrides, blockOverrides, timeout, globalGasCap, runCtx) } // Call executes the given transaction on the state for the given block number. @@ -1253,7 +1253,7 @@ func (s *BlockChainAPI) Call(ctx context.Context, args TransactionArgs, blockNrO latest := rpc.BlockNumberOrHashWithNumber(rpc.LatestBlockNumber) blockNrOrHash = &latest } - result, err := DoCall(ctx, s.b, args, *blockNrOrHash, overrides, blockOverrides, s.b.RPCEVMTimeout(), s.b.RPCGasCap(), core.NewMessageEthcallMode()) + result, err := DoCall(ctx, s.b, args, *blockNrOrHash, overrides, blockOverrides, s.b.RPCEVMTimeout(), s.b.RPCGasCap(), core.NewMessageEthcallContext()) if err != nil { if client := fallbackClientFor(s.b, err); client != nil { var res hexutil.Bytes @@ -1300,7 +1300,7 @@ func DoEstimateGas(ctx context.Context, b Backend, args TransactionArgs, blockNr } // Run the gas estimation andwrap any revertals into a custom return // Arbitrum: this also appropriately recursively calls another args.ToMessage with increased gasCap by posterCostInL2Gas amount - call := args.ToMessage(header.BaseFee, gasCap, header, state, core.NewMessageGasEstimationMode()) + call := args.ToMessage(header.BaseFee, gasCap, header, state, core.NewMessageGasEstimationContext()) // Arbitrum: raise the gas cap to ignore L1 costs so that it's compute-only { @@ -1742,7 +1742,7 @@ func AccessList(ctx context.Context, b Backend, blockNrOrHash rpc.BlockNumberOrH if args.AccessList != nil { prevTracer = logger.NewAccessListTracer(*args.AccessList, args.from(), to, precompiles) } - runMode := core.NewMessageEthcallMode() + runCtx := core.NewMessageEthcallContext() for { // Retrieve the current access list to expand accessList := prevTracer.AccessList() @@ -1752,7 +1752,7 @@ func AccessList(ctx context.Context, b Backend, blockNrOrHash rpc.BlockNumberOrH statedb := db.Copy() // Set the accesslist to the last al args.AccessList = &accessList - msg := args.ToMessage(header.BaseFee, b.RPCGasCap(), header, statedb, runMode) + msg := args.ToMessage(header.BaseFee, b.RPCGasCap(), header, statedb, runCtx) // Apply the transaction with the access list tracer tracer := logger.NewAccessListTracer(accessList, args.from(), to, precompiles) diff --git a/internal/ethapi/transaction_args.go b/internal/ethapi/transaction_args.go index 91c219f760..b00634a20e 100644 --- a/internal/ethapi/transaction_args.go +++ b/internal/ethapi/transaction_args.go @@ -436,7 +436,7 @@ func (args *TransactionArgs) CallDefaults(globalGasCap uint64, baseFee *big.Int, } // Assumes that fields are not nil, i.e. setDefaults or CallDefaults has been called. -func (args *TransactionArgs) ToMessage(baseFee *big.Int, globalGasCap uint64, header *types.Header, state *state.StateDB, runMode *core.MessageRunMode) *core.Message { +func (args *TransactionArgs) ToMessage(baseFee *big.Int, globalGasCap uint64, header *types.Header, state *state.StateDB, runCtx *core.MessageRunContext) *core.Message { var ( gasPrice *big.Int gasFeeCap *big.Int @@ -485,7 +485,7 @@ func (args *TransactionArgs) ToMessage(baseFee *big.Int, globalGasCap uint64, he BlobGasFeeCap: (*big.Int)(args.BlobFeeCap), BlobHashes: args.BlobHashes, SkipAccountChecks: true, - TxRunMode: runMode, + TxRunContext: runCtx, SkipL1Charging: skipL1Charging, } // Arbitrum: raise the gas cap to ignore L1 costs so that it's compute-only From 7fb544de8fc9d2e1a9e0f697af5b96aa4e30b61f Mon Sep 17 00:00:00 2001 From: Maciej Kulawik Date: Wed, 13 Nov 2024 16:00:56 +0100 Subject: [PATCH 04/12] include WasmCacheTag/arobos_tag in MessageRunContext --- arbitrum/apibackend.go | 11 +---------- arbitrum/recordingdb.go | 2 +- core/rawdb/database.go | 19 +++++++++---------- core/rawdb/table.go | 2 +- core/state/database.go | 24 ++++++------------------ core/state_transition.go | 8 +++++++- ethdb/database.go | 4 ++-- ethdb/remotedb/remotedb.go | 4 ++-- 8 files changed, 29 insertions(+), 45 deletions(-) diff --git a/arbitrum/apibackend.go b/arbitrum/apibackend.go index 3d278fcd0e..e46c3eff88 100644 --- a/arbitrum/apibackend.go +++ b/arbitrum/apibackend.go @@ -45,8 +45,6 @@ var ( type APIBackend struct { b *Backend - dbForAPICalls ethdb.Database - fallbackClient types.FallbackClient sync SyncProgressBackend } @@ -103,15 +101,8 @@ 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 { - dbForAPICalls = rawdb.WrapDatabaseWithWasm(backend.chainDb, wasmStore, 0) - } backend.apiBackend = &APIBackend{ b: backend, - dbForAPICalls: dbForAPICalls, fallbackClient: fallbackClient, } filterSystem := filters.NewFilterSystem(backend.apiBackend, filterConfig) @@ -331,7 +322,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 { diff --git a/arbitrum/recordingdb.go b/arbitrum/recordingdb.go index 0f1a48361a..a896710b9c 100644 --- a/arbitrum/recordingdb.go +++ b/arbitrum/recordingdb.go @@ -258,7 +258,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(rawdb.WrapDatabaseWithWasm(rawdb.NewDatabase(recordingKeyValue), r.db.WasmStore(), 0)) + recordingStateDatabase := state.NewDatabase(rawdb.WrapDatabaseWithWasm(rawdb.NewDatabase(recordingKeyValue), r.db.WasmStore())) var prevRoot common.Hash if lastBlockHeader != nil { prevRoot = lastBlockHeader.Root diff --git a/core/rawdb/database.go b/core/rawdb/database.go index f2e71c6d6d..74ad1d0870 100644 --- a/core/rawdb/database.go +++ b/core/rawdb/database.go @@ -41,8 +41,8 @@ type freezerdb struct { ethdb.AncientStore } -func (frdb *freezerdb) WasmDataBase() (ethdb.KeyValueStore, uint32) { - return frdb, 0 +func (frdb *freezerdb) WasmDataBase() ethdb.KeyValueStore { + return frdb } func (frdb *freezerdb) WasmTargets() []ethdb.WasmTarget { @@ -166,8 +166,8 @@ 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 { @@ -182,12 +182,11 @@ func NewDatabase(db ethdb.KeyValueStore) ethdb.Database { type dbWithWasmEntry struct { ethdb.Database - wasmDb ethdb.KeyValueStore - wasmCacheTag uint32 + wasmDb ethdb.KeyValueStore } -func (db *dbWithWasmEntry) WasmDataBase() (ethdb.KeyValueStore, uint32) { - return db.wasmDb, db.wasmCacheTag +func (db *dbWithWasmEntry) WasmDataBase() ethdb.KeyValueStore { + return db.wasmDb } func (db *dbWithWasmEntry) Close() error { @@ -199,8 +198,8 @@ func (db *dbWithWasmEntry) Close() error { return wasmErr } -func WrapDatabaseWithWasm(db ethdb.Database, wasm ethdb.KeyValueStore, cacheTag uint32) ethdb.Database { - return &dbWithWasmEntry{db, wasm, cacheTag} +func WrapDatabaseWithWasm(db ethdb.Database, wasm ethdb.KeyValueStore) ethdb.Database { + return &dbWithWasmEntry{db, wasm} } // resolveChainFreezerDir is a helper function which resolves the absolute path diff --git a/core/rawdb/table.go b/core/rawdb/table.go index 5f09b48203..1c7b572899 100644 --- a/core/rawdb/table.go +++ b/core/rawdb/table.go @@ -40,7 +40,7 @@ func (t *table) Close() error { return nil } -func (t *table) WasmDataBase() (ethdb.KeyValueStore, uint32) { +func (t *table) WasmDataBase() ethdb.KeyValueStore { return t.db.WasmDataBase() } diff --git a/core/state/database.go b/core/state/database.go index f0bf0f08d4..198213e0fd 100644 --- a/core/state/database.go +++ b/core/state/database.go @@ -55,7 +55,6 @@ type Database interface { // Arbitrum: Read activated Stylus contracts ActivatedAsm(target ethdb.WasmTarget, moduleHash common.Hash) (asm []byte, err error) WasmStore() ethdb.KeyValueStore - WasmCacheTag() uint32 // OpenTrie opens the main account trie. OpenTrie(root common.Hash) (Trie, error) @@ -160,15 +159,12 @@ func NewDatabase(db ethdb.Database) Database { // is safe for concurrent use and retains a lot of collapsed RLP trie nodes in a // large memory cache. func NewDatabaseWithConfig(db ethdb.Database, config *triedb.Config) Database { - wasmdb, wasmTag := db.WasmDataBase() cdb := &cachingDB{ // Arbitrum only - activatedAsmCache: lru.NewSizeConstrainedCache[activatedAsmCacheKey, []byte](activatedWasmCacheSize), - wasmTag: wasmTag, - wasmDatabaseRetriever: db, + activatedAsmCache: lru.NewSizeConstrainedCache[activatedAsmCacheKey, []byte](activatedWasmCacheSize), disk: db, - wasmdb: wasmdb, + wasmdb: db.WasmDataBase(), codeSizeCache: lru.NewCache[common.Hash, int](codeSizeCacheSize), codeCache: lru.NewSizeConstrainedCache[common.Hash, []byte](codeCacheSize), triedb: triedb.NewDatabase(db, config), @@ -178,15 +174,12 @@ func NewDatabaseWithConfig(db ethdb.Database, config *triedb.Config) Database { // NewDatabaseWithNodeDB creates a state database with an already initialized node database. func NewDatabaseWithNodeDB(db ethdb.Database, triedb *triedb.Database) Database { - wasmdb, wasmTag := db.WasmDataBase() cdb := &cachingDB{ // Arbitrum only - activatedAsmCache: lru.NewSizeConstrainedCache[activatedAsmCacheKey, []byte](activatedWasmCacheSize), - wasmTag: wasmTag, - wasmDatabaseRetriever: db, + activatedAsmCache: lru.NewSizeConstrainedCache[activatedAsmCacheKey, []byte](activatedWasmCacheSize), disk: db, - wasmdb: wasmdb, + wasmdb: db.WasmDataBase(), codeSizeCache: lru.NewCache[common.Hash, int](codeSizeCacheSize), codeCache: lru.NewSizeConstrainedCache[common.Hash, []byte](codeCacheSize), triedb: triedb, @@ -201,9 +194,8 @@ type activatedAsmCacheKey struct { type cachingDB struct { // Arbitrum - activatedAsmCache *lru.SizeConstrainedCache[activatedAsmCacheKey, []byte] - wasmTag uint32 - wasmDatabaseRetriever ethdb.WasmDataBaseRetriever + activatedAsmCache *lru.SizeConstrainedCache[activatedAsmCacheKey, []byte] + wasmTag uint32 disk ethdb.KeyValueStore wasmdb ethdb.KeyValueStore @@ -216,10 +208,6 @@ func (db *cachingDB) WasmStore() ethdb.KeyValueStore { return db.wasmdb } -func (db *cachingDB) WasmCacheTag() uint32 { - return db.wasmTag -} - // OpenTrie opens the main account trie at a specific root hash. func (db *cachingDB) OpenTrie(root common.Hash) (Trie, error) { if db.triedb.IsVerkle() { diff --git a/core/state_transition.go b/core/state_transition.go index effebc7c3b..7508908f17 100644 --- a/core/state_transition.go +++ b/core/state_transition.go @@ -168,7 +168,9 @@ type MessageRunContext struct { mutating bool executedOnChain bool gasEstimation bool // TODO: rename - wasmTargets []ethdb.WasmTarget + + wasmCacheTag uint32 + wasmTargets []ethdb.WasmTarget } func NewMessageCommitContext(wasmTargets []ethdb.WasmTarget) *MessageRunContext { @@ -227,6 +229,10 @@ func (m *MessageRunContext) IsCall() bool { return m.call } +func (m *MessageRunContext) WasmCacheTag() uint32 { + return m.wasmCacheTag +} + func (m *MessageRunContext) WasmTargets() []ethdb.WasmTarget { return m.wasmTargets } diff --git a/ethdb/database.go b/ethdb/database.go index 76f3fe6b6f..bb131036ec 100644 --- a/ethdb/database.go +++ b/ethdb/database.go @@ -178,9 +178,9 @@ type AncientStore interface { io.Closer } -type WasmTarget string +type WasmTarget string // TODO move to rawdb package type WasmDataBaseRetriever interface { - WasmDataBase() (KeyValueStore, uint32) + WasmDataBase() KeyValueStore } // Database contains all the methods required by the high level database to not diff --git a/ethdb/remotedb/remotedb.go b/ethdb/remotedb/remotedb.go index ef38ce786d..9add7672f2 100644 --- a/ethdb/remotedb/remotedb.go +++ b/ethdb/remotedb/remotedb.go @@ -39,8 +39,8 @@ func (db *Database) Has(key []byte) (bool, error) { return true, nil } -func (t *Database) WasmDataBase() (ethdb.KeyValueStore, uint32) { - return t, 0 +func (t *Database) WasmDataBase() ethdb.KeyValueStore { + return t } func (db *Database) Get(key []byte) ([]byte, error) { From acab6d3316b496061a876add66b2eefe9871d2c2 Mon Sep 17 00:00:00 2001 From: Maciej Kulawik Date: Wed, 13 Nov 2024 16:11:27 +0100 Subject: [PATCH 05/12] fix missed NewMessage*Mode -> NewMessage*Context renames --- cmd/evm/internal/t8ntool/execution.go | 2 +- eth/tracers/api_test.go | 2 +- eth/tracers/internal/tracetest/calltrace_test.go | 6 +++--- eth/tracers/internal/tracetest/flat_calltrace_test.go | 2 +- eth/tracers/internal/tracetest/prestate_test.go | 2 +- eth/tracers/tracers_test.go | 2 +- 6 files changed, 8 insertions(+), 8 deletions(-) diff --git a/cmd/evm/internal/t8ntool/execution.go b/cmd/evm/internal/t8ntool/execution.go index 1c76f669aa..e30f0f17ab 100644 --- a/cmd/evm/internal/t8ntool/execution.go +++ b/cmd/evm/internal/t8ntool/execution.go @@ -213,7 +213,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.NewMessageCommitMode(nil)) // TODO: do we need to specify wasm targets here if chainConfig.IsArbitrum == false? + msg, err := core.TransactionToMessage(tx, signer, pre.Env.BaseFee, core.NewMessageCommitContext(nil)) // TODO: do we need to specify wasm targets here if chainConfig.IsArbitrum == false? if err != nil { log.Warn("rejected tx", "index", i, "hash", tx.Hash(), "error", err) rejectedTxs = append(rejectedTxs, &rejectedTx{i, err.Error()}) diff --git a/eth/tracers/api_test.go b/eth/tracers/api_test.go index 5fdeb9fda4..a9c2a1ab22 100644 --- a/eth/tracers/api_test.go +++ b/eth/tracers/api_test.go @@ -174,7 +174,7 @@ func (b *testBackend) StateAtTransaction(ctx context.Context, block *types.Block } // Recompute transactions up to the target index. signer := types.MakeSigner(b.chainConfig, block.Number(), block.Time()) - runCtx := core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()}) + runCtx := core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()}) for idx, tx := range block.Transactions() { msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), runCtx) txContext := core.NewEVMTxContext(msg) diff --git a/eth/tracers/internal/tracetest/calltrace_test.go b/eth/tracers/internal/tracetest/calltrace_test.go index 1e130a1ad6..71dd2e963a 100644 --- a/eth/tracers/internal/tracetest/calltrace_test.go +++ b/eth/tracers/internal/tracetest/calltrace_test.go @@ -139,7 +139,7 @@ func testCallTracer(tracerName string, dirPath string, t *testing.T) { } state.StateDB.SetLogger(tracer.Hooks) - msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()})) + msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()})) if err != nil { t.Fatalf("failed to prepare transaction for tracing: %v", err) } @@ -231,7 +231,7 @@ func benchTracer(tracerName string, test *callTracerTest, b *testing.B) { Difficulty: (*big.Int)(test.Context.Difficulty), GasLimit: uint64(test.Context.GasLimit), } - msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()})) + msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()})) if err != nil { b.Fatalf("failed to prepare transaction for tracing: %v", err) } @@ -388,7 +388,7 @@ func TestInternals(t *testing.T) { GasPrice: tx.GasPrice(), } evm := vm.NewEVM(context, txContext, state.StateDB, config, vm.Config{Tracer: tc.tracer.Hooks}) - msg, err := core.TransactionToMessage(tx, signer, big.NewInt(0), core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()})) + msg, err := core.TransactionToMessage(tx, signer, big.NewInt(0), core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()})) if err != nil { t.Fatalf("test %v: failed to create message: %v", tc.name, err) } diff --git a/eth/tracers/internal/tracetest/flat_calltrace_test.go b/eth/tracers/internal/tracetest/flat_calltrace_test.go index b6ea16fa67..1b8da00efb 100644 --- a/eth/tracers/internal/tracetest/flat_calltrace_test.go +++ b/eth/tracers/internal/tracetest/flat_calltrace_test.go @@ -96,7 +96,7 @@ func flatCallTracerTestRunner(tracerName string, filename string, dirPath string } state.StateDB.SetLogger(tracer.Hooks) - msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()})) + msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()})) if err != nil { return fmt.Errorf("failed to prepare transaction for tracing: %v", err) } diff --git a/eth/tracers/internal/tracetest/prestate_test.go b/eth/tracers/internal/tracetest/prestate_test.go index 396558f09d..1f66bc4443 100644 --- a/eth/tracers/internal/tracetest/prestate_test.go +++ b/eth/tracers/internal/tracetest/prestate_test.go @@ -105,7 +105,7 @@ func testPrestateDiffTracer(tracerName string, dirPath string, t *testing.T) { } state.StateDB.SetLogger(tracer.Hooks) - msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()})) + msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()})) if err != nil { t.Fatalf("failed to prepare transaction for tracing: %v", err) } diff --git a/eth/tracers/tracers_test.go b/eth/tracers/tracers_test.go index f5db043ac6..c30bbd8712 100644 --- a/eth/tracers/tracers_test.go +++ b/eth/tracers/tracers_test.go @@ -91,7 +91,7 @@ func BenchmarkTransactionTrace(b *testing.B) { //EnableReturnData: false, }) evm := vm.NewEVM(context, txContext, state.StateDB, params.AllEthashProtocolChanges, vm.Config{Tracer: tracer.Hooks()}) - msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayMode([]ethdb.WasmTarget{rawdb.LocalTarget()})) + msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()})) if err != nil { b.Fatalf("failed to prepare transaction for tracing: %v", err) } From 48c205077edeec96c2b34eb5aaf4b566febac7ed Mon Sep 17 00:00:00 2001 From: Maciej Kulawik Date: Wed, 13 Nov 2024 16:55:04 +0100 Subject: [PATCH 06/12] remove unused wasmTag from cachingDB --- core/state/database.go | 1 - 1 file changed, 1 deletion(-) diff --git a/core/state/database.go b/core/state/database.go index 198213e0fd..9fd5c218d3 100644 --- a/core/state/database.go +++ b/core/state/database.go @@ -195,7 +195,6 @@ type activatedAsmCacheKey struct { type cachingDB struct { // Arbitrum activatedAsmCache *lru.SizeConstrainedCache[activatedAsmCacheKey, []byte] - wasmTag uint32 disk ethdb.KeyValueStore wasmdb ethdb.KeyValueStore From fd4538a2c5bcbe67b4bb847f71ffbb6d3dbd6800 Mon Sep 17 00:00:00 2001 From: Maciej Kulawik Date: Wed, 13 Nov 2024 17:02:24 +0100 Subject: [PATCH 07/12] set wasmCacheTag for MessageCommitContext to 1 --- core/state_transition.go | 1 + 1 file changed, 1 insertion(+) diff --git a/core/state_transition.go b/core/state_transition.go index 7508908f17..bb37f5185f 100644 --- a/core/state_transition.go +++ b/core/state_transition.go @@ -178,6 +178,7 @@ func NewMessageCommitContext(wasmTargets []ethdb.WasmTarget) *MessageRunContext chainTip: true, mutating: true, executedOnChain: true, + wasmCacheTag: 1, wasmTargets: wasmTargets, } } From 956e6493a5280e0413a698c83b18a0d1d9a87a82 Mon Sep 17 00:00:00 2001 From: Maciej Kulawik Date: Thu, 14 Nov 2024 16:22:45 +0100 Subject: [PATCH 08/12] refactor MessageRunContext methods --- core/state_transition.go | 62 +++++++++++++++++++++------------------- 1 file changed, 32 insertions(+), 30 deletions(-) diff --git a/core/state_transition.go b/core/state_transition.go index bb37f5185f..2dc3cb4bfc 100644 --- a/core/state_transition.go +++ b/core/state_transition.go @@ -162,12 +162,17 @@ type Message struct { SkipL1Charging bool } +type messageRunMode uint8 + +const ( + messageCommitMode messageRunMode = iota + messageGasEstimationMode + messageEthcallMode + messageReplayMode +) + type MessageRunContext struct { - chainTip bool - call bool // TODO: rename or refactor the bool flags - mutating bool - executedOnChain bool - gasEstimation bool // TODO: rename + runMode messageRunMode wasmCacheTag uint32 wasmTargets []ethdb.WasmTarget @@ -175,19 +180,16 @@ type MessageRunContext struct { func NewMessageCommitContext(wasmTargets []ethdb.WasmTarget) *MessageRunContext { return &MessageRunContext{ - chainTip: true, - mutating: true, - executedOnChain: true, - wasmCacheTag: 1, - wasmTargets: wasmTargets, + runMode: messageCommitMode, + wasmCacheTag: 1, + wasmTargets: wasmTargets, } } func NewMessageReplayContext(wasmTargets []ethdb.WasmTarget) *MessageRunContext { return &MessageRunContext{ - mutating: true, - executedOnChain: true, - wasmTargets: wasmTargets, + runMode: messageReplayMode, + wasmTargets: wasmTargets, } } @@ -197,45 +199,45 @@ func NewMessagePrefetchContext(wasmTargets []ethdb.WasmTarget) *MessageRunContex func NewMessageEthcallContext() *MessageRunContext { return &MessageRunContext{ - call: true, + runMode: messageEthcallMode, wasmTargets: []ethdb.WasmTarget{rawdb.LocalTarget()}, } } func NewMessageGasEstimationContext() *MessageRunContext { return &MessageRunContext{ - gasEstimation: true, - wasmTargets: []ethdb.WasmTarget{rawdb.LocalTarget()}, + runMode: messageGasEstimationMode, + wasmTargets: []ethdb.WasmTarget{rawdb.LocalTarget()}, } } -func (m *MessageRunContext) IsChainTip() bool { - return m.chainTip +func (c *MessageRunContext) IsCommitMode() bool { + return c.runMode == messageCommitMode } // these message modes are executed onchain so cannot make any gas shortcuts -func (m *MessageRunContext) ExecutedOnChain() bool { - return m.executedOnChain +func (c *MessageRunContext) IsExecutedOnChain() bool { + return c.runMode == messageCommitMode || c.runMode == messageReplayMode } -func (m *MessageRunContext) IsGasEstimation() bool { - return m.gasEstimation +func (c *MessageRunContext) IsGasEstimation() bool { + return c.runMode == messageGasEstimationMode } -func (m *MessageRunContext) IsMutating() bool { - return m.mutating +func (c *MessageRunContext) IsNonMutating() bool { + return c.runMode == messageGasEstimationMode || c.runMode == messageEthcallMode } -func (m *MessageRunContext) IsCall() bool { - return m.call +func (c *MessageRunContext) IsEthcall() bool { + return c.runMode == messageEthcallMode } -func (m *MessageRunContext) WasmCacheTag() uint32 { - return m.wasmCacheTag +func (c *MessageRunContext) WasmCacheTag() uint32 { + return c.wasmCacheTag } -func (m *MessageRunContext) WasmTargets() []ethdb.WasmTarget { - return m.wasmTargets +func (c *MessageRunContext) WasmTargets() []ethdb.WasmTarget { + return c.wasmTargets } // TransactionToMessage converts a transaction into a Message. From ec2af98b1ce2ca38a9370586f7f6de2201ff4117 Mon Sep 17 00:00:00 2001 From: Maciej Kulawik Date: Fri, 15 Nov 2024 15:32:12 +0100 Subject: [PATCH 09/12] move WasmTarget to rawdb package --- core/rawdb/accessors_state_arbitrum.go | 22 ++++++++++--------- core/rawdb/database.go | 4 ++-- core/state/database.go | 4 ++-- core/state/database_arbitrum.go | 3 +-- core/state/statedb_arbitrum.go | 14 ++++++------ core/state_processor.go | 5 ++--- core/state_transition.go | 15 ++++++------- core/vm/interface.go | 8 +++---- eth/state_accessor.go | 3 +-- eth/tracers/api.go | 12 +++++----- eth/tracers/api_test.go | 2 +- .../internal/tracetest/calltrace_test.go | 7 +++--- .../internal/tracetest/flat_calltrace_test.go | 3 +-- .../internal/tracetest/prestate_test.go | 3 +-- eth/tracers/tracers_test.go | 3 +-- ethdb/database.go | 1 - 16 files changed, 51 insertions(+), 58 deletions(-) diff --git a/core/rawdb/accessors_state_arbitrum.go b/core/rawdb/accessors_state_arbitrum.go index b6b282d67f..7c7898cd1a 100644 --- a/core/rawdb/accessors_state_arbitrum.go +++ b/core/rawdb/accessors_state_arbitrum.go @@ -25,14 +25,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": @@ -44,7 +46,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: @@ -61,19 +63,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) @@ -85,7 +87,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) diff --git a/core/rawdb/database.go b/core/rawdb/database.go index 74ad1d0870..53759ad834 100644 --- a/core/rawdb/database.go +++ b/core/rawdb/database.go @@ -45,7 +45,7 @@ func (frdb *freezerdb) WasmDataBase() ethdb.KeyValueStore { return frdb } -func (frdb *freezerdb) WasmTargets() []ethdb.WasmTarget { +func (frdb *freezerdb) WasmTargets() []WasmTarget { return nil } @@ -170,7 +170,7 @@ func (db *nofreezedb) WasmDataBase() ethdb.KeyValueStore { return db } -func (db *nofreezedb) WasmTargets() []ethdb.WasmTarget { +func (db *nofreezedb) WasmTargets() []WasmTarget { return nil } diff --git a/core/state/database.go b/core/state/database.go index 9fd5c218d3..b5bb9d6ab1 100644 --- a/core/state/database.go +++ b/core/state/database.go @@ -53,7 +53,7 @@ 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 // OpenTrie opens the main account trie. @@ -189,7 +189,7 @@ func NewDatabaseWithNodeDB(db ethdb.Database, triedb *triedb.Database) Database type activatedAsmCacheKey struct { moduleHash common.Hash - target ethdb.WasmTarget + target rawdb.WasmTarget } type cachingDB struct { diff --git a/core/state/database_arbitrum.go b/core/state/database_arbitrum.go index 851e54ff4e..75cb17fd87 100644 --- a/core/state/database_arbitrum.go +++ b/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 diff --git a/core/state/statedb_arbitrum.go b/core/state/statedb_arbitrum.go index 0eadd2306f..6c5f6e11ab 100644 --- a/core/state/statedb_arbitrum.go +++ b/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 { @@ -241,7 +241,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 diff --git a/core/state_processor.go b/core/state_processor.go index 55b8e81feb..0c535e2000 100644 --- a/core/state_processor.go +++ b/core/state_processor.go @@ -28,7 +28,6 @@ import ( "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" - "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/params" ) @@ -81,7 +80,7 @@ func (p *StateProcessor) Process(block *types.Block, statedb *state.StateDB, cfg if beaconRoot := block.BeaconRoot(); beaconRoot != nil { ProcessBeaconBlockRoot(*beaconRoot, vmenv, statedb) } - runCtx := NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()}) + runCtx := NewMessageReplayContext([]rawdb.WasmTarget{rawdb.LocalTarget()}) // Iterate over and process the individual transactions for i, tx := range block.Transactions() { msg, err := TransactionToMessage(tx, signer, header.BaseFee, runCtx) @@ -182,7 +181,7 @@ func ApplyTransactionWithEVM(msg *Message, config *params.ChainConfig, gp *GasPo // for the transaction, gas used and an error if the transaction failed, // indicating the block was invalid. func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config) (*types.Receipt, *ExecutionResult, error) { - return ApplyTransactionWithResultFilter(config, bc, author, gp, statedb, header, tx, usedGas, cfg, NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()}), nil) + return ApplyTransactionWithResultFilter(config, bc, author, gp, statedb, header, tx, usedGas, cfg, NewMessageReplayContext([]rawdb.WasmTarget{rawdb.LocalTarget()}), nil) } func ApplyTransactionWithResultFilter(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config, runCtx *MessageRunContext, resultFilter func(*ExecutionResult) error) (*types.Receipt, *ExecutionResult, error) { diff --git a/core/state_transition.go b/core/state_transition.go index 2dc3cb4bfc..1fd8fb2ea6 100644 --- a/core/state_transition.go +++ b/core/state_transition.go @@ -28,7 +28,6 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/crypto/kzg4844" - "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/params" "github.com/holiman/uint256" ) @@ -175,10 +174,10 @@ type MessageRunContext struct { runMode messageRunMode wasmCacheTag uint32 - wasmTargets []ethdb.WasmTarget + wasmTargets []rawdb.WasmTarget } -func NewMessageCommitContext(wasmTargets []ethdb.WasmTarget) *MessageRunContext { +func NewMessageCommitContext(wasmTargets []rawdb.WasmTarget) *MessageRunContext { return &MessageRunContext{ runMode: messageCommitMode, wasmCacheTag: 1, @@ -186,28 +185,28 @@ func NewMessageCommitContext(wasmTargets []ethdb.WasmTarget) *MessageRunContext } } -func NewMessageReplayContext(wasmTargets []ethdb.WasmTarget) *MessageRunContext { +func NewMessageReplayContext(wasmTargets []rawdb.WasmTarget) *MessageRunContext { return &MessageRunContext{ runMode: messageReplayMode, wasmTargets: wasmTargets, } } -func NewMessagePrefetchContext(wasmTargets []ethdb.WasmTarget) *MessageRunContext { +func NewMessagePrefetchContext(wasmTargets []rawdb.WasmTarget) *MessageRunContext { return NewMessageReplayContext(wasmTargets) } func NewMessageEthcallContext() *MessageRunContext { return &MessageRunContext{ runMode: messageEthcallMode, - wasmTargets: []ethdb.WasmTarget{rawdb.LocalTarget()}, + wasmTargets: []rawdb.WasmTarget{rawdb.LocalTarget()}, } } func NewMessageGasEstimationContext() *MessageRunContext { return &MessageRunContext{ runMode: messageGasEstimationMode, - wasmTargets: []ethdb.WasmTarget{rawdb.LocalTarget()}, + wasmTargets: []rawdb.WasmTarget{rawdb.LocalTarget()}, } } @@ -236,7 +235,7 @@ func (c *MessageRunContext) WasmCacheTag() uint32 { return c.wasmCacheTag } -func (c *MessageRunContext) WasmTargets() []ethdb.WasmTarget { +func (c *MessageRunContext) WasmTargets() []rawdb.WasmTarget { return c.wasmTargets } diff --git a/core/vm/interface.go b/core/vm/interface.go index 69e28375e3..0545fd0cd2 100644 --- a/core/vm/interface.go +++ b/core/vm/interface.go @@ -20,10 +20,10 @@ import ( "math/big" "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/rawdb" "github.com/ethereum/go-ethereum/core/state" "github.com/ethereum/go-ethereum/core/tracing" "github.com/ethereum/go-ethereum/core/types" - "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/params" "github.com/holiman/uint256" ) @@ -31,9 +31,9 @@ import ( // StateDB is an EVM database for full state querying. type StateDB interface { // Arbitrum: manage Stylus wasms - ActivateWasm(moduleHash common.Hash, asmMap map[ethdb.WasmTarget][]byte) - TryGetActivatedAsm(target ethdb.WasmTarget, moduleHash common.Hash) (asm []byte, err error) - TryGetActivatedAsmMap(targets []ethdb.WasmTarget, moduleHash common.Hash) (asmMap map[ethdb.WasmTarget][]byte, err error) + ActivateWasm(moduleHash common.Hash, asmMap map[rawdb.WasmTarget][]byte) + TryGetActivatedAsm(target rawdb.WasmTarget, moduleHash common.Hash) (asm []byte, err error) + TryGetActivatedAsmMap(targets []rawdb.WasmTarget, moduleHash common.Hash) (asmMap map[rawdb.WasmTarget][]byte, err error) RecordCacheWasm(wasm state.CacheWasm) RecordEvictWasm(wasm state.EvictWasm) GetRecentWasms() state.RecentWasms diff --git a/eth/state_accessor.go b/eth/state_accessor.go index 12506ab2e0..253846862e 100644 --- a/eth/state_accessor.go +++ b/eth/state_accessor.go @@ -29,7 +29,6 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/eth/tracers" - "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/metrics" "github.com/ethereum/go-ethereum/trie" @@ -265,7 +264,7 @@ func (eth *Ethereum) stateAtTransaction(ctx context.Context, block *types.Block, } // Recompute transactions up to the target index. signer := types.MakeSigner(eth.blockchain.Config(), block.Number(), block.Time()) - runCtx := core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()}) + runCtx := core.NewMessageReplayContext([]rawdb.WasmTarget{rawdb.LocalTarget()}) for idx, tx := range block.Transactions() { // Assemble the transaction call message and return if the requested offset msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), runCtx) diff --git a/eth/tracers/api.go b/eth/tracers/api.go index 1714232dd3..0d6eebdd98 100644 --- a/eth/tracers/api.go +++ b/eth/tracers/api.go @@ -263,7 +263,7 @@ func (api *API) traceChain(start, end *types.Block, config *TraceConfig, closed tracker = newStateTracker(maximumPendingTraceStates, start.NumberU64()) ) - runCtx := core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()}) + runCtx := core.NewMessageReplayContext([]rawdb.WasmTarget{rawdb.LocalTarget()}) for th := 0; th < threads; th++ { pend.Add(1) @@ -542,7 +542,7 @@ func (api *API) IntermediateRoots(ctx context.Context, hash common.Hash, config vmenv := vm.NewEVM(vmctx, vm.TxContext{}, statedb, chainConfig, vm.Config{}) core.ProcessBeaconBlockRoot(*beaconRoot, vmenv, statedb) } - runCtx := core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()}) + runCtx := core.NewMessageReplayContext([]rawdb.WasmTarget{rawdb.LocalTarget()}) for i, tx := range block.Transactions() { if err := ctx.Err(); err != nil { return nil, err @@ -622,7 +622,7 @@ func (api *API) traceBlock(ctx context.Context, block *types.Block, config *Trac vmenv := vm.NewEVM(blockCtx, vm.TxContext{}, statedb, api.backend.ChainConfig(), vm.Config{}) core.ProcessBeaconBlockRoot(*beaconRoot, vmenv, statedb) } - runCtx := core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()}) + runCtx := core.NewMessageReplayContext([]rawdb.WasmTarget{rawdb.LocalTarget()}) for i, tx := range txs { // Generate the next state snapshot fast without tracing msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), runCtx) @@ -653,7 +653,7 @@ func (api *API) traceBlockParallel(ctx context.Context, block *types.Block, stat results = make([]*txTraceResult, len(txs)) pend sync.WaitGroup ) - runCtx := core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()}) + runCtx := core.NewMessageReplayContext([]rawdb.WasmTarget{rawdb.LocalTarget()}) threads := runtime.NumCPU() if threads > len(txs) { threads = len(txs) @@ -783,7 +783,7 @@ func (api *API) standardTraceBlockToFile(ctx context.Context, block *types.Block core.ProcessBeaconBlockRoot(*beaconRoot, vmenv, statedb) } - runCtx := core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()}) + runCtx := core.NewMessageReplayContext([]rawdb.WasmTarget{rawdb.LocalTarget()}) for i, tx := range block.Transactions() { // Prepare the transaction for un-traced execution var ( @@ -881,7 +881,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.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()})) + msg, err := core.TransactionToMessage(tx, types.MakeSigner(api.backend.ChainConfig(), block.Number(), block.Time()), block.BaseFee(), core.NewMessageReplayContext([]rawdb.WasmTarget{rawdb.LocalTarget()})) if err != nil { return nil, err } diff --git a/eth/tracers/api_test.go b/eth/tracers/api_test.go index a9c2a1ab22..39912fcbb1 100644 --- a/eth/tracers/api_test.go +++ b/eth/tracers/api_test.go @@ -174,7 +174,7 @@ func (b *testBackend) StateAtTransaction(ctx context.Context, block *types.Block } // Recompute transactions up to the target index. signer := types.MakeSigner(b.chainConfig, block.Number(), block.Time()) - runCtx := core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()}) + runCtx := core.NewMessageReplayContext([]rawdb.WasmTarget{rawdb.LocalTarget()}) for idx, tx := range block.Transactions() { msg, _ := core.TransactionToMessage(tx, signer, block.BaseFee(), runCtx) txContext := core.NewEVMTxContext(msg) diff --git a/eth/tracers/internal/tracetest/calltrace_test.go b/eth/tracers/internal/tracetest/calltrace_test.go index 71dd2e963a..cac3d04dc5 100644 --- a/eth/tracers/internal/tracetest/calltrace_test.go +++ b/eth/tracers/internal/tracetest/calltrace_test.go @@ -33,7 +33,6 @@ import ( "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/eth/tracers" - "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/tests" @@ -139,7 +138,7 @@ func testCallTracer(tracerName string, dirPath string, t *testing.T) { } state.StateDB.SetLogger(tracer.Hooks) - msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()})) + msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayContext([]rawdb.WasmTarget{rawdb.LocalTarget()})) if err != nil { t.Fatalf("failed to prepare transaction for tracing: %v", err) } @@ -231,7 +230,7 @@ func benchTracer(tracerName string, test *callTracerTest, b *testing.B) { Difficulty: (*big.Int)(test.Context.Difficulty), GasLimit: uint64(test.Context.GasLimit), } - msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()})) + msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayContext([]rawdb.WasmTarget{rawdb.LocalTarget()})) if err != nil { b.Fatalf("failed to prepare transaction for tracing: %v", err) } @@ -388,7 +387,7 @@ func TestInternals(t *testing.T) { GasPrice: tx.GasPrice(), } evm := vm.NewEVM(context, txContext, state.StateDB, config, vm.Config{Tracer: tc.tracer.Hooks}) - msg, err := core.TransactionToMessage(tx, signer, big.NewInt(0), core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()})) + msg, err := core.TransactionToMessage(tx, signer, big.NewInt(0), core.NewMessageReplayContext([]rawdb.WasmTarget{rawdb.LocalTarget()})) if err != nil { t.Fatalf("test %v: failed to create message: %v", tc.name, err) } diff --git a/eth/tracers/internal/tracetest/flat_calltrace_test.go b/eth/tracers/internal/tracetest/flat_calltrace_test.go index 1b8da00efb..f863e65d30 100644 --- a/eth/tracers/internal/tracetest/flat_calltrace_test.go +++ b/eth/tracers/internal/tracetest/flat_calltrace_test.go @@ -17,7 +17,6 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/eth/tracers" - "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/tests" ) @@ -96,7 +95,7 @@ func flatCallTracerTestRunner(tracerName string, filename string, dirPath string } state.StateDB.SetLogger(tracer.Hooks) - msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()})) + msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayContext([]rawdb.WasmTarget{rawdb.LocalTarget()})) if err != nil { return fmt.Errorf("failed to prepare transaction for tracing: %v", err) } diff --git a/eth/tracers/internal/tracetest/prestate_test.go b/eth/tracers/internal/tracetest/prestate_test.go index 1f66bc4443..9dd7ae801e 100644 --- a/eth/tracers/internal/tracetest/prestate_test.go +++ b/eth/tracers/internal/tracetest/prestate_test.go @@ -30,7 +30,6 @@ import ( "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/eth/tracers" - "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/tests" ) @@ -105,7 +104,7 @@ func testPrestateDiffTracer(tracerName string, dirPath string, t *testing.T) { } state.StateDB.SetLogger(tracer.Hooks) - msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()})) + msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayContext([]rawdb.WasmTarget{rawdb.LocalTarget()})) if err != nil { t.Fatalf("failed to prepare transaction for tracing: %v", err) } diff --git a/eth/tracers/tracers_test.go b/eth/tracers/tracers_test.go index c30bbd8712..c41f05db82 100644 --- a/eth/tracers/tracers_test.go +++ b/eth/tracers/tracers_test.go @@ -27,7 +27,6 @@ import ( "github.com/ethereum/go-ethereum/core/vm" "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/eth/tracers/logger" - "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/tests" ) @@ -91,7 +90,7 @@ func BenchmarkTransactionTrace(b *testing.B) { //EnableReturnData: false, }) evm := vm.NewEVM(context, txContext, state.StateDB, params.AllEthashProtocolChanges, vm.Config{Tracer: tracer.Hooks()}) - msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayContext([]ethdb.WasmTarget{rawdb.LocalTarget()})) + msg, err := core.TransactionToMessage(tx, signer, context.BaseFee, core.NewMessageReplayContext([]rawdb.WasmTarget{rawdb.LocalTarget()})) if err != nil { b.Fatalf("failed to prepare transaction for tracing: %v", err) } diff --git a/ethdb/database.go b/ethdb/database.go index bb131036ec..66b736a13b 100644 --- a/ethdb/database.go +++ b/ethdb/database.go @@ -178,7 +178,6 @@ type AncientStore interface { io.Closer } -type WasmTarget string // TODO move to rawdb package type WasmDataBaseRetriever interface { WasmDataBase() KeyValueStore } From c7e8abc4282976ac60d54b4915cdcc4e1ead7ac0 Mon Sep 17 00:00:00 2001 From: Maciej Kulawik Date: Fri, 10 Jan 2025 18:43:18 +0100 Subject: [PATCH 10/12] add RunModeMetricName method --- core/state_transition.go | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/core/state_transition.go b/core/state_transition.go index 1fd8fb2ea6..2b30c10425 100644 --- a/core/state_transition.go +++ b/core/state_transition.go @@ -239,6 +239,21 @@ func (c *MessageRunContext) WasmTargets() []rawdb.WasmTarget { return c.wasmTargets } +func (c *MessageRunContext) RunModeMetricName() string { + switch c.runMode { + case messageCommitMode: + return "commit_runmode" + case messageGasEstimationMode: + return "gas_estimation_runmode" + case messageEthcallMode: + return "eth_call_runmode" + case messageReplayMode: + return "replay_runmode" + default: + return "unknown_runmode" + } +} + // TransactionToMessage converts a transaction into a Message. func TransactionToMessage(tx *types.Transaction, s types.Signer, baseFee *big.Int, runCtx *MessageRunContext) (*Message, error) { msg := &Message{ From 937e7e3d936ff78778698916650dd0f195dcd514 Mon Sep 17 00:00:00 2001 From: Maciej Kulawik Date: Fri, 10 Jan 2025 20:46:06 +0100 Subject: [PATCH 11/12] default to local target when empty targets are passed to new MessageRunContext --- cmd/evm/internal/t8ntool/execution.go | 2 +- core/state_transition.go | 9 +++++++++ 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/cmd/evm/internal/t8ntool/execution.go b/cmd/evm/internal/t8ntool/execution.go index e30f0f17ab..17bc45b158 100644 --- a/cmd/evm/internal/t8ntool/execution.go +++ b/cmd/evm/internal/t8ntool/execution.go @@ -213,7 +213,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.NewMessageCommitContext(nil)) // TODO: do we need to specify wasm targets here if chainConfig.IsArbitrum == false? + 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()}) diff --git a/core/state_transition.go b/core/state_transition.go index 2b30c10425..c2ba4e6c86 100644 --- a/core/state_transition.go +++ b/core/state_transition.go @@ -178,6 +178,9 @@ type MessageRunContext struct { } func NewMessageCommitContext(wasmTargets []rawdb.WasmTarget) *MessageRunContext { + if len(wasmTargets) == 0 { + wasmTargets = []rawdb.WasmTarget{rawdb.LocalTarget()} + } return &MessageRunContext{ runMode: messageCommitMode, wasmCacheTag: 1, @@ -186,6 +189,9 @@ func NewMessageCommitContext(wasmTargets []rawdb.WasmTarget) *MessageRunContext } func NewMessageReplayContext(wasmTargets []rawdb.WasmTarget) *MessageRunContext { + if len(wasmTargets) == 0 { + wasmTargets = []rawdb.WasmTarget{rawdb.LocalTarget()} + } return &MessageRunContext{ runMode: messageReplayMode, wasmTargets: wasmTargets, @@ -193,6 +199,9 @@ func NewMessageReplayContext(wasmTargets []rawdb.WasmTarget) *MessageRunContext } func NewMessagePrefetchContext(wasmTargets []rawdb.WasmTarget) *MessageRunContext { + if len(wasmTargets) == 0 { + wasmTargets = []rawdb.WasmTarget{rawdb.LocalTarget()} + } return NewMessageReplayContext(wasmTargets) } From b50e0c851cbd90be4abdbad9192ad53c0a9e1de2 Mon Sep 17 00:00:00 2001 From: Maciej Kulawik Date: Mon, 13 Jan 2025 16:25:16 +0100 Subject: [PATCH 12/12] pass runCtx to runScheduledTxes in doCall instead of overwriting it with gas estimation ctx --- internal/ethapi/api.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/ethapi/api.go b/internal/ethapi/api.go index a3c9ad7d67..32e9a71d92 100644 --- a/internal/ethapi/api.go +++ b/internal/ethapi/api.go @@ -1167,7 +1167,7 @@ func doCall(ctx context.Context, b Backend, args TransactionArgs, state *state.S } // Arbitrum: a tx can schedule another (see retryables) - result, err = runScheduledTxes(ctx, b, state, header, blockCtx, core.NewMessageGasEstimationContext(), result) // TODO: why do we use GasEstimationMode here? + result, err = runScheduledTxes(ctx, b, state, header, blockCtx, runCtx, result) if err != nil { return nil, err }