WIP mega eof

cmd/eofdump/eofparser.go

@@ -0,0 +1,220 @@
+// 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"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/core/vm"
+	"github.com/urfave/cli/v2"
+)
+
+func init() {
+	jt = vm.NewPragueEOFInstructionSetForTesting()
+}
+
+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 RefTests struct {
+	Vectors map[string]EOFTest `json:"vectors"`
+}
+
+type EOFTest struct {
+	Code    string              `json:"code"`
+	Results map[string]etResult `json:"results"`
+}
+
+type etResult struct {
+	Result    bool   `json:"result"`
+	Exception string `json:"exception,omitempty"`
+}
+
+func eofParser(ctx *cli.Context) error {
+	// 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) {
+		file := ctx.String(RefTestFlag.Name)
+		if info, err := os.Stat(file); err != nil {
+			return err
+		} else if !info.IsDir() {
+			src, err := os.ReadFile(file)
+			if err != nil {
+				return err
+			}
+			return ExecuteTest(src)
+		} else {
+			return filepath.Walk(file, func(path string, info fs.FileInfo, err error) error {
+				if err != nil {
+					return err
+				}
+				if info.IsDir() {
+					return nil
+				}
+				fmt.Printf("Executing Tests: %v\n", info.Name())
+				src, err := os.ReadFile(path)
+				if err != nil {
+					return err
+				}
+				return ExecuteTest(src)
+			})
+		}
+
+	}
+
+	// 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 ExecuteTest(src []byte) error {
+	var testsByName map[string]RefTests
+	if err := json.Unmarshal(src, &testsByName); err != nil {
+		return err
+	}
+	passed, total := 0, 0
+	for _, tests := range testsByName {
+		for name, tt := range tests.Vectors {
+			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
+				}
+				/*
+					// TODO (MariusVanDerWijden) reenable once tests have a decent error format
+					if !r.Result && err != nil && r.Exception != 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
+}
+
+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
+}
+
+func eofDump(ctx *cli.Context) error {
+	// If `--hex` is set, parse and validate the hex string argument.
+	if ctx.IsSet(HexFlag.Name) {
+		s := ctx.String(HexFlag.Name)
+		if len(s) >= 2 && strings.HasPrefix(s, "0x") {
+			s = s[2:]
+		}
+		b, err := hex.DecodeString(s)
+		if err != nil {
+			return fmt.Errorf("unable to decode data: %w", err)
+		}
+		var c vm.Container
+		if err := c.UnmarshalBinary(b); err != nil {
+			return err
+		}
+		fmt.Print(c.String())
+		return nil
+	}
+	return nil
+}

cmd/eofdump/main.go

@@ -0,0 +1,65 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/ethereum/go-ethereum/internal/debug"
+	"github.com/ethereum/go-ethereum/internal/flags"
+	"github.com/urfave/cli/v2"
+)
+
+var app = flags.NewApp("the evm command line interface")
+
+var (
+	RefTestFlag = &cli.StringFlag{
+		Name:  "test",
+		Usage: "Path to EOF validation reference test.",
+	}
+	HexFlag = &cli.StringFlag{
+		Name:  "hex",
+		Usage: "single container data parse and validation",
+	}
+)
+
+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{
+		HexFlag,
+		RefTestFlag,
+	},
+}
+
+var eofDumpCommand = &cli.Command{
+	Name:   "eofdump",
+	Usage:  "parses hex eof container",
+	Action: eofDump,
+	Flags: []cli.Flag{
+		HexFlag,
+	},
+}
+
+func init() {
+	app.Commands = []*cli.Command{
+		eofParserCommand,
+		eofDumpCommand,
+	}
+	app.Before = func(ctx *cli.Context) error {
+		flags.MigrateGlobalFlags(ctx)
+		return debug.Setup(ctx)
+	}
+	app.After = func(ctx *cli.Context) error {
+		debug.Exit()
+		return nil
+	}
+}
+
+func main() {
+	if err := app.Run(os.Args); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}

cmd/evm/internal/t8ntool/transition.go

@@ -196,6 +196,9 @@ func Transition(ctx *cli.Context) error {
 	if err := applyCancunChecks(&prestate.Env, chainConfig); err != nil {
 		return err
 	}
+	if err := applyEOFChecks(&prestate, chainConfig); err != nil {
+		return err
+	}
 	// Run the test and aggregate the result
 	s, result, body, err := prestate.Apply(vmConfig, chainConfig, txIt, ctx.Int64(RewardFlag.Name), getTracer)
 	if err != nil {
@@ -285,6 +288,29 @@ func applyCancunChecks(env *stEnv, chainConfig *params.ChainConfig) error {
 	return nil
 }
 
+func applyEOFChecks(prestate *Prestate, chainConfig *params.ChainConfig) error {
+	// Sanity check pre-allocated EOF code to not panic in state transition.
+	if chainConfig.IsShanghai(big.NewInt(int64(prestate.Env.Number)), prestate.Env.Timestamp) {
+		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.NewPragueEOFInstructionSetForTesting()
+					err = c.ValidateCode(&jt)
+				}
+				if err != nil {
+					return NewError(ErrorConfig, fmt.Errorf("code at %s considered invalid: %v", addr, err))
+				}
+			}
+		}
+	}
+	return nil
+}
+
 type Alloc map[common.Address]types.Account
 
 func (g Alloc) OnRoot(common.Hash) {}

cmd/evm/main.go

@@ -21,10 +21,13 @@ 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/debug"
 	"github.com/ethereum/go-ethereum/internal/flags"
+	"github.com/ethereum/go-ethereum/tests"
 	"github.com/urfave/cli/v2"
 
 	// Force-load the tracer engines to trigger registration
@@ -138,6 +141,18 @@ var (
 		Usage:    "enable return data output",
 		Category: flags.VMCategory,
 	}
+	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",
+	}
 )
 
 var stateTransitionCommand = &cli.Command{

cmd/evm/t8n_test.go

@@ -284,8 +284,6 @@ func TestT8n(t *testing.T) {
 			input: t8nInput{
 				"alloc.json", "txs_more.rlp", "env.json", "Cancun", "",
 			},
-			output: t8nOutput{alloc: true, result: true},
-			expOut: "exp.json",
 		},
 	} {
 		args := []string{"t8n"}