core/vm: implement full EOF suite

cmd/evm/eofparser.go

@@ -0,0 +1,168 @@
+// Copyright 2023 The go-ethereum Authors
+// This file is part of go-ethereum.
+//
+// go-ethereum is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// go-ethereum is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
+
+package main
+
+import (
+	"bufio"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/urfave/cli/v2"
+)
+
+func init() {
+	jt = vm.NewShanghaiEOFInstructionSetForTesting()
+}
+
+var (
+	jt       vm.JumpTable
+	errorMap = map[string]int{
+		io.ErrUnexpectedEOF.Error():          1,
+		vm.ErrInvalidMagic.Error():           2,
+		vm.ErrInvalidVersion.Error():         3,
+		vm.ErrMissingTypeHeader.Error():      4,
+		vm.ErrInvalidTypeSize.Error():        5,
+		vm.ErrMissingCodeHeader.Error():      6,
+		vm.ErrInvalidCodeHeader.Error():      7,
+		vm.ErrMissingDataHeader.Error():      8,
+		vm.ErrMissingTerminator.Error():      9,
+		vm.ErrTooManyInputs.Error():          10,
+		vm.ErrTooManyOutputs.Error():         11,
+		vm.ErrTooLargeMaxStackHeight.Error(): 12,
+		vm.ErrInvalidCodeSize.Error():        13,
+		vm.ErrInvalidContainerSize.Error():   14,
+		vm.ErrUndefinedInstruction.Error():   15,
+		vm.ErrTruncatedImmediate.Error():     16,
+		vm.ErrInvalidSectionArgument.Error(): 17,
+		vm.ErrInvalidJumpDest.Error():        18,
+		vm.ErrConflictingStack.Error():       19,
+		vm.ErrInvalidBranchCount.Error():     20,
+		vm.ErrInvalidOutputs.Error():         21,
+		vm.ErrInvalidMaxStackHeight.Error():  22,
+		vm.ErrInvalidCodeTermination.Error(): 23,
+		vm.ErrUnreachableCode.Error():        24,
+	}
+)
+
+type EOFTest struct {
+	Code    string              `json:"code"`
+	Results map[string]etResult `json:"results"`
+}
+
+type etResult struct {
+	Result    bool `json:"result"`
+	Exception int  `json:"exception,omitempty"`
+}
+
+func eofParser(ctx *cli.Context) error {
+	glogger := log.NewGlogHandler(log.StreamHandler(os.Stderr, log.TerminalFormat(false)))
+	glogger.Verbosity(log.Lvl(ctx.Int(VerbosityFlag.Name)))
+	log.Root().SetHandler(glogger)
+
+	// If `--hex` is set, parse and validate the hex string argument.
+	if ctx.IsSet(HexFlag.Name) {
+		if _, err := parseAndValidate(ctx.String(HexFlag.Name)); err != nil {
+			if err2 := errors.Unwrap(err); err2 != nil {
+				err = err2
+			}
+			return fmt.Errorf("err(%d): %w", errorMap[err.Error()], err)
+		}
+		fmt.Println("ok.")
+		return nil
+	}
+
+	// If `--test` is set, parse and validate the reference test at the provided path.
+	if ctx.IsSet(RefTestFlag.Name) {
+		src, err := os.ReadFile(ctx.String(RefTestFlag.Name))
+		if err != nil {
+			return err
+		}
+		var tests map[string]EOFTest
+		if err = json.Unmarshal(src, &tests); err != nil {
+			return err
+		}
+		passed, total := 0, 0
+		for name, tt := range tests {
+			for fork, r := range tt.Results {
+				total++
+				// TODO(matt): all tests currently run against
+				// shanghai EOF, add support for custom forks.
+				_, err := parseAndValidate(tt.Code)
+				if err2 := errors.Unwrap(err); err2 != nil {
+					err = err2
+				}
+				if r.Result && err != nil {
+					fmt.Fprintf(os.Stderr, "%s, %s: expected success, got %v\n", name, fork, err)
+					continue
+				}
+				if !r.Result && err == nil {
+					fmt.Fprintf(os.Stderr, "%s, %s: expected error %d, got %v\n", name, fork, r.Exception, err)
+					continue
+				}
+				if !r.Result && err != nil && r.Exception != errorMap[err.Error()] {
+					fmt.Fprintf(os.Stderr, "%s, %s: expected error %d, got: err(%d): %v\n", name, fork, r.Exception, errorMap[err.Error()], err)
+					continue
+				}
+				passed++
+			}
+		}
+		fmt.Printf("%d/%d tests passed.\n", passed, total)
+		return nil
+	}
+
+	// If neither are passed in, read input from stdin.
+	scanner := bufio.NewScanner(os.Stdin)
+	for scanner.Scan() {
+		t := strings.TrimSpace(scanner.Text())
+		if len(t) == 0 || t[0] == '#' {
+			continue
+		}
+		if _, err := parseAndValidate(t); err != nil {
+			if err2 := errors.Unwrap(err); err2 != nil {
+				err = err2
+			}
+			fmt.Fprintf(os.Stderr, "err(%d): %v\n", errorMap[err.Error()], err)
+		}
+	}
+
+	return nil
+}
+
+func parseAndValidate(s string) (*vm.Container, error) {
+	if len(s) >= 2 && strings.HasPrefix(s, "0x") {
+		s = s[2:]
+	}
+	b, err := hex.DecodeString(s)
+	if err != nil {
+		return nil, fmt.Errorf("unable to decode data: %w", err)
+	}
+	var c vm.Container
+	if err := c.UnmarshalBinary(b); err != nil {
+		return nil, err
+	}
+	if err := c.ValidateCode(&jt); err != nil {
+		return nil, err
+	}
+	return &c, nil
+}

cmd/evm/internal/t8ntool/transition.go

@@ -262,6 +262,25 @@ func Transition(ctx *cli.Context) error {
 			return NewError(ErrorConfig, errors.New("EIP-1559 config but missing 'currentBaseFee' in env section"))
 		}
 	}
+	// Sanity check pre-allocated EOF code to not panic in state transition.
+	if chainConfig.IsShanghai(big.NewInt(int64(prestate.Env.Number))) {
+		for addr, acc := range prestate.Pre {
+			if vm.HasEOFByte(acc.Code) {
+				var (
+					c   vm.Container
+					err error
+				)
+				err = c.UnmarshalBinary(acc.Code)
+				if err == nil {
+					jt := vm.NewShanghaiEOFInstructionSetForTesting()
+					err = c.ValidateCode(&jt)
+				}
+				if err != nil {
+					return NewError(ErrorConfig, fmt.Errorf("code at %s considered invalid: %v", addr, err))
+				}
+			}
+		}
+	}
 	isMerged := chainConfig.TerminalTotalDifficulty != nil && chainConfig.TerminalTotalDifficulty.BitLen() == 0
 	env := prestate.Env
 	if isMerged {

cmd/evm/main.go

@@ -21,9 +21,12 @@ import (
 	"fmt"
 	"math/big"
 	"os"
+	"strings"
 
 	"github.com/ethereum/go-ethereum/cmd/evm/internal/t8ntool"
+	"github.com/ethereum/go-ethereum/core/vm"
 	"github.com/ethereum/go-ethereum/internal/flags"
+	"github.com/ethereum/go-ethereum/tests"
 	"github.com/urfave/cli/v2"
 )
 
@@ -125,6 +128,26 @@ var (
 		Value: true,
 		Usage: "enable return data output",
 	}
+	HexFlag = &cli.StringFlag{
+		Name:  "hex",
+		Usage: "single container data parse and validation",
+	}
+	ForknameFlag = &cli.StringFlag{
+		Name: "state.fork",
+		Usage: fmt.Sprintf("Name of ruleset to use."+
+			"\n\tAvailable forknames:"+
+			"\n\t    %v"+
+			"\n\tAvailable extra eips:"+
+			"\n\t    %v"+
+			"\n\tSyntax <forkname>(+ExtraEip)",
+			strings.Join(tests.AvailableForks(), "\n\t    "),
+			strings.Join(vm.ActivateableEips(), ", ")),
+		Value: "Shanghai",
+	}
+	RefTestFlag = &cli.StringFlag{
+		Name:  "test",
+		Usage: "Path to EOF validation reference test.",
+	}
 )
 
 var stateTransitionCommand = &cli.Command{
@@ -185,6 +208,18 @@ var blockBuilderCommand = &cli.Command{
 	},
 }
 
+var eofParserCommand = &cli.Command{
+	Name:    "eofparser",
+	Aliases: []string{"eof"},
+	Usage:   "parses hex eof container and returns validation errors (if any)",
+	Action:  eofParser,
+	Flags: []cli.Flag{
+		VerbosityFlag,
+		HexFlag,
+		RefTestFlag,
+	},
+}
+
 var app = flags.NewApp("the evm command line interface")
 
 func init() {
@@ -221,6 +256,7 @@ func init() {
 		stateTransitionCommand,
 		transactionCommand,
 		blockBuilderCommand,
+		eofParserCommand,
 	}
 }
 

cmd/evm/t8n_test.go

@@ -251,6 +251,14 @@ func TestT8n(t *testing.T) {
 			output: t8nOutput{alloc: true, result: true},
 			expOut: "exp.json",
 		},
+		{ // Validate pre-allocated EOF code
+			base: "./testdata/26",
+			input: t8nInput{
+				"alloc.json", "txs.json", "env.json", "Shanghai", "",
+			},
+			output:      t8nOutput{alloc: true, result: false},
+			expExitCode: 3,
+		},
 	} {
 		args := []string{"t8n"}
 		args = append(args, tc.output.get()...)

cmd/evm/testdata/26/alloc.json

@@ -0,0 +1,14 @@
+{
+  "a94f5374fce5edbc8e2a8697c15331677e6ebf0b": {
+    "balance": "0x0",
+    "code": "0xef01",
+    "nonce": "0x1",
+    "storage": {}
+  },
+  "a94f5374fce5edbc8e2a8697c15331677e6ebf0c": {
+    "balance": "0x0",
+    "code": "0xef0001010008020002000700020300000000000002020100025959b0000250b101b1",
+    "nonce": "0x1",
+    "storage": {}
+  }
+}

cmd/evm/testdata/26/env.json

@@ -0,0 +1,11 @@
+{
+  "currentCoinbase": "0xc94f5374fce5edbc8e2a8697c15331677e6ebf0b",
+  "currentDifficulty": null,
+  "currentRandom": "0xdeadc0de",
+  "currentGasLimit": "0x750a163df65e8a",
+  "parentBaseFee": "0x500",
+  "parentGasUsed": "0x0",
+  "parentGasLimit": "0x750a163df65e8a",
+  "currentNumber": "1",
+  "currentTimestamp": "1000"
+}

cmd/evm/testdata/26/txs.json

@@ -0,0 +1 @@
+[]