new precompile function types

core/vm/evm.go

@@ -40,16 +40,14 @@ type (
 	GetHashFunc func(uint64) common.Hash
 )
 
-// `PrecompileRunner` is allows the EVM to execute a precompiled contract.
-type PrecompileRunner interface {
-	// `Exists` returns if a precompiled contract was found at `addr`.
-	Exists(addr common.Address) (PrecompiledContract, bool)
-
-	// `Run` runs a precompiled contract and returns the leftover gas.
-	Run(p PrecompiledContract, input []byte, caller common.Address,
-		value *big.Int, suppliedGas uint64, readonly bool,
-	) (ret []byte, remainingGas uint64, err error)
-}
+// `PrecompileExists` returns if a precompiled contract was found at `addr`.
+type PrecompileExists func(addr common.Address) (p PrecompiledContract, found bool)
+
+// `RunPrecompile` runs a precompiled contract and returns the remaining gas.
+type RunPrecompile func(
+	p PrecompiledContract, input []byte, caller common.Address,
+	value *big.Int, suppliedGas uint64, readonly bool,
+) (ret []byte, remainingGas uint64, err error)
 
 // BlockContext provides the EVM with auxiliary information. Once provided
 // it shouldn't be modified.
@@ -95,8 +93,11 @@ type EVM struct {
 	TxContext
 	// StateDB gives access to the underlying state
 	StateDB StateDB
-	// precompileRunner gives access to the precompiled contracts
-	precompileRunner PrecompileRunner
+	// precompileExists searches an address for a precompiled
+	// contract
+	precompileExists PrecompileExists
+	// runPrecompile gives access running a precompiled contract
+	runPrecompile RunPrecompile
 	// Depth is the current call stack
 	depth int
 
@@ -134,9 +135,13 @@ func NewEVM(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig
 	return evm
 }
 
-func NewEVMWithPrecompiles(blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig *params.ChainConfig, config Config, precompileRunner PrecompileRunner) *EVM {
+func NewEVMWithPrecompiles(
+	blockCtx BlockContext, txCtx TxContext, statedb StateDB, chainConfig *params.ChainConfig,
+	config Config, precompileExists PrecompileExists, runPrecompile RunPrecompile,
+) *EVM {
 	evm := NewEVM(blockCtx, txCtx, statedb, chainConfig, config)
-	evm.precompileRunner = precompileRunner
+	evm.precompileExists = precompileExists
+	evm.runPrecompile = runPrecompile
 	return evm
 }
 
@@ -185,7 +190,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas
 		return nil, gas, ErrInsufficientBalance
 	}
 	snapshot := evm.StateDB.Snapshot()
-	p, isPrecompile := evm.precompileRunner.Exists(addr)
+	p, isPrecompile := evm.precompileExists(addr)
 
 	if !evm.StateDB.Exist(addr) {
 		if !isPrecompile && evm.chainRules.IsEIP158 && value.Sign() == 0 {
@@ -222,7 +227,7 @@ func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas
 	}
 
 	if isPrecompile {
-		ret, gas, err = evm.precompileRunner.Run(p, input, caller.Address(), value, gas, false)
+		ret, gas, err = evm.runPrecompile(p, input, caller.Address(), value, gas, false)
 	} 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.
@@ -284,8 +289,8 @@ func (evm *EVM) CallCode(caller ContractRef, addr common.Address, input []byte,
 	}
 
 	// It is allowed to call precompiles, even via delegatecall
-	if p, isPrecompile := evm.precompileRunner.Exists(addr); isPrecompile {
-		ret, gas, err = evm.precompileRunner.Run(p, input, caller.Address(), value, gas, true)
+	if p, isPrecompile := evm.precompileExists(addr); isPrecompile {
+		ret, gas, err = evm.runPrecompile(p, input, caller.Address(), value, gas, true)
 	} else {
 		addrCopy := addr
 		// Initialise a new contract and set the code that is to be used by the EVM.
@@ -329,9 +334,9 @@ func (evm *EVM) DelegateCall(caller ContractRef, addr common.Address, input []by
 	}
 
 	// It is allowed to call precompiles, even via delegatecall
-	if p, isPrecompile := evm.precompileRunner.Exists(addr); isPrecompile {
+	if p, isPrecompile := evm.precompileExists(addr); isPrecompile {
 		parent := caller.(*Contract)
-		ret, gas, err = evm.precompileRunner.Run(p, input, parent.CallerAddress, parent.value, gas, false)
+		ret, gas, err = evm.runPrecompile(p, input, parent.CallerAddress, parent.value, gas, false)
 	} else {
 		addrCopy := addr
 		// Initialise a new contract and make initialise the delegate values
@@ -379,8 +384,8 @@ func (evm *EVM) StaticCall(caller ContractRef, addr common.Address, input []byte
 		}(gas)
 	}
 
-	if p, isPrecompile := evm.precompileRunner.Exists(addr); isPrecompile {
-		ret, gas, err = evm.precompileRunner.Run(p, input, caller.Address(), new(big.Int), gas, true)
+	if p, isPrecompile := evm.precompileExists(addr); isPrecompile {
+		ret, gas, err = evm.runPrecompile(p, input, caller.Address(), new(big.Int), gas, true)
 	} 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'