feat: precompilegen Solidity interface -> stateful precompile

.github/workflows/go.yml

@@ -30,6 +30,13 @@ jobs:
       EXCLUDE_REGEX: 'ava-labs/libevm/(accounts/usbwallet/trezor)$'
     runs-on: ubuntu-latest
     steps:
+      - name: Install solc
+        run: |
+          sudo add-apt-repository ppa:ethereum/ethereum
+          sudo apt update
+          sudo apt list -a solc
+          sudo apt install solc=1:0.8.28-0ubuntu1~noble
+
       - uses: actions/checkout@v4
       - name: Set up Go
         uses: actions/setup-go@v5

accounts/abi/selector.libevm.go

@@ -0,0 +1,75 @@
+// Copyright 2024 the libevm authors.
+//
+// The libevm additions to go-ethereum are free software: you can redistribute
+// them and/or modify them under the terms of the GNU Lesser General Public License
+// as published by the Free Software Foundation, either version 3 of the License,
+// or (at your option) any later version.
+//
+// The libevm additions are distributed in the hope that they will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
+// General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License
+// along with the go-ethereum library. If not, see
+// <http://www.gnu.org/licenses/>.
+
+package abi
+
+import (
+	"encoding/binary"
+	"fmt"
+)
+
+// SelectorByteLen is the number of bytes in an ABI function selector.
+const SelectorByteLen = 4
+
+// A Selector is an ABI function selector. It is a uint32 instead of a [4]byte
+// to allow for simpler hex literals.
+type Selector uint32
+
+// String returns a hex encoding of `s`.
+func (s Selector) String() string {
+	b := make([]byte, 4)
+	binary.BigEndian.PutUint32(b, uint32(s))
+	return fmt.Sprintf("%#x", b)
+}
+
+// ExtractSelector returns the first 4 bytes of the slice as a Selector. It
+// assumes that its input is of sufficient length.
+func ExtractSelector(data []byte) Selector {
+	return Selector(binary.BigEndian.Uint32(data[:4]))
+}
+
+// Selector returns the Method's ID as a Selector.
+func (m Method) Selector() Selector {
+	return ExtractSelector(m.ID)
+}
+
+// MethodsBySelector maps 4-byte ABI selectors to the corresponding method
+// representation. The key MUST be equivalent to the value's [Method.Selector].
+type MethodsBySelector map[Selector]Method
+
+// MethodsBySelector returns the [Method]s keyed by their Selectors.
+func (a *ABI) MethodsBySelector() MethodsBySelector {
+	ms := make(MethodsBySelector)
+	for _, m := range a.Methods {
+		ms[m.Selector()] = m
+	}
+	return ms
+}
+
+// FindSelector extracts the Selector from `data` and, if it exists in `m`,
+// returns it. The returned boolean functions as for regular map lookups. Unlike
+// [ExtractSelector], FindSelector confirms that `data` has at least 4 bytes,
+// treating invalid inputs as not found.
+func (m MethodsBySelector) FindSelector(data []byte) (Selector, bool) {
+	if len(data) < SelectorByteLen {
+		return 0, false
+	}
+	sel := ExtractSelector(data)
+	if _, ok := m[sel]; !ok {
+		return 0, false
+	}
+	return sel, true
+}

core/vm/contracts.libevm.go

@@ -57,10 +57,10 @@ type evmCallArgs struct {
 type CallType OpCode
 
 const (
-	Call         = CallType(CALL)
-	CallCode     = CallType(CALLCODE)
-	DelegateCall = CallType(DELEGATECALL)
-	StaticCall   = CallType(STATICCALL)
+	Call         CallType = CallType(CALL)
+	CallCode     CallType = CallType(CALLCODE)
+	DelegateCall CallType = CallType(DELEGATECALL)
+	StaticCall   CallType = CallType(STATICCALL)
 )
 
 func (t CallType) isValid() bool {
@@ -88,6 +88,32 @@ func (t CallType) OpCode() OpCode {
 	return INVALID
 }
 
+// StateMutability describes the available state access.
+type StateMutability uint
+
+const (
+	// Pure is a Solidity concept disallowing all access, read or write, to
+	// state.
+	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.
+func (m StateMutability) String() string {
+	switch m {
+	case MutableState:
+		return "mutable"
+	case ReadOnlyState:
+		return "read-only"
+	case Pure:
+		return "no state access"
+	}
+	return fmt.Sprintf("unknown %T(%[1]d)", m)
+}
+
 // run runs the [PrecompiledContract], differentiating between stateful and
 // regular types, updating `args.gasRemaining` in the stateful case.
 func (args *evmCallArgs) run(p PrecompiledContract, input []byte) (ret []byte, err error) {
@@ -96,7 +122,7 @@ func (args *evmCallArgs) run(p PrecompiledContract, input []byte) (ret []byte, e
 		return p.Run(input)
 	case statefulPrecompile:
 		env := args.env()
-		ret, err := p(env, input)
+		ret, err := p(env, common.CopyBytes(input))
 		args.gasRemaining = env.Gas()
 		return ret, err
 	}
@@ -141,14 +167,28 @@ func (p statefulPrecompile) Run([]byte) ([]byte, error) {
 type PrecompileEnvironment interface {
 	ChainConfig() *params.ChainConfig
 	Rules() params.Rules
-	// StateDB will be non-nil i.f.f !ReadOnly().
+	// StateDB will be non-nil i.f.f StateMutability() returns [MutableState].
 	StateDB() StateDB
-	// ReadOnlyState will always be non-nil.
+	// ReadOnlyState will be non-nil i.f.f. StateMutability() does not return
+	// [Pure].
 	ReadOnlyState() libevm.StateReader
 
+	// StateMutability can infer [MutableState] vs [ReadOnlyState] based on EVM
+	// 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() 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()
+	// and ReadOnlyState() will return nil.
+	AsPure() PrecompileEnvironment
+
 	IncomingCallType() CallType
 	Addresses() *libevm.AddressContext
-	ReadOnly() bool
 	// Equivalent to respective methods on [Contract].
 	Gas() uint64
 	UseGas(uint64) (hasEnoughGas bool)
@@ -210,3 +250,21 @@ var (
 		(*EVM)(nil).StaticCall,
 	}
 )
+
+// A RevertError is an error that couples [ErrExecutionReverted] with the EVM
+// return buffer. Although not used in vanilla geth, it can be returned by a
+// libevm `precompilegen` method implementation to circumvent regular argument
+// packing.
+type RevertError []byte
+
+// Error is equivalent to the respective method on [ErrExecutionReverted].
+func (e RevertError) Error() string { return ErrExecutionReverted.Error() }
+
+// Bytes returns the return buffer with which an EVM context reverted.
+func (e RevertError) Bytes() []byte { return []byte(e) }
+
+// Is returns true if `err` is directly == to `e` or if `err` is
+// [ErrExecutionReverted].
+func (e RevertError) Is(err error) bool {
+	return error(e) == err || err == ErrExecutionReverted
+}