feat: integrate fhevm-go

Author: youben11

core/state_transition.go

@@ -27,6 +27,7 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/params"
+	"github.com/zama-ai/fhevm-go/fhevm"
 )
 
 // ExecutionResult includes all output after executing given evm
@@ -111,7 +112,7 @@ func IntrinsicGas(data []byte, accessList types.AccessList, isContractCreation b
 		gas += uint64(len(accessList)) * params.TxAccessListAddressGas
 		gas += uint64(accessList.StorageKeys()) * params.TxAccessListStorageKeyGas
 	}
-	return gas, nil
+	return fhevm.TxDataFractionalGas(gas), nil
 }
 
 // toWordSize returns the ceiled word size required for init code payment calculation.

core/vm/contracts.go

@@ -20,11 +20,14 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"math/big"
 	"os"
 	"testing"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/core/state"
 )
 
 // precompiledTest defines the input/output pairs for precompiled contract tests.
@@ -93,12 +96,44 @@ var blake2FMalformedInputTests = []precompiledFailureTest{
 	},
 }
 
+type statefulPrecompileAccessibleState struct {
+	interpreter *EVMInterpreter
+}
+
+func (s *statefulPrecompileAccessibleState) Interpreter() *EVMInterpreter {
+	return s.interpreter
+}
+
+// FIXME: create it correctly
+func newTestInterpreter() *EVMInterpreter {
+	// cfg := Config{IsGasEstimation: false}
+	evm := &EVM{}
+	evm.Context = BlockContext{}
+	evm.Context.Transfer = func(StateDB, common.Address, common.Address, *big.Int) {}
+	evm.Context.CanTransfer = func(StateDB, common.Address, *big.Int) bool { return true }
+	interpreter := NewEVMInterpreter(evm)
+	evm.interpreter = interpreter
+	db := rawdb.NewMemoryDatabase()
+	state, _ := state.New(common.Hash{}, state.NewDatabase(db), nil)
+	interpreter.evm.StateDB = state
+	return interpreter
+}
+
+func newTestState() *statefulPrecompileAccessibleState {
+	s := new(statefulPrecompileAccessibleState)
+	interpreter := newTestInterpreter()
+	s.interpreter = interpreter
+	return s
+}
+
 func testPrecompiled(addr string, test precompiledTest, t *testing.T) {
 	p := allPrecompiles[common.HexToAddress(addr)]
 	in := common.Hex2Bytes(test.Input)
-	gas := p.RequiredGas(in)
+	state := newTestState()
+	state.interpreter.readOnly = false
+	gas := p.RequiredGas(state, in)
 	t.Run(fmt.Sprintf("%s-Gas=%d", test.Name, gas), func(t *testing.T) {
-		if res, _, err := RunPrecompiledContract(p, in, gas); err != nil {
+		if res, _, err := RunPrecompiledContract(p, state, common.HexToAddress(addr), common.HexToAddress(addr), in, gas); err != nil {
 			t.Error(err)
 		} else if common.Bytes2Hex(res) != test.Expected {
 			t.Errorf("Expected %v, got %v", test.Expected, common.Bytes2Hex(res))
@@ -117,10 +152,12 @@ func testPrecompiled(addr string, test precompiledTest, t *testing.T) {
 func testPrecompiledOOG(addr string, test precompiledTest, t *testing.T) {
 	p := allPrecompiles[common.HexToAddress(addr)]
 	in := common.Hex2Bytes(test.Input)
-	gas := p.RequiredGas(in) - 1
+	state := newTestState()
+	state.interpreter.readOnly = false
+	gas := p.RequiredGas(state, in) - 1
 
 	t.Run(fmt.Sprintf("%s-Gas=%d", test.Name, gas), func(t *testing.T) {
-		_, _, err := RunPrecompiledContract(p, in, gas)
+		_, _, err := RunPrecompiledContract(p, state, common.HexToAddress(addr), common.HexToAddress(addr), in, gas)
 		if err.Error() != "out of gas" {
 			t.Errorf("Expected error [out of gas], got [%v]", err)
 		}
@@ -135,9 +172,11 @@ func testPrecompiledOOG(addr string, test precompiledTest, t *testing.T) {
 func testPrecompiledFailure(addr string, test precompiledFailureTest, t *testing.T) {
 	p := allPrecompiles[common.HexToAddress(addr)]
 	in := common.Hex2Bytes(test.Input)
-	gas := p.RequiredGas(in)
+	state := newTestState()
+	state.interpreter.readOnly = false
+	gas := p.RequiredGas(state, in)
 	t.Run(test.Name, func(t *testing.T) {
-		_, _, err := RunPrecompiledContract(p, in, gas)
+		_, _, err := RunPrecompiledContract(p, state, common.HexToAddress(addr), common.HexToAddress(addr), in, gas)
 		if err.Error() != test.ExpectedError {
 			t.Errorf("Expected error [%v], got [%v]", test.ExpectedError, err)
 		}
@@ -155,7 +194,9 @@ func benchmarkPrecompiled(addr string, test precompiledTest, bench *testing.B) {
 	}
 	p := allPrecompiles[common.HexToAddress(addr)]
 	in := common.Hex2Bytes(test.Input)
-	reqGas := p.RequiredGas(in)
+	state := newTestState()
+	state.interpreter.readOnly = false
+	reqGas := p.RequiredGas(state, in)
 
 	var (
 		res  []byte
@@ -169,7 +210,7 @@ func benchmarkPrecompiled(addr string, test precompiledTest, bench *testing.B) {
 		bench.ResetTimer()
 		for i := 0; i < bench.N; i++ {
 			copy(data, in)
-			res, _, err = RunPrecompiledContract(p, data, reqGas)
+			res, _, err = RunPrecompiledContract(p, state, common.HexToAddress(addr), common.HexToAddress(addr), data, reqGas)
 		}
 		bench.StopTimer()
 		elapsed := uint64(time.Since(start))

core/vm/contracts_test.go

@@ -19,6 +19,8 @@ package vm
 import (
 	"errors"
 	"fmt"
+
+	"github.com/zama-ai/fhevm-go/fhevm"
 )
 
 // List evm execution errors
@@ -43,6 +45,13 @@ var (
 	errStopToken = errors.New("stop token")
 )
 
+func init() {
+	fhevm.RegisterErrors(ErrOutOfGas, ErrCodeStoreOutOfGas, ErrDepth, ErrInsufficientBalance,
+		ErrContractAddressCollision, ErrExecutionReverted, ErrMaxInitCodeSizeExceeded, ErrMaxCodeSizeExceeded,
+		ErrInvalidJump, ErrWriteProtection, ErrReturnDataOutOfBounds, ErrGasUintOverflow, ErrInvalidCode,
+		ErrNonceUintOverflow, nil, nil, nil)
+}
+
 // ErrStackUnderflow wraps an evm error when the items on the stack less
 // than the minimal requirement.
 type ErrStackUnderflow struct {

core/vm/errors.go

@@ -25,6 +25,7 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/holiman/uint256"
+	"github.com/zama-ai/fhevm-go/fhevm"
 )
 
 type (
@@ -120,7 +121,17 @@ type EVM struct {
 	// callGasTemp holds the gas available for the current call. This is needed because the
 	// available gas is calculated in gasCall* according to the 63/64 rule and later
 	// applied in opCall*.
-	callGasTemp uint64
+	callGasTemp      uint64
+	fhevmEnvironment FhevmImplementation
+	isGasEstimation  bool
+	isEthCall        bool
+}
+
+type FhevmImplementation struct {
+	interpreter *EVMInterpreter
+	data        fhevm.FhevmData
+	logger      fhevm.Logger
+	params      fhevm.FhevmParams
 }
 
 // NewEVM returns a new EVM. The returned EVM is not thread safe and should
@@ -138,14 +149,19 @@ func NewEVM(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig
 		}
 	}
 	evm := &EVM{
-		Context:     blockCtx,
-		TxContext:   txCtx,
-		StateDB:     statedb,
-		Config:      config,
-		chainConfig: chainConfig,
-		chainRules:  chainConfig.Rules(blockCtx.BlockNumber, blockCtx.Random != nil, blockCtx.Time),
+		Context:          blockCtx,
+		TxContext:        txCtx,
+		StateDB:          statedb,
+		Config:           config,
+		chainConfig:      chainConfig,
+		chainRules:       chainConfig.Rules(blockCtx.BlockNumber, blockCtx.Random != nil, blockCtx.Time),
+		fhevmEnvironment: FhevmImplementation{interpreter: nil, logger: &fhevm.DefaultLogger{}, data: fhevm.NewFhevmData(), params: fhevm.DefaultFhevmParams()},
+		isGasEstimation:  config.IsGasEstimation,
+		isEthCall:        config.IsEthCall,
 	}
 	evm.interpreter = NewEVMInterpreter(evm)
+	evm.fhevmEnvironment.interpreter = evm.interpreter
+	fhevm.InitFhevm(&evm.fhevmEnvironment)
 	return evm
 }
 
@@ -224,7 +240,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas
 	}
 
 	if isPrecompile {
-		ret, gas, err = RunPrecompiledContract(p, input, gas)
+		ret, gas, err = RunPrecompiledContract(p, evm, caller.Address(), addr, input, gas)
 	} else {
 		// Initialise a new contract and set the code that is to be used by the EVM.
 		// The contract is a scoped environment for this execution context only.
@@ -287,7 +303,7 @@ func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte,
 
 	// It is allowed to call precompiles, even via delegatecall
 	if p, isPrecompile := evm.precompile(addr); isPrecompile {
-		ret, gas, err = RunPrecompiledContract(p, input, gas)
+		ret, gas, err = RunPrecompiledContract(p, evm, caller.Address(), addr, input, gas)
 	} else {
 		addrCopy := addr
 		// Initialise a new contract and set the code that is to be used by the EVM.
@@ -332,7 +348,7 @@ func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []by
 
 	// It is allowed to call precompiles, even via delegatecall
 	if p, isPrecompile := evm.precompile(addr); isPrecompile {
-		ret, gas, err = RunPrecompiledContract(p, input, gas)
+		ret, gas, err = RunPrecompiledContract(p, evm, caller.Address(), addr, input, gas)
 	} else {
 		addrCopy := addr
 		// Initialise a new contract and make initialise the delegate values
@@ -381,7 +397,7 @@ func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte
 	}
 
 	if p, isPrecompile := evm.precompile(addr); isPrecompile {
-		ret, gas, err = RunPrecompiledContract(p, input, gas)
+		ret, gas, err = RunPrecompiledContract(p, evm, caller.Address(), addr, input, gas)
 	} else {
 		// At this point, we use a copy of address. If we don't, the go compiler will
 		// leak the 'contract' to the outer scope, and make allocation for 'contract'
@@ -511,19 +527,80 @@ func (evm *EVM) create(caller ContractRef, codeAndHash *codeAndHash, gas uint64,
 
 // Create creates a new contract using code as deployment code.
 func (evm *EVM) Create(caller ContractRef, code []byte, gas uint64, value *big.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error) {
-	contractAddr = crypto.CreateAddress(caller.Address(), evm.StateDB.GetNonce(caller.Address()))
-	return evm.create(caller, &codeAndHash{code: code}, gas, value, contractAddr, CREATE)
+	return fhevm.Create(evm.FhevmEnvironment(), caller.Address(), code, gas, value)
 }
 
 // Create2 creates a new contract using code as deployment code.
 //
 // The different between Create2 with Create is Create2 uses keccak256(0xff ++ msg.sender ++ salt ++ keccak256(init_code))[12:]
 // instead of the usual sender-and-nonce-hash as the address where the contract is initialized at.
 func (evm *EVM) Create2(caller ContractRef, code []byte, gas uint64, endowment *big.Int, salt *uint256.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error) {
-	codeAndHash := &codeAndHash{code: code}
-	contractAddr = crypto.CreateAddress2(caller.Address(), salt.Bytes32(), codeAndHash.Hash().Bytes())
-	return evm.create(caller, codeAndHash, gas, endowment, contractAddr, CREATE2)
+	return fhevm.Create2(evm.FhevmEnvironment(), caller.Address(), code, gas, endowment, salt)
 }
 
 // ChainConfig returns the environment's chain configuration
 func (evm *EVM) ChainConfig() *params.ChainConfig { return evm.chainConfig }
+
+func (evm *EVM) FhevmEnvironment() fhevm.EVMEnvironment { return &evm.fhevmEnvironment }
+
+func (evm *FhevmImplementation) GetState(addr common.Address, hash common.Hash) common.Hash {
+	return evm.interpreter.evm.StateDB.GetState(addr, hash)
+}
+
+func (evm *FhevmImplementation) SetState(addr common.Address, hash common.Hash, input common.Hash) {
+	evm.interpreter.evm.StateDB.SetState(addr, hash, input)
+}
+
+func (evm *FhevmImplementation) GetNonce(addr common.Address) uint64 {
+	return evm.interpreter.evm.StateDB.GetNonce(addr)
+}
+
+func (evm *FhevmImplementation) AddBalance(addr common.Address, value *big.Int) {
+	evm.interpreter.evm.StateDB.AddBalance(addr, value)
+}
+
+func (evm *FhevmImplementation) GetBalance(addr common.Address) *big.Int {
+	return evm.interpreter.evm.StateDB.GetBalance(addr)
+}
+
+// FIXME: Maybe change the interface to SelfDestruct (new version of geth)
+func (evm *FhevmImplementation) Suicide(addr common.Address) bool {
+	evm.interpreter.evm.StateDB.SelfDestruct(addr)
+	return evm.interpreter.evm.StateDB.HasSelfDestructed(addr)
+}
+
+func (evm *FhevmImplementation) GetDepth() int {
+	return evm.interpreter.evm.depth
+}
+
+func (evm *FhevmImplementation) IsCommitting() bool {
+	return !evm.interpreter.evm.isGasEstimation
+}
+
+func (evm *FhevmImplementation) IsEthCall() bool {
+	return evm.interpreter.evm.isEthCall
+}
+
+func (evm *FhevmImplementation) IsReadOnly() bool {
+	return evm.interpreter.readOnly
+}
+
+func (evm *FhevmImplementation) GetLogger() fhevm.Logger {
+	return evm.logger
+}
+
+func (evm *FhevmImplementation) FhevmData() *fhevm.FhevmData {
+	return &evm.data
+}
+
+func (evm *FhevmImplementation) FhevmParams() *fhevm.FhevmParams {
+	return &evm.params
+}
+
+func (evm *FhevmImplementation) CreateContract(caller common.Address, code []byte, gas uint64, value *big.Int, address common.Address) ([]byte, common.Address, uint64, error) {
+	return evm.interpreter.evm.create(AccountRef(caller), &codeAndHash{code: code}, gas, value, address, CREATE)
+}
+
+func (evm *FhevmImplementation) CreateContract2(caller common.Address, code []byte, codeHash common.Hash, gas uint64, value *big.Int, address common.Address) ([]byte, common.Address, uint64, error) {
+	return evm.interpreter.evm.create(AccountRef(caller), &codeAndHash{code: code, hash: codeHash}, gas, value, address, CREATE2)
+}