update fork

x/evm/vm/geth/geth.go

@@ -0,0 +1,79 @@
+package geth
+
+import (
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/ethereum/go-ethereum/params"
+
+	evm "github.com/cerc-io/laconicd/x/evm/vm"
+)
+
+var (
+	_ evm.EVM         = (*EVM)(nil)
+	_ evm.Constructor = NewEVM
+)
+
+// EVM is the wrapper for the go-ethereum EVM.
+type EVM struct {
+	*vm.EVM
+}
+
+// NewEVM defines the constructor function for the go-ethereum (geth) EVM. It uses
+// the default precompiled contracts and the EVM concrete implementation from
+// geth.
+func NewEVM(
+	blockCtx vm.BlockContext,
+	txCtx vm.TxContext,
+	stateDB vm.StateDB,
+	chainConfig *params.ChainConfig,
+	config vm.Config,
+	_ evm.PrecompiledContracts, // unused
+) evm.EVM {
+	return &EVM{
+		EVM: vm.NewEVM(blockCtx, txCtx, stateDB, chainConfig, config),
+	}
+}
+
+// Context returns the EVM's Block Context
+func (e EVM) Context() vm.BlockContext {
+	return e.EVM.Context
+}
+
+// TxContext returns the EVM's Tx Context
+func (e EVM) TxContext() vm.TxContext {
+	return e.EVM.TxContext
+}
+
+// Config returns the configuration options for the EVM.
+func (e EVM) Config() vm.Config {
+	return e.EVM.Config
+}
+
+// Precompile returns the precompiled contract associated with the given address
+// and the current chain configuration. If the contract cannot be found it returns
+// nil.
+func (e EVM) Precompile(addr common.Address) (p vm.PrecompiledContract, found bool) {
+	precompiles := GetPrecompiles(e.ChainConfig(), e.EVM.Context.BlockNumber)
+	p, found = precompiles[addr]
+	return p, found
+}
+
+// ActivePrecompiles returns a list of all the active precompiled contract addresses
+// for the current chain configuration.
+func (EVM) ActivePrecompiles(rules params.Rules) []common.Address {
+	return vm.ActivePrecompiles(rules)
+}
+
+// RunPrecompiledContract runs a stateless precompiled contract and ignores the address and
+// value arguments. It uses the RunPrecompiledContract function from the geth vm package.
+func (EVM) RunPrecompiledContract(
+	p evm.StatefulPrecompiledContract,
+	_ common.Address, // address arg is unused
+	input []byte,
+	suppliedGas uint64,
+	_ *big.Int, // 	value arg is unused
+) (ret []byte, remainingGas uint64, err error) {
+	return vm.RunPrecompiledContract(p, input, suppliedGas)
+}

x/evm/vm/geth/precompiles.go

@@ -0,0 +1,27 @@
+package geth
+
+import (
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/ethereum/go-ethereum/params"
+
+	evm "github.com/cerc-io/laconicd/x/evm/vm"
+)
+
+// GetPrecompiles returns all the precompiled contracts defined given the
+// current chain configuration and block height.
+func GetPrecompiles(cfg *params.ChainConfig, blockNumber *big.Int) evm.PrecompiledContracts {
+	var precompiles evm.PrecompiledContracts
+	switch {
+	case cfg.IsBerlin(blockNumber):
+		precompiles = vm.PrecompiledContractsBerlin
+	case cfg.IsIstanbul(blockNumber):
+		precompiles = vm.PrecompiledContractsIstanbul
+	case cfg.IsByzantium(blockNumber):
+		precompiles = vm.PrecompiledContractsByzantium
+	default:
+		precompiles = vm.PrecompiledContractsHomestead
+	}
+	return precompiles
+}

x/evm/vm/interface.go

@@ -0,0 +1,66 @@
+package vm
+
+import (
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/ethereum/go-ethereum/params"
+	"github.com/holiman/uint256"
+)
+
+// PrecompiledContracts defines a map of address -> precompiled contract
+type PrecompiledContracts map[common.Address]vm.PrecompiledContract
+
+type StatefulPrecompiledContract interface {
+	vm.PrecompiledContract
+	RunStateful(evm EVM, addr common.Address, input []byte, value *big.Int) (ret []byte, err error)
+}
+
+// EVM defines the interface for the Ethereum Virtual Machine used by the EVM module.
+type EVM interface {
+	Config() vm.Config
+	Context() vm.BlockContext
+	TxContext() vm.TxContext
+
+	Reset(txCtx vm.TxContext, statedb vm.StateDB)
+	Cancel()
+	Cancelled() bool //nolint
+	Interpreter() *vm.EVMInterpreter
+	Call(caller vm.ContractRef, addr common.Address, input []byte, gas uint64, value *big.Int) (ret []byte, leftOverGas uint64, err error)
+	CallCode(caller vm.ContractRef, addr common.Address, input []byte, gas uint64, value *big.Int) (ret []byte, leftOverGas uint64, err error)
+	DelegateCall(caller vm.ContractRef, addr common.Address, input []byte, gas uint64) (ret []byte, leftOverGas uint64, err error)
+	StaticCall(caller vm.ContractRef, addr common.Address, input []byte, gas uint64) (ret []byte, leftOverGas uint64, err error)
+	Create(caller vm.ContractRef, code []byte, gas uint64, value *big.Int) (ret []byte, contractAddr common.Address, leftOverGas uint64, err error)
+	Create2(
+		caller vm.ContractRef,
+		code []byte,
+		gas uint64,
+		endowment *big.Int,
+		salt *uint256.Int) (
+		ret []byte, contractAddr common.Address, leftOverGas uint64, err error,
+	)
+	ChainConfig() *params.ChainConfig
+
+	ActivePrecompiles(rules params.Rules) []common.Address
+	Precompile(addr common.Address) (vm.PrecompiledContract, bool)
+	RunPrecompiledContract(
+		p StatefulPrecompiledContract,
+		addr common.Address,
+		input []byte,
+		suppliedGas uint64,
+		value *big.Int) (
+		ret []byte, remainingGas uint64, err error,
+	)
+}
+
+// Constructor defines the function used to instantiate the EVM on
+// each state transition.
+type Constructor func(
+	blockCtx vm.BlockContext,
+	txCtx vm.TxContext,
+	stateDB vm.StateDB,
+	chainConfig *params.ChainConfig,
+	config vm.Config,
+	customPrecompiles PrecompiledContracts,
+) EVM