interesting
/
go-ethereum
mirror of https://github.com/ethereum/go-ethereum.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

all: fix merging issues

This commit is contained in:
Marius van der Wijden 2025-02-04 10:20:10 +01:00
parent dbb4ef5d9f
commit 6fe254e378
7 changed files with 30 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
cmd/evm/internal/t8ntool/transition.go
View File

@ -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 {

2
core/vm/eof_instructions.go
View File

@ -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"

48
core/vm/instructions_test.go
View File

@ -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)

2
core/vm/interpreter.go
View File

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

2
eth/tracers/js/tracer_test.go
View File

@ -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)

4
eth/tracers/logger/logger_test.go
View File

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

9
tests/state_test_util.go
View File

@ -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)