diff --git a/cmd/evm/internal/t8ntool/transition.go b/cmd/evm/internal/t8ntool/transition.go index 0d358b8be6..24997def03 100644 --- a/cmd/evm/internal/t8ntool/transition.go +++ b/cmd/evm/internal/t8ntool/transition.go @@ -152,7 +152,7 @@ func Transition(ctx *cli.Context) error { } if err := applyEOFChecks(&prestate, chainConfig); err != nil { return err - } + } // Configure tracer if ctx.IsSet(TraceTracerFlag.Name) { // Custom tracing @@ -281,7 +281,7 @@ func applyEOFChecks(prestate *Prestate, chainConfig *params.ChainConfig) error { ) err = c.UnmarshalBinary(acc.Code, false) if err == nil { - jt := vm.NewPragueEOFInstructionSetForTesting() + jt := vm.NewEOFInstructionSetForTesting() err = c.ValidateCode(&jt, false) } if err != nil { diff --git a/core/vm/eof_instructions.go b/core/vm/eof_instructions.go index c06071f6d5..a0ed9ada83 100644 --- a/core/vm/eof_instructions.go +++ b/core/vm/eof_instructions.go @@ -20,9 +20,9 @@ import ( "encoding/binary" "errors" "fmt" + "math" "github.com/ethereum/go-ethereum/common" - "github.com/ethereum/go-ethereum/common/math" "github.com/ethereum/go-ethereum/core/tracing" "github.com/ethereum/go-ethereum/params" "github.com/holiman/uint256" diff --git a/core/vm/instructions_test.go b/core/vm/instructions_test.go index 091dc013ea..c3c28f23f1 100644 --- a/core/vm/instructions_test.go +++ b/core/vm/instructions_test.go @@ -115,7 +115,7 @@ func testTwoOperandOp(t *testing.T, tests []TwoOperandTestcase, opFn executionFu expected := new(uint256.Int).SetBytes(common.Hex2Bytes(test.Expected)) stack.push(x) stack.push(y) - opFn(&pc, evmInterpreter, &ScopeContext{nil, stack, nil, 0, nil, false}) + opFn(&pc, evm.interpreter, &ScopeContext{nil, stack, nil, 0, nil, false}) if len(stack.data) != 1 { t.Errorf("Expected one item on stack after %v, got %d: ", name, len(stack.data)) } @@ -229,7 +229,7 @@ func TestAddMod(t *testing.T) { stack.push(z) stack.push(y) stack.push(x) - opAddmod(&pc, evmInterpreter, &ScopeContext{nil, stack, nil, 0, nil, false}) + opAddmod(&pc, evm.interpreter, &ScopeContext{nil, stack, nil, 0, nil, false}) actual := stack.pop() if actual.Cmp(expected) != 0 { t.Errorf("Testcase %d, expected %x, got %x", i, expected, actual) @@ -255,7 +255,7 @@ func TestWriteExpectedValues(t *testing.T) { y := new(uint256.Int).SetBytes(common.Hex2Bytes(param.y)) stack.push(x) stack.push(y) - opFn(&pc, interpreter, &ScopeContext{nil, stack, nil, 0, nil, false}) + opFn(&pc, evm.interpreter, &ScopeContext{nil, stack, nil, 0, nil, false}) actual := stack.pop() result[i] = TwoOperandTestcase{param.x, param.y, fmt.Sprintf("%064x", actual)} } @@ -289,10 +289,9 @@ func TestJsonTestcases(t *testing.T) { func opBenchmark(bench *testing.B, op executionFunc, args ...string) { var ( - env = NewEVM(BlockContext{}, TxContext{}, nil, params.TestChainConfig, Config{}) - stack = newstack() - scope = &ScopeContext{nil, stack, nil, 0, nil, false} - evmInterpreter = NewEVMInterpreter(env) + evm = NewEVM(BlockContext{}, nil, params.TestChainConfig, Config{}) + stack = newstack() + scope = &ScopeContext{nil, stack, nil, 0, nil, false} ) // convert args intArgs := make([]*uint256.Int, len(args)) @@ -537,13 +536,13 @@ func TestOpMstore(t *testing.T) { v := "abcdef00000000000000abba000000000deaf000000c0de00100000000133700" stack.push(new(uint256.Int).SetBytes(common.Hex2Bytes(v))) stack.push(new(uint256.Int)) - opMstore(&pc, evmInterpreter, &ScopeContext{mem, stack, nil, 0, nil, false}) + opMstore(&pc, evm.interpreter, &ScopeContext{mem, stack, nil, 0, nil, false}) if got := common.Bytes2Hex(mem.GetCopy(0, 32)); got != v { t.Fatalf("Mstore fail, got %v, expected %v", got, v) } stack.push(new(uint256.Int).SetUint64(0x1)) stack.push(new(uint256.Int)) - opMstore(&pc, evmInterpreter, &ScopeContext{mem, stack, nil, 0, nil, false}) + opMstore(&pc, evm.interpreter, &ScopeContext{mem, stack, nil, 0, nil, false}) if common.Bytes2Hex(mem.GetCopy(0, 32)) != "0000000000000000000000000000000000000000000000000000000000000001" { t.Fatalf("Mstore failed to overwrite previous value") } @@ -564,23 +563,22 @@ func BenchmarkOpMstore(bench *testing.B) { for i := 0; i < bench.N; i++ { stack.push(value) stack.push(memStart) - opMstore(&pc, evmInterpreter, &ScopeContext{mem, stack, nil, 0, nil, false}) + opMstore(&pc, evm.interpreter, &ScopeContext{mem, stack, nil, 0, nil, false}) } } func TestOpTstore(t *testing.T) { var ( - statedb, _ = state.New(types.EmptyRootHash, state.NewDatabaseForTesting()) - env = NewEVM(BlockContext{}, TxContext{}, statedb, params.TestChainConfig, Config{}) - stack = newstack() - mem = NewMemory() - evmInterpreter = NewEVMInterpreter(env) - caller = common.Address{} - to = common.Address{1} - contractRef = contractRef{caller} - contract = NewContract(contractRef, AccountRef(to), new(uint256.Int), 0) - scopeContext = ScopeContext{mem, stack, contract, 0, nil, false} - value = common.Hex2Bytes("abcdef00000000000000abba000000000deaf000000c0de00100000000133700") + statedb, _ = state.New(types.EmptyRootHash, state.NewDatabaseForTesting()) + evm = NewEVM(BlockContext{}, statedb, params.TestChainConfig, Config{}) + stack = newstack() + mem = NewMemory() + caller = common.Address{} + to = common.Address{1} + contractRef = contractRef{caller} + contract = NewContract(contractRef, AccountRef(to), new(uint256.Int), 0) + scopeContext = ScopeContext{mem, stack, contract, 0, nil, false} + value = common.Hex2Bytes("abcdef00000000000000abba000000000deaf000000c0de00100000000133700") ) // Add a stateObject for the caller and the contract being called @@ -624,7 +622,7 @@ func BenchmarkOpKeccak256(bench *testing.B) { for i := 0; i < bench.N; i++ { stack.push(uint256.NewInt(32)) stack.push(start) - opKeccak256(&pc, evmInterpreter, &ScopeContext{mem, stack, nil, 0, nil, false}) + opKeccak256(&pc, evm.interpreter, &ScopeContext{mem, stack, nil, 0, nil, false}) } } @@ -718,7 +716,7 @@ func TestRandom(t *testing.T) { stack = newstack() pc = uint64(0) ) - opRandom(&pc, evmInterpreter, &ScopeContext{nil, stack, nil, 0, nil, false}) + opRandom(&pc, evm.interpreter, &ScopeContext{nil, stack, nil, 0, nil, false}) if len(stack.data) != 1 { t.Errorf("Expected one item on stack after %v, got %d: ", tt.name, len(stack.data)) } @@ -760,7 +758,7 @@ func TestBlobHash(t *testing.T) { ) evm.SetTxContext(TxContext{BlobHashes: tt.hashes}) stack.push(uint256.NewInt(tt.idx)) - opBlobHash(&pc, evmInterpreter, &ScopeContext{nil, stack, nil, 0, nil, false}) + opBlobHash(&pc, evm.interpreter, &ScopeContext{nil, stack, nil, 0, nil, false}) if len(stack.data) != 1 { t.Errorf("Expected one item on stack after %v, got %d: ", tt.name, len(stack.data)) } @@ -900,7 +898,7 @@ func TestOpMCopy(t *testing.T) { mem.Resize(memorySize) } // Do the copy - opMcopy(&pc, evmInterpreter, &ScopeContext{mem, stack, nil, 0, nil, false}) + opMcopy(&pc, evm.interpreter, &ScopeContext{mem, stack, nil, 0, nil, false}) want := common.FromHex(strings.ReplaceAll(tc.want, " ", "")) if have := mem.store; !bytes.Equal(want, have) { t.Errorf("case %d: \nwant: %#x\nhave: %#x\n", i, want, have) diff --git a/core/vm/interpreter.go b/core/vm/interpreter.go index 8b01c68139..ea08500de0 100644 --- a/core/vm/interpreter.go +++ b/core/vm/interpreter.go @@ -177,7 +177,7 @@ func NewEVMInterpreter(evm *EVM) *EVMInterpreter { } } evm.Config.ExtraEips = extraEips - return &EVMInterpreter{evm: evm, table: table, tableEOF: &pragueEOFInstructionSet} + return &EVMInterpreter{evm: evm, table: table, tableEOF: &eofInstructionSet} } // Run loops and evaluates the contract's code with the given input data and returns diff --git a/eth/tracers/js/tracer_test.go b/eth/tracers/js/tracer_test.go index 4c6f6590f0..e833572d1f 100644 --- a/eth/tracers/js/tracer_test.go +++ b/eth/tracers/js/tracer_test.go @@ -78,7 +78,7 @@ func runTrace(tracer *tracers.Tracer, vmctx *vmContext, chaincfg *params.ChainCo tracer.OnTxStart(evm.GetVMContext(), types.NewTx(&types.LegacyTx{Gas: gasLimit, GasPrice: vmctx.txCtx.GasPrice}), contract.Caller()) tracer.OnEnter(0, byte(vm.CALL), contract.Caller(), contract.Address(), []byte{}, startGas, value.ToBig()) - ret, err := env.Interpreter().Run(contract, []byte{}, false, false) + ret, err := evm.Interpreter().Run(contract, []byte{}, false, false) tracer.OnExit(0, ret, startGas-contract.Gas, err, true) // Rest gas assumes no refund tracer.OnTxEnd(&types.Receipt{GasUsed: gasLimit - contract.Gas}, nil) diff --git a/eth/tracers/logger/logger_test.go b/eth/tracers/logger/logger_test.go index fd58359239..a84c9dc89c 100644 --- a/eth/tracers/logger/logger_test.go +++ b/eth/tracers/logger/logger_test.go @@ -63,8 +63,8 @@ func TestStoreCapture(t *testing.T) { ) contract.Code = []byte{byte(vm.PUSH1), 0x1, byte(vm.PUSH1), 0x0, byte(vm.SSTORE)} var index common.Hash - logger.OnTxStart(env.GetVMContext(), nil, common.Address{}) - _, err := env.Interpreter().Run(contract, []byte{}, false, false) + logger.OnTxStart(evm.GetVMContext(), nil, common.Address{}) + _, err := evm.Interpreter().Run(contract, []byte{}, false, false) if err != nil { t.Fatal(err) } diff --git a/tests/state_test_util.go b/tests/state_test_util.go index 9483f40d41..e658b62ebf 100644 --- a/tests/state_test_util.go +++ b/tests/state_test_util.go @@ -319,15 +319,6 @@ func (t *StateTest) RunNoVerify(subtest StateSubtest, vmconfig vm.Config, snapsh if tracer := vmconfig.Tracer; tracer != nil && tracer.OnTxStart != nil { tracer.OnTxStart(evm.GetVMContext(), nil, msg.From) } - - oldContext := evm.TxContext - if config.IsPrague(new(big.Int), 0) { - for i := int(block.Number().Uint64() - 1); i >= 0; i-- { - core.ProcessParentBlockHash(vmTestBlockHash(uint64(i)), evm, st.StateDB) - } - } - evm.Reset(oldContext, st.StateDB) - // Execute the message. snapshot := st.StateDB.Snapshot() gaspool := new(core.GasPool)