[WIP] evmc VM

giga/executor/vm/evmc/host_context.go

@@ -0,0 +1,208 @@
+package evmc
+
+import (
+	"github.com/ethereum/evmc/v12/bindings/go/evmc"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/tracing"
+	ethtypes "github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/core/vm"
+)
+
+var _ evmc.HostContext = (*HostContext)(nil)
+
+type HostContext struct {
+	vm  *evmc.VM
+	evm *vm.EVM
+}
+
+func NewHostContext(vm *evmc.VM, evm *vm.EVM) *HostContext {
+	return &HostContext{vm: vm, evm: evm}
+}
+
+func (h *HostContext) AccountExists(addr evmc.Address) bool {
+	return h.evm.StateDB.Exist(common.Address(addr))
+}
+
+func (h *HostContext) GetStorage(addr evmc.Address, key evmc.Hash) evmc.Hash {
+	return evmc.Hash(h.evm.StateDB.GetState(common.Address(addr), common.Hash(key)))
+}
+
+func (h *HostContext) SetStorage(addr evmc.Address, key evmc.Hash, value evmc.Hash) evmc.StorageStatus {
+	gethAddr := common.Address(addr)
+	gethKey := common.Hash(key)
+
+	current := h.evm.StateDB.GetState(gethAddr, gethKey)
+	original := h.evm.StateDB.GetCommittedState(gethAddr, gethKey)
+
+	dirty := original.Cmp(current) != 0
+	restored := original.Cmp(common.Hash(value)) == 0
+	currentIsZero := current.Cmp(common.Hash{}) == 0
+	valueIsZero := common.Hash(value).Cmp(common.Hash{}) == 0
+
+	status := evmc.StorageAssigned
+	if !dirty && !restored {
+		if currentIsZero {
+			status = evmc.StorageAdded
+		} else if valueIsZero {
+			status = evmc.StorageDeleted
+		} else {
+			status = evmc.StorageModified
+		}
+	} else if dirty && !restored {
+		if currentIsZero && valueIsZero {
+			status = evmc.StorageDeletedAdded
+		} else if !currentIsZero && valueIsZero {
+			status = evmc.StorageModifiedDeleted
+		}
+	} else if dirty {
+		if currentIsZero {
+			status = evmc.StorageDeletedRestored
+		} else if valueIsZero {
+			status = evmc.StorageAddedDeleted
+		} else {
+			status = evmc.StorageModifiedRestored
+		}
+	}
+
+	h.evm.StateDB.SetState(gethAddr, gethKey, common.Hash(value))
+	return status
+}
+
+func (h *HostContext) GetBalance(addr evmc.Address) evmc.Hash {
+	return h.evm.StateDB.GetBalance(common.Address(addr)).Bytes32()
+}
+
+func (h *HostContext) GetCodeSize(addr evmc.Address) int {
+	return h.evm.StateDB.GetCodeSize(common.Address(addr))
+}
+
+func (h *HostContext) GetCodeHash(addr evmc.Address) evmc.Hash {
+	return evmc.Hash(h.evm.StateDB.GetCodeHash(common.Address(addr)))
+}
+
+func (h *HostContext) GetCode(addr evmc.Address) []byte {
+	return h.evm.StateDB.GetCode(common.Address(addr))
+}
+
+// todo(pdrobnjak): support historical selfdestruct logic as well
+func (h *HostContext) Selfdestruct(addr evmc.Address, beneficiary evmc.Address) bool {
+	addrKey := common.Address(addr)
+	beneficiaryKey := common.Address(beneficiary)
+	amt := h.evm.StateDB.GetBalance(addrKey)
+	h.evm.StateDB.SubBalance(addrKey, amt, tracing.BalanceDecreaseSelfdestruct)
+	h.evm.StateDB.AddBalance(beneficiaryKey, amt, tracing.BalanceIncreaseSelfdestruct)
+	h.evm.StateDB.SelfDestruct6780(common.Address(addr))
+	return true
+}
+
+func (h *HostContext) GetTxContext() evmc.TxContext {
+	var gasPrice evmc.Hash
+	h.evm.TxContext.GasPrice.FillBytes(gasPrice[:])
+
+	var prevRandao evmc.Hash
+	if h.evm.Context.Random != nil {
+		prevRandao = evmc.Hash(*h.evm.Context.Random)
+	}
+
+	var chainID evmc.Hash
+	h.evm.ChainConfig().ChainID.FillBytes(chainID[:])
+
+	var baseFee evmc.Hash
+	h.evm.Context.BaseFee.FillBytes(baseFee[:])
+
+	var blobBaseFee evmc.Hash
+	h.evm.Context.BlobBaseFee.FillBytes(blobBaseFee[:])
+
+	return evmc.TxContext{
+		GasPrice:    gasPrice,
+		Origin:      evmc.Address(h.evm.TxContext.Origin),
+		Coinbase:    evmc.Address(h.evm.Context.Coinbase),
+		Number:      h.evm.Context.BlockNumber.Int64(),
+		Timestamp:   int64(h.evm.Context.Time),
+		GasLimit:    int64(h.evm.Context.GasLimit),
+		PrevRandao:  prevRandao,
+		ChainID:     chainID,
+		BaseFee:     baseFee,
+		BlobBaseFee: blobBaseFee,
+	}
+}
+
+func (h *HostContext) GetBlockHash(number int64) evmc.Hash {
+	return evmc.Hash(h.evm.Context.GetHash(uint64(number)))
+}
+
+func (h *HostContext) EmitLog(addr evmc.Address, topics []evmc.Hash, data []byte) {
+	gethTopics := make([]common.Hash, len(topics))
+	for i, topic := range topics {
+		gethTopics[i] = common.Hash(topic)
+	}
+	h.evm.StateDB.AddLog(&ethtypes.Log{Address: common.Address(addr), Topics: gethTopics, Data: data})
+}
+
+// todo(pdrobnjak): figure out how to populate - evmRevision, delegated, code - probably can be passed down from interpreter
+// this will sometimes be called throught interpreter.Run (top level) and sometimes from evmc_execute (child calls)
+// which means that sometimes it should delegate to the interpreter and sometimes it should call evm.Call/evm.DelegateCall/...
+// we are getting a Frankestein of geth + evmc + evmone
+// can this be routed through depth? noup, but we can set an internal flag in HostContext when calling through interpreter.Run
+// host HostContext needs to contain the EVM
+func (h *HostContext) Call(
+	kind evmc.CallKind, recipient evmc.Address, sender evmc.Address, value evmc.Hash, input []byte, gas int64,
+	depth int, static bool, salt evmc.Hash, codeAddress evmc.Address,
+) ([]byte, int64, int64, evmc.Address, error) {
+	// evmc -> opdelegatecall -> HostContext.Call (here we should route ) -> evm.DelegateCall -> intepreter.Run -> HostContext.Call
+	flag := true
+	if flag {
+		switch kind {
+		case evmc.Call:
+			ret, leftoverGas, err := h.evm.Call(caller, addr, input, gas, value)
+		case evmc.DelegateCall:
+			ret, leftoverGas, err := h.evm.DelegateCall(originCaller, caller, addr, input, gas, value)
+		case evmc.CallCode:
+			ret, leftoverGas, err := h.evm.CallCode(caller, addr, input, gas, value)
+		case evmc.Create:
+			ret, createAddr, leftoverGas, err := h.evm.Create(caller, code, gas, value)
+		case evmc.Create2:
+			ret, createAddr, leftoverGas, err := h.evm.Create2(caller, code, gas, endowment, salt)
+		}
+	}
+	// ELSE
+	evmRevision := evmc.Frontier
+	delegated := false
+	var code []byte
+	executionResult, err := h.vm.Execute(
+		h, evmRevision, kind, static, delegated, depth,
+		gas, recipient, sender, input, value, code,
+	)
+	if err != nil {
+		return nil, 0, 0, [20]byte{}, err
+	}
+
+	//todo(pdrobnjak): figure out how to populate createAddr
+	return executionResult.Output, executionResult.GasLeft, executionResult.GasRefund, evmc.Address{}, nil
+}
+
+func (h *HostContext) AccessAccount(addr evmc.Address) evmc.AccessStatus {
+	addrInAccessList := h.evm.StateDB.AddressInAccessList(common.Address(addr))
+	if addrInAccessList {
+		return evmc.WarmAccess
+	}
+	// todo(pdrobnjak): poll something similar to - https://github.com/sei-protocol/sei-v3/blob/cd50388d4d423501b15a544612643073680aa8de/execute/store/types/types.go#L23 - temporarily we can expose access via our statedb impl for testing
+	return evmc.ColdAccess
+}
+
+func (h *HostContext) AccessStorage(addr evmc.Address, key evmc.Hash) evmc.AccessStatus {
+	addrInAccessList, slotInAccessList := h.evm.StateDB.SlotInAccessList(common.Address(addr), common.Hash(key))
+	if addrInAccessList && slotInAccessList {
+		return evmc.WarmAccess
+	}
+	// todo(pdrobnjak): poll something similar to - https://github.com/sei-protocol/sei-v3/blob/cd50388d4d423501b15a544612643073680aa8de/execute/store/types/types.go#L22 - temporarily we can expose access via our statedb impl for testing
+	return evmc.ColdAccess
+}
+
+func (h *HostContext) GetTransientStorage(addr evmc.Address, key evmc.Hash) evmc.Hash {
+	return evmc.Hash(h.evm.StateDB.GetTransientState(common.Address(addr), common.Hash(key)))
+}
+
+func (h *HostContext) SetTransientStorage(addr evmc.Address, key evmc.Hash, value evmc.Hash) {
+	h.evm.StateDB.SetTransientState(common.Address(addr), common.Hash(key), common.Hash(value))
+}

giga/executor/vm/evmc/interpreter.go

@@ -0,0 +1,54 @@
+package evmc
+
+import (
+	"github.com/ethereum/evmc/v12/bindings/go/evmc"
+	"github.com/ethereum/go-ethereum/core/vm"
+)
+
+var _ vm.IEVMInterpreter = (*EVMInterpreter)(nil)
+
+type EVMInterpreter struct {
+	hostContext evmc.HostContext
+	evm         *vm.EVM
+	readOnly    bool
+}
+
+func NewEVMInterpreter(hostContext evmc.HostContext, evm *vm.EVM) *EVMInterpreter {
+	return &EVMInterpreter{hostContext: hostContext, evm: evm}
+}
+
+func (e *EVMInterpreter) Run(contract *vm.Contract, input []byte, readOnly bool) ([]byte, error) {
+	// todo(pdrobnjak): figure out if there is a way to avoid this, probably not, I'll have to replicate every interpreter side effect
+	// PASTED FROM GETH
+	// Increment the call depth which is restricted to 1024
+	e.evm.depth++
+	defer func() { e.evm.depth-- }()
+
+	// Make sure the readOnly is only set if we aren't in readOnly yet.
+	// This also makes sure that the readOnly flag isn't removed for child calls.
+	if readOnly && !e.readOnly {
+		e.readOnly = true
+		defer func() { e.readOnly = false }()
+	}
+	// PASTED FROM GETH
+
+	// todo(pdrobnjak): figure out how to access these values and how to validate if they are populated correctly
+	callKind := evmc.Call
+	recipient := evmc.Address{}
+	sender := evmc.Address{}
+	static := false
+	// irrelevant as it is only used for CREATE2 - geth is handling our CREATE2 logic
+	salt := evmc.Hash{}
+	codeAddress := evmc.Address{}
+	output, _, _, _, err := e.hostContext.Call(callKind, recipient, sender, contract.Value().Bytes32(), input,
+		int64(contract.Gas), e.evm.GetDepth(), static, salt, codeAddress)
+	if err != nil {
+		return nil, err
+	}
+
+	return output, nil
+}
+
+func (e *EVMInterpreter) ReadOnly() bool {
+	return e.readOnly
+}

giga/executor/vm/evmc/vm.go

@@ -1,32 +1,28 @@
 package evmc
 
 import (
-	"math"
-
-	"github.com/ethereum/evmc/v12/bindings/go/evmc"
-	"github.com/sei-protocol/sei-chain/giga/executor/types"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core"
+	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/ethereum/go-ethereum/params"
 )
 
 type VMImpl struct {
-	hostContext evmc.HostContext
-}
-
-func NewVM(hostContext evmc.HostContext) types.VM {
-	return &VMImpl{hostContext: hostContext}
+	evm *vm.EVM
 }
 
-func (v *VMImpl) Create(sender types.Address, code []byte, gas uint64, value types.Hash) (ret []byte, contractAddr types.Address, gasLeft uint64, err error) {
-	if gas > math.MaxInt64 {
-		panic("gas overflow")
+// this should bootstrap evmone - receive a configuration or something similar, we can do it the same way we did in v3
+func NewVM(blockCtx vm.BlockContext, stateDB vm.StateDB, chainConfig *params.ChainConfig, config vm.Config, customPrecompiles map[common.Address]vm.PrecompiledContract) *VMImpl {
+	evm := vm.NewEVM(blockCtx, stateDB, chainConfig, config, customPrecompiles)
+	// todo(pdrobnjak): populate evmc.VM
+	hostContext := NewHostContext(nil, evm)
+	evm.EVMInterpreter = NewEVMInterpreter(hostContext, evm)
+	return &VMImpl{
+		evm: evm,
 	}
-	ret, left, _, addr, err := v.hostContext.Call(evmc.Create, evmc.Address{}, evmc.Address(sender), evmc.Hash(value), code, int64(gas), 0, false, evmc.Hash{}, evmc.Address{})
-	return ret, types.Address(addr), uint64(left), err //nolint:gosec
 }
 
-func (v *VMImpl) Call(sender types.Address, to types.Address, input []byte, gas uint64, value types.Hash) (ret []byte, gasLeft uint64, err error) {
-	if gas > math.MaxInt64 {
-		panic("gas overflow")
-	}
-	ret, left, _, _, err := v.hostContext.Call(evmc.Call, evmc.Address(to), evmc.Address(sender), evmc.Hash(value), input, int64(gas), 0, false, evmc.Hash{}, evmc.Address(to))
-	return ret, uint64(left), err //nolint:gosec
+func (v *VMImpl) ApplyMessage(msg *core.Message, gp *core.GasPool) (*core.ExecutionResult, error) {
+	executionResult, err := core.ApplyMessage(v.evm, msg, gp)
+	return executionResult, err
 }

go.mod

@@ -352,7 +352,7 @@ replace (
 	github.com/btcsuite/btcd => github.com/btcsuite/btcd v0.23.2
 	github.com/confio/ics23/go => github.com/cosmos/cosmos-sdk/ics23/go v0.8.0
 	github.com/cosmos/cosmos-sdk => ./sei-cosmos
-	github.com/ethereum/go-ethereum => github.com/sei-protocol/go-ethereum v1.15.7-sei-7.0.20250929182230-93350978bb7c
+	github.com/ethereum/go-ethereum => ../go-ethereum
 	github.com/gogo/protobuf => github.com/regen-network/protobuf v1.3.3-alpha.regen.1
 	// Latest goleveldb is broken, we have to stick to this version
 	github.com/syndtr/goleveldb => github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7

go.sum

@@ -1921,8 +1921,6 @@ github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg
 github.com/securego/gosec/v2 v2.13.1 h1:7mU32qn2dyC81MH9L2kefnQyRMUarfDER3iQyMHcjYM=
 github.com/securego/gosec/v2 v2.13.1/go.mod h1:EO1sImBMBWFjOTFzMWfTRrZW6M15gm60ljzrmy/wtHo=
 github.com/segmentio/fasthash v1.0.3/go.mod h1:waKX8l2N8yckOgmSsXJi7x1ZfdKZ4x7KRMzBtS3oedY=
-github.com/sei-protocol/go-ethereum v1.15.7-sei-7.0.20250929182230-93350978bb7c h1:p3Q8KgwlYEZW5Iyr/X6RJ63cezc+GG3tVQ3BCnfxEgo=
-github.com/sei-protocol/go-ethereum v1.15.7-sei-7.0.20250929182230-93350978bb7c/go.mod h1:+S9k+jFzlyVTNcYGvqFhzN/SFhI6vA+aOY4T5tLSPL0=
 github.com/sei-protocol/goutils v0.0.2 h1:Bfa7Sv+4CVLNM20QcpvGb81B8C5HkQC/kW1CQpIbXDA=
 github.com/sei-protocol/goutils v0.0.2/go.mod h1:iYE2DuJfEnM+APPehr2gOUXfuLuPsVxorcDO+Tzq9q8=
 github.com/sei-protocol/sei-load v0.0.0-20251007135253-78fbdc141082 h1:f2sY8OcN60UL1/6POx+HDMZ4w04FTZtSScnrFSnGZHg=

go.work

@@ -5,3 +5,5 @@ use (
 	./sei-cosmos
 	./sei-tendermint
 )
+
+replace github.com/ethereum/go-ethereum => ../go-ethereum