feat: add single-sequencer, EVM rollup (#2085)

## Overview

This PR introduces rollup binary for single-sequencer with EVM.

Resolves #2029

Author: tzdybal

block/manager.go

@@ -1242,6 +1242,12 @@ func (m *Manager) publishBlock(ctx context.Context) error {
 
 		// set the signature to current block's signed header
 		header.Signature = signature
+
+		if err := header.ValidateBasic(); err != nil {
+			// TODO(tzdybal): I think this is could be even a panic, because if this happens, header is FUBAR
+			m.logger.Error("header validation error", "error", err)
+		}
+
 		err = m.store.SaveBlockData(ctx, header, data, &signature)
 		if err != nil {
 			return SaveBlockError{err}

rollups/evm/centralized/go.mod

@@ -0,0 +1,48 @@
+# Rollkit EVM Single Sequencer
+
+This directory contains the implementation of a single EVM sequencer using Rollkit.
+
+## Prerequisites
+
+- Go 1.20 or later
+- Docker and Docker Compose
+- Access to the go-execution-evm repository
+
+## Starting the Aggregator Node
+
+1. Both EVM and DA layers must be running before starting the aggregator
+   1. For the EVM layer, Reth can be conveniently run using `docker compose` from the go-execution-evm repository.
+   2. For the DA layer, local-da can be built and run from the `rollkit/da/cmd/local-da` directory.
+
+
+2. Build the sequencer:
+```bash
+go build -o evm-single ./cmd/
+```
+
+3. Initialize the sequencer:
+```bash
+./evm-single init --rollkit.node.aggregator=true --rollkit.signer.passphrase secret
+```
+
+4. Start the sequencer:
+```bash
+./evm-single start \
+  --evm.jwt-secret $(cat <path_to>/go-execution-evm/docker/jwttoken/jwt.hex) \
+  --evm.genesis-hash 0x0a962a0d163416829894c89cb604ae422323bcdf02d7ea08b94d68d3e026a380 \
+  --rollkit.node.block_time 1s \
+  --rollkit.node.aggregator=true \
+  --rollkit.signer.passphrase secret
+```
+
+Note: Replace `<path_to>` with the actual path to your go-execution-evm repository.
+
+## Configuration
+
+The sequencer can be configured using various command-line flags. The most important ones are:
+
+- `--rollkit.node.aggregator`: Set to true to run in aggregator mode
+- `--rollkit.signer.passphrase`: Passphrase for the signer
+- `--evm.jwt-secret`: JWT secret for EVM communication
+- `--evm.genesis-hash`: Genesis hash of the EVM chain
+- `--rollkit.node.block_time`: Block time for the Rollkit node 

rollups/evm/single/README.md

@@ -0,0 +1,39 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+
+	"github.com/rollkit/rollkit/pkg/cmd"
+	rollkitconfig "github.com/rollkit/rollkit/pkg/config"
+)
+
+func main() {
+	// Initiate the root command
+	rootCmd := &cobra.Command{
+		Use:   "evm-single",
+		Short: "Rollkit with EVM; single sequencer",
+	}
+
+	rollkitconfig.AddGlobalFlags(rootCmd, "evm-single")
+
+	// Add subcommands to the root command
+	initCmd := cmd.InitCmd
+	rollkitconfig.AddFlags(initCmd)
+
+	rootCmd.AddCommand(
+		initCmd,
+		RunCmd,
+		cmd.NewDocsGenCmd(rootCmd, "evm-single"),
+		cmd.VersionCmd,
+		cmd.NodeInfoCmd,
+	)
+
+	if err := rootCmd.Execute(); err != nil {
+		// Print to stderr and exit with error
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}

rollups/evm/single/cmd/main.go

@@ -0,0 +1,145 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"github.com/rollkit/rollkit/sequencers/single"
+	"github.com/rs/zerolog"
+	"os"
+	"path/filepath"
+
+	"cosmossdk.io/log"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/spf13/cobra"
+
+	evm "github.com/rollkit/go-execution-evm"
+
+	coreda "github.com/rollkit/rollkit/core/da"
+	"github.com/rollkit/rollkit/core/execution"
+	"github.com/rollkit/rollkit/da"
+	"github.com/rollkit/rollkit/da/proxy"
+	rollcmd "github.com/rollkit/rollkit/pkg/cmd"
+	"github.com/rollkit/rollkit/pkg/config"
+	"github.com/rollkit/rollkit/pkg/p2p"
+	"github.com/rollkit/rollkit/pkg/p2p/key"
+	"github.com/rollkit/rollkit/pkg/store"
+)
+
+var RunCmd = &cobra.Command{
+	Use:     "start",
+	Aliases: []string{"node", "run"},
+	Short:   "Run the rollkit node with EVM execution client",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		opts := []log.Option{}
+		logLevel, _ := cmd.Flags().GetString(config.FlagLogLevel)
+		if logLevel != "" {
+			zl, err := zerolog.ParseLevel(logLevel)
+			if err != nil {
+				return err
+			}
+			opts = append(opts, log.LevelOption(zl))
+		}
+
+		logger := log.NewLogger(os.Stdout, opts...)
+
+		executor, err := createExecutionClient(cmd)
+		if err != nil {
+			return err
+		}
+
+		nodeConfig, err := rollcmd.ParseConfig(cmd)
+		if err != nil {
+			return err
+		}
+
+		daJrpc, err := proxy.NewClient(nodeConfig.DA.Address, nodeConfig.DA.AuthToken)
+		if err != nil {
+			return err
+		}
+
+		datastore, err := store.NewDefaultKVStore(nodeConfig.RootDir, nodeConfig.DBPath, "evm-single")
+		if err != nil {
+			return err
+		}
+
+		singleMetrics, err := single.NopMetrics()
+		if err != nil {
+			return err
+		}
+
+		sequencer, err := single.NewSequencer(
+			context.Background(),
+			logger,
+			datastore,
+			daJrpc,
+			[]byte(nodeConfig.DA.Namespace),
+			[]byte(nodeConfig.ChainID),
+			nodeConfig.Node.BlockTime.Duration,
+			singleMetrics,
+			nodeConfig.Node.Aggregator,
+		)
+		if err != nil {
+			return err
+		}
+
+		// Create DA client with dummy DA
+		dummyDA := coreda.NewDummyDA(100_000, 0, 0)
+		dac := da.NewDAClient(dummyDA, 0, 1.0, []byte("test"), []byte(""), logger)
+
+		nodeKey, err := key.LoadNodeKey(filepath.Dir(nodeConfig.ConfigPath()))
+		if err != nil {
+			return err
+		}
+
+		p2pClient, err := p2p.NewClient(nodeConfig, nodeKey, datastore, logger, nil)
+		if err != nil {
+			return err
+		}
+
+		return rollcmd.StartNode(logger, cmd, executor, sequencer, dac, nodeKey, p2pClient, datastore, nodeConfig)
+	},
+}
+
+func init() {
+	config.AddFlags(RunCmd)
+	addFlags(RunCmd)
+}
+
+func createExecutionClient(cmd *cobra.Command) (execution.Executor, error) {
+	// Read execution client parameters from flags
+	ethURL, err := cmd.Flags().GetString("evm.eth-url")
+	if err != nil {
+		return nil, fmt.Errorf("failed to get 'evm.eth-url' flag: %w", err)
+	}
+	engineURL, err := cmd.Flags().GetString("evm.engine-url")
+	if err != nil {
+		return nil, fmt.Errorf("failed to get 'evm.engine-url' flag: %w", err)
+	}
+	jwtSecret, err := cmd.Flags().GetString("evm.jwt-secret")
+	if err != nil {
+		return nil, fmt.Errorf("failed to get 'evm.jwt-secret' flag: %w", err)
+	}
+	genesisHashStr, err := cmd.Flags().GetString("evm.genesis-hash")
+	if err != nil {
+		return nil, fmt.Errorf("failed to get 'evm.genesis-hash' flag: %w", err)
+	}
+	feeRecipientStr, err := cmd.Flags().GetString("evm.fee-recipient")
+	if err != nil {
+		return nil, fmt.Errorf("failed to get 'evm.fee-recipient' flag: %w", err)
+	}
+
+	// Convert string parameters to Ethereum types
+	genesisHash := common.HexToHash(genesisHashStr)
+	feeRecipient := common.HexToAddress(feeRecipientStr)
+
+	return evm.NewPureEngineExecutionClient(ethURL, engineURL, jwtSecret, genesisHash, feeRecipient)
+}
+
+// addFlags adds flags related to the EVM execution client
+func addFlags(cmd *cobra.Command) {
+	cmd.Flags().String("evm.eth-url", "http://localhost:8545", "URL of the Ethereum JSON-RPC endpoint")
+	cmd.Flags().String("evm.engine-url", "http://localhost:8551", "URL of the Engine API endpoint")
+	cmd.Flags().String("evm.jwt-secret", "", "Path to the JWT secret file for authentication with the execution client")
+	cmd.Flags().String("evm.genesis-hash", "", "Hash of the genesis block")
+	cmd.Flags().String("evm.fee-recipient", "", "Address that will receive transaction fees")
+}

rollups/evm/single/cmd/run.go

@@ -1,4 +1,4 @@
 /*
 This package implements a centralized rollup for RETH
 */
-package centralized
+package single