test: PrecompileEnvironment mutability limitation

Author: ARR4N

core/vm/contracts.libevm.go

@@ -92,13 +92,13 @@ func (t CallType) OpCode() OpCode {
 type StateMutability uint
 
 const (
-	unknownStateMutability StateMutability = iota
-	MutableState
-	// ReadOnlyState is equivalent to Solidity's "view".
-	ReadOnlyState
 	// Pure is a Solidity concept disallowing all access, read or write, to
 	// state.
-	Pure
+	Pure StateMutability = iota + 1
+	// ReadOnlyState is equivalent to Solidity's "view".
+	ReadOnlyState
+	// MutableState can be both read from and written to.
+	MutableState
 )
 
 // String returns a human-readable representation of the StateMutability.
@@ -177,9 +177,10 @@ type PrecompileEnvironment interface {
 	// context, but [Pure] is a Solidity concept that is enforced by user code.
 	StateMutability() StateMutability
 	// AsReadOnly returns a copy of the current environment for which
-	// StateMutability() returns [ReadOnlyState]. It can be used as a guard
-	// against accidental writes when a read-only function is invoked with EVM
-	// call() instead of staticcall().
+	// StateMutability() is at most [ReadOnlyState]; i.e. if mutability is
+	// already limited to [Pure], AsReadOnly() will not expand access. It can be
+	// used as a guard against accidental writes when a read-only function is
+	// invoked with EVM call() instead of staticcall().
 	AsReadOnly() PrecompileEnvironment
 	// AsPure returns a copy of the current environment that has no access to
 	// state; i.e. StateMutability() returns [Pure]. All calls to both StateDB()

core/vm/contracts.libevm_test.go

@@ -149,9 +149,6 @@ func TestNewStatefulPrecompile(t *testing.T) {
 	gasCost := rng.Uint64n(gasLimit)
 
 	run := func(env vm.PrecompileEnvironment, input []byte, suppliedGas uint64) ([]byte, uint64, error) {
-		if got, want := env.StateDB() != nil, env.StateMutability() == vm.MutableState; got != want {
-			return nil, 0, fmt.Errorf("PrecompileEnvironment().StateDB() must be non-nil i.f.f. state is mutable; got non-nil? %t; want %t", got, want)
-		}
 		hdr, err := env.BlockHeader()
 		if err != nil {
 			return nil, 0, err
@@ -770,3 +767,75 @@ func ExamplePrecompileEnvironment() {
 	// variable to include it in this example function.
 	_ = actualCaller
 }
+
+func TestStateMutability(t *testing.T) {
+	rng := ethtest.NewPseudoRand(0)
+	precompile := rng.Address()
+	chainID := rng.BigUint64()
+
+	const precompileReturn = "precompile executed"
+	hooks := &hookstest.Stub{
+		PrecompileOverrides: map[common.Address]libevm.PrecompiledContract{
+			precompile: vm.NewStatefulPrecompile(func(env vm.PrecompileEnvironment, input []byte) (ret []byte, err error) {
+
+				tests := []struct {
+					name string
+					env  vm.PrecompileEnvironment
+					want vm.StateMutability
+				}{
+					{
+						name: "incoming argument",
+						env:  env,
+						want: vm.MutableState,
+					},
+					{
+						name: "AsReadOnly()",
+						env:  env.AsReadOnly(),
+						want: vm.ReadOnlyState,
+					},
+					{
+						name: "AsPure()",
+						env:  env.AsPure(),
+						want: vm.Pure,
+					},
+					{
+						name: "AsPure().AsReadOnly() is still pure",
+						env:  env.AsPure().AsReadOnly(),
+						want: vm.Pure,
+					},
+				}
+
+				for _, tt := range tests {
+					t.Run(tt.name, func(t *testing.T) {
+						env := tt.env // deliberately shadow the incoming arg
+						t.Run("mutability_and_access", func(t *testing.T) {
+							assert.Equal(t, tt.want, env.StateMutability(), "env.StateMutability()")
+							assert.Equal(t, env.StateDB() != nil, tt.want == vm.MutableState, "env.StateDB() != nil i.f.f. MutableState")
+							assert.Equal(t, env.ReadOnlyState() != nil, tt.want != vm.Pure, "env.ReadOnlyState() != nil i.f.f !Pure")
+						})
+
+						t.Run("environment_unmodified", func(t *testing.T) {
+							// Each of these demonstrate that the underlying
+							// copy of the environment propagates everything but
+							// mutability.
+							assert.Equal(t, chainID, env.ChainConfig().ChainID, "Chain ID preserved")
+							assert.Equalf(t, precompile, env.Addresses().Self, "%T preserved", env.Addresses())
+							assert.Equalf(t, vm.Call, env.IncomingCallType(), "%T preserved", env.IncomingCallType())
+						})
+					})
+				}
+
+				return []byte(precompileReturn), nil
+			}),
+		},
+	}
+	hooks.Register(t)
+
+	_, evm := ethtest.NewZeroEVM(t, ethtest.WithChainConfig(&params.ChainConfig{
+		ChainID: chainID,
+	}))
+	got, _, err := evm.Call(vm.AccountRef{}, precompile, nil, 0, uint256.NewInt(0))
+	if got, want := string(got), precompileReturn; err != nil || got != want {
+		t.Errorf("%T.Call([precompile]) got {%q, %v}; want {%q, nil}", evm, got, err, want)
+	}
+}

core/vm/environment.libevm.go

@@ -81,6 +81,9 @@ func (e *environment) StateMutability() StateMutability {
 	// A switch statement provides clearer code coverage for difficult-to-test
 	// cases.
 	switch {
+	// cases MUST be ordered from most to least restrictive
+	case e.pure:
+		return Pure
 	case e.callType == StaticCall:
 		// evm.interpreter.readOnly is only set to true via a call to
 		// EVMInterpreter.Run() so, if a precompile is called directly with
@@ -90,8 +93,6 @@ func (e *environment) StateMutability() StateMutability {
 		return ReadOnlyState
 	case e.view:
 		return ReadOnlyState
-	case e.pure:
-		return Pure
 	default:
 		return MutableState
 	}