feat: view and pure mutability limitations

Author: ARR4N

core/vm/contracts.libevm.go

@@ -143,12 +143,22 @@ type PrecompileEnvironment interface {
 	Rules() params.Rules
 	// StateDB will be non-nil i.f.f !ReadOnly().
 	StateDB() StateDB
-	// ReadOnlyState will always be non-nil.
+	// ReadOnlyState will be non-nil i.f.f. SetPure() has not been called.
 	ReadOnlyState() libevm.StateReader
 
+	// SetReadOnly ensures that all future calls to ReadOnly() will return true.
+	// Is can be used as a guard against accidental writes when a read-only
+	// function is invoked with EVM call() instead of staticcall().
+	SetReadOnly()
+	// SetPure ensures that all future calls to ReadOnly() will return true and
+	// that calls to ReadOnlyState() will return nil.
+	// TODO(arr4n) DO NOT MERGE: change this and SetReadOnly to return new
+	// environments.
+	SetPure()
+	ReadOnly() bool
+
 	IncomingCallType() CallType
 	Addresses() *libevm.AddressContext
-	ReadOnly() bool
 	// Equivalent to respective methods on [Contract].
 	Gas() uint64
 	UseGas(uint64) (hasEnoughGas bool)

core/vm/environment.libevm.go

@@ -33,21 +33,21 @@ import (
 var _ PrecompileEnvironment = (*environment)(nil)
 
 type environment struct {
-	evm      *EVM
-	self     *Contract
-	callType CallType
+	evm        *EVM
+	self       *Contract
+	callType   CallType
+	view, pure bool
 }
 
 func (e *environment) Gas() uint64            { return e.self.Gas }
 func (e *environment) UseGas(gas uint64) bool { return e.self.UseGas(gas) }
 func (e *environment) Value() *uint256.Int    { return new(uint256.Int).Set(e.self.Value()) }
 
-func (e *environment) ChainConfig() *params.ChainConfig  { return e.evm.chainConfig }
-func (e *environment) Rules() params.Rules               { return e.evm.chainRules }
-func (e *environment) ReadOnlyState() libevm.StateReader { return e.evm.StateDB }
-func (e *environment) IncomingCallType() CallType        { return e.callType }
-func (e *environment) BlockNumber() *big.Int             { return new(big.Int).Set(e.evm.Context.BlockNumber) }
-func (e *environment) BlockTime() uint64                 { return e.evm.Context.Time }
+func (e *environment) ChainConfig() *params.ChainConfig { return e.evm.chainConfig }
+func (e *environment) Rules() params.Rules              { return e.evm.chainRules }
+func (e *environment) IncomingCallType() CallType       { return e.callType }
+func (e *environment) BlockNumber() *big.Int            { return new(big.Int).Set(e.evm.Context.BlockNumber) }
+func (e *environment) BlockTime() uint64                { return e.evm.Context.Time }
 
 func (e *environment) refundGas(add uint64) error {
 	gas, overflow := math.SafeAdd(e.self.Gas, add)
@@ -58,6 +58,9 @@ func (e *environment) refundGas(add uint64) error {
 	return nil
 }
 
+func (e *environment) SetReadOnly() { e.view = true }
+func (e *environment) SetPure()     { e.pure = true }
+
 func (e *environment) ReadOnly() bool {
 	// A switch statement provides clearer code coverage for difficult-to-test
 	// cases.
@@ -69,17 +72,18 @@ func (e *environment) ReadOnly() bool {
 		return true
 	case e.evm.interpreter.readOnly:
 		return true
+	case e.view || e.pure:
+		return true
 	default:
 		return false
 	}
 }
 
-func (e *environment) Addresses() *libevm.AddressContext {
-	return &libevm.AddressContext{
-		Origin: e.evm.Origin,
-		Caller: e.self.CallerAddress,
-		Self:   e.self.Address(),
+func (e *environment) ReadOnlyState() libevm.StateReader {
+	if e.pure {
+		return nil
 	}
+	return e.evm.StateDB
 }
 
 func (e *environment) StateDB() StateDB {
@@ -89,6 +93,14 @@ func (e *environment) StateDB() StateDB {
 	return e.evm.StateDB
 }
 
+func (e *environment) Addresses() *libevm.AddressContext {
+	return &libevm.AddressContext{
+		Origin: e.evm.Origin,
+		Caller: e.self.CallerAddress,
+		Self:   e.self.Address(),
+	}
+}
+
 func (e *environment) BlockHeader() (types.Header, error) {
 	hdr := e.evm.Context.Header
 	if hdr == nil {

libevm/precompilegen/Test.sol

@@ -18,6 +18,12 @@ interface IPrecompile {
     function Self() external view returns (address);
 
     function RevertWith(bytes memory) external;
+
+    function View() external view returns (bool canReadState, bool canWriteState);
+
+    function Pure() external pure returns (bool canReadState, bool canWriteState);
+
+    function NeitherViewNorPure() external returns (bool canReadState, bool canWriteState);
 }
 
 /// @dev Testing contract to exercise the implementaiton of `IPrecompile`.
@@ -75,4 +81,30 @@ contract PrecompileTest {
 
         emit Called("EchoingFallback(...)");
     }
+
+    function assertReadOnly(bytes4 selector, bool expectCanReadState, bool expectCanWriteState) internal {
+        // We use a low-level call() here to ensure that the Solidity compiler
+        // doesn't issue a staticcall() to view/pure functions as this would
+        // hide our forcing of a read-only state.
+        (bool ok, bytes memory ret) = address(precompile).call(abi.encodeWithSelector(selector));
+        assert(ok);
+        (bool canReadState, bool canWriteState) = abi.decode(ret, (bool, bool));
+        assert(canReadState == expectCanReadState);
+        assert(canWriteState == expectCanWriteState);
+    }
+
+    function View() external {
+        assertReadOnly(IPrecompile.View.selector, true, false);
+        emit Called("View()");
+    }
+
+    function Pure() external {
+        assertReadOnly(IPrecompile.Pure.selector, false, false);
+        emit Called("Pure()");
+    }
+
+    function NeitherViewNorPure() external {
+        assertReadOnly(IPrecompile.NeitherViewNorPure.selector, true, true);
+        emit Called("NeitherViewNorPure()");
+    }
 }