feat: enable mock servers with intercept command (#1911)

<!--
Please read and fill out this form before submitting your PR.

Please make sure you have reviewed our contributors guide before
submitting your
first PR.

NOTE: PR titles should follow semantic commits:
https://www.conventionalcommits.org/en/v1.0.0/
-->

## Overview

<!-- 
Please provide an explanation of the PR, including the appropriate
context,
background, goal, and rationale. If there is an issue with this
information,
please provide a tl;dr and link the issue. 

Ex: Closes #<issue number>
-->

This PR does two key things:
1. Handles already running sequencer
2. Enables using mock services with the intercept command. 

1 is pretty straight forward as we did this for the DA server as well.
The one thing to note though with this PR is that because we are
checking for already running servers, I just remove the redundant check
of if the flag was set. I add a comment to the code to explain the
reasoning and to document the context for the future.

For 2, this will help us clean up the rollkit docs. Right now, even for
simple ignite apps, you have to run the local da, local sequencer, and
in the future some local execution. This makes the docs and rollkit feel
clunky.

By adding the mock server commands to the intercept command, we can spin
up mock da and mock sequencer for these tutorials to reduce the steps
required by the users.

Enables: evstack/docs#485
Closes #1910 


<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

## Release Notes

- **New Features**
- Added command-line option `--rollkit.sequencer_rollup_id` for
specifying the sequencer middleware rollup ID, defaulting to
"mock-rollup."
- Introduced functionality to start mock services for improved testing
and development.

- **Bug Fixes**
- Enhanced error handling for starting mock servers, including checks
for already running services.

- **Documentation**
- Updated documentation to reflect new command-line options and improved
configurations.

- **Refactor**
- Streamlined control flow and error handling in the `InterceptCommand`
and mock server initialization processes.
- Improved code structure and readability for mock server startup logic.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: MSevey

cmd/rollkit/commands/intercept.go

@@ -1,6 +1,7 @@
 package commands
 
 import (
+	"errors"
 	"fmt"
 	"os"
 	"os/exec"
@@ -9,6 +10,7 @@ import (
 	cometos "github.com/cometbft/cometbft/libs/os"
 	"github.com/spf13/cobra"
 
+	proxy "github.com/rollkit/go-da/proxy/jsonrpc"
 	rollconf "github.com/rollkit/rollkit/config"
 )
 
@@ -22,47 +24,85 @@ func InterceptCommand(
 	rollkitCommand *cobra.Command,
 	readToml func() (rollconf.TomlConfig, error),
 	runEntrypoint func(*rollconf.TomlConfig, []string) error,
-) (bool, error) {
+) (shouldExecute bool, err error) {
 	// Grab flags and verify command
 	flags := []string{}
+	isStartCommand := false
 	if len(os.Args) >= 2 {
 		flags = os.Args[1:]
 
 		// Handle specific cases first for help, version, and start
 		switch os.Args[1] {
 		case "help", "--help", "h", "-h",
 			"version", "--version", "v", "-v":
-			return false, nil
+			return
 		case "start":
-			goto readTOML
-		}
-
-		// Check if user attempted to run a rollkit command
-		for _, cmd := range rollkitCommand.Commands() {
-			if os.Args[1] == cmd.Use {
-				return false, nil
+			isStartCommand = true
+		default:
+			// Check if user attempted to run a rollkit command
+			for _, cmd := range rollkitCommand.Commands() {
+				if os.Args[1] == cmd.Use {
+					return
+				}
 			}
 		}
 	}
 
-readTOML:
-	var err error
 	rollkitConfig, err = readToml()
 	if err != nil {
-		return false, err
+		return
 	}
 
 	// To avoid recursive calls, we check if the root directory is the rollkit repository itself
 	if filepath.Base(rollkitConfig.RootDir) == "rollkit" {
-		return false, nil
+		return
 	}
 
+	// At this point we expect to execute the command against the entrypoint
+	shouldExecute = true
+
 	// After successfully reading the TOML file, we expect to be able to use the entrypoint
 	if rollkitConfig.Entrypoint == "" {
-		return true, fmt.Errorf("no entrypoint specified in %s", rollconf.RollkitToml)
+		err = fmt.Errorf("no entrypoint specified in %s", rollconf.RollkitToml)
+		return
 	}
 
-	return true, runEntrypoint(&rollkitConfig, flags)
+	if isStartCommand {
+		// Try and launch mock services or connect to default addresses
+		daAddress := parseFlag(flags, rollconf.FlagDAAddress)
+		if daAddress == "" {
+			daAddress = rollconf.DefaultDAAddress
+		}
+		daSrv, err := tryStartMockDAServJSONRPC(rollkitCommand.Context(), daAddress, proxy.NewServer)
+		if err != nil && !errors.Is(err, errDAServerAlreadyRunning) {
+			return shouldExecute, fmt.Errorf("failed to launch mock da server: %w", err)
+		}
+		// nolint:errcheck,gosec
+		defer func() {
+			if daSrv != nil {
+				daSrv.Stop(rollkitCommand.Context())
+			}
+		}()
+		sequencerAddress := parseFlag(flags, rollconf.FlagSequencerAddress)
+		if sequencerAddress == "" {
+			sequencerAddress = rollconf.DefaultSequencerAddress
+		}
+		rollupID := parseFlag(flags, rollconf.FlagSequencerRollupID)
+		if rollupID == "" {
+			rollupID = rollconf.DefaultSequencerRollupID
+		}
+		seqSrv, err := tryStartMockSequencerServerGRPC(sequencerAddress, rollupID)
+		if err != nil && !errors.Is(err, errSequencerAlreadyRunning) {
+			return shouldExecute, fmt.Errorf("failed to launch mock sequencing server: %w", err)
+		}
+		// nolint:errcheck,gosec
+		defer func() {
+			if seqSrv != nil {
+				seqSrv.Stop()
+			}
+		}()
+	}
+	return shouldExecute, runEntrypoint(&rollkitConfig, flags)
 }
 
 func buildEntrypoint(rootDir, entrypointSourceFile string, forceRebuild bool) (string, error) {
@@ -125,3 +165,14 @@ func RunRollupEntrypoint(rollkitConfig *rollconf.TomlConfig, args []string) erro
 
 	return nil
 }
+
+func parseFlag(args []string, flag string) string {
+	for i, arg := range args {
+		if arg == fmt.Sprintf("--%s", flag) {
+			if len(args) > i+1 {
+				return args[i+1]
+			}
+		}
+	}
+	return ""
+}

cmd/rollkit/commands/run_node.go

@@ -51,12 +51,10 @@ var (
 	// initialize the logger with the cometBFT defaults
 	logger = cometlog.NewTMLogger(cometlog.NewSyncWriter(os.Stdout))
 
-	errDAServerAlreadyRunning = errors.New("DA server already running")
+	errDAServerAlreadyRunning  = errors.New("DA server already running")
+	errSequencerAlreadyRunning = errors.New("sequencer already running")
 )
 
-// MockSequencerAddress is a sample address used by the mock sequencer
-const MockSequencerAddress = "localhost:50051"
-
 // NewRunNodeCmd returns the command that allows the CLI to start a node.
 func NewRunNodeCmd() *cobra.Command {
 	cmd := &cobra.Command{
@@ -130,29 +128,36 @@ func NewRunNodeCmd() *cobra.Command {
 			// initialize the metrics
 			metrics := rollnode.DefaultMetricsProvider(cometconf.DefaultInstrumentationConfig())
 
-			// use mock jsonrpc da server by default
-			if !cmd.Flags().Lookup("rollkit.da_address").Changed {
-				srv, err := startMockDAServJSONRPC(cmd.Context(), nodeConfig.DAAddress, proxy.NewServer)
-				if err != nil && !errors.Is(err, errDAServerAlreadyRunning) {
-					return fmt.Errorf("failed to launch mock da server: %w", err)
-				}
-				// nolint:errcheck,gosec
-				defer func() {
-					if srv != nil {
-						srv.Stop(cmd.Context())
-					}
-				}()
+			// Try and launch a mock JSON RPC DA server if there is no DA server running.
+			// NOTE: if the user supplied an address for a running DA server, and the address doesn't match, this will launch a mock DA server. This is ok because the logs will tell the user that a mock DA server is being used.
+			daSrv, err := tryStartMockDAServJSONRPC(cmd.Context(), nodeConfig.DAAddress, proxy.NewServer)
+			if err != nil && !errors.Is(err, errDAServerAlreadyRunning) {
+				return fmt.Errorf("failed to launch mock da server: %w", err)
 			}
-
-			// use mock grpc sequencer server by default
-			if !cmd.Flags().Lookup("rollkit.sequencer_address").Changed {
-				srv, err := startMockSequencerServerGRPC(MockSequencerAddress, genDoc.ChainID)
-				if err != nil {
-					return fmt.Errorf("failed to launch mock sequencing server: %w", err)
+			// nolint:errcheck,gosec
+			defer func() {
+				if daSrv != nil {
+					daSrv.Stop(cmd.Context())
 				}
-				// nolint:errcheck,gosec
-				defer func() { srv.Stop() }()
+			}()
+
+			// Determine which rollupID to use. If the flag has been set we want to use that value and ensure that the chainID in the genesis doc matches.
+			if cmd.Flags().Lookup(rollconf.FlagSequencerRollupID).Changed {
+				genDoc.ChainID = nodeConfig.SequencerRollupID
 			}
+			sequencerRollupID := genDoc.ChainID
+			// Try and launch a mock gRPC sequencer if there is no sequencer running.
+			// NOTE: if the user supplied an address for a running sequencer, and the address doesn't match, this will launch a mock sequencer. This is ok because the logs will tell the user that a mock sequencer is being used.
+			seqSrv, err := tryStartMockSequencerServerGRPC(nodeConfig.SequencerAddress, sequencerRollupID)
+			if err != nil && !errors.Is(err, errSequencerAlreadyRunning) {
+				return fmt.Errorf("failed to launch mock sequencing server: %w", err)
+			}
+			// nolint:errcheck,gosec
+			defer func() {
+				if seqSrv != nil {
+					seqSrv.Stop()
+				}
+			}()
 
 			// use noop proxy app by default
 			if !cmd.Flags().Lookup("proxy_app").Changed {
@@ -244,8 +249,8 @@ func addNodeFlags(cmd *cobra.Command) {
 	rollconf.AddFlags(cmd)
 }
 
-// startMockDAServJSONRPC starts a mock JSONRPC server
-func startMockDAServJSONRPC(
+// tryStartMockDAServJSONRPC will try and start a mock JSONRPC server
+func tryStartMockDAServJSONRPC(
 	ctx context.Context,
 	daAddress string,
 	newServer func(string, string, da.DA) *proxy.Server,
@@ -258,28 +263,34 @@ func startMockDAServJSONRPC(
 	srv := newServer(addr.Hostname(), addr.Port(), goDATest.NewDummyDA())
 	if err := srv.Start(ctx); err != nil {
 		if errors.Is(err, syscall.EADDRINUSE) {
-			logger.Info("DA server is already running", "address", nodeConfig.DAAddress)
+			logger.Info("DA server is already running", "address", daAddress)
 			return nil, errDAServerAlreadyRunning
 		}
 		return nil, err
 	}
 
-	logger.Info("Starting mock DA server", "address", nodeConfig.DAAddress)
+	logger.Info("Starting mock DA server", "address", daAddress)
 
 	return srv, nil
 }
 
-// startMockSequencerServerGRPC starts a mock gRPC server with the given listenAddress.
-func startMockSequencerServerGRPC(listenAddress string, rollupId string) (*grpc.Server, error) {
+// tryStartMockSequencerServerGRPC will try and start a mock gRPC server with the given listenAddress.
+func tryStartMockSequencerServerGRPC(listenAddress string, rollupId string) (*grpc.Server, error) {
 	dummySeq := seqTest.NewDummySequencer([]byte(rollupId))
 	server := seqGRPC.NewServer(dummySeq, dummySeq, dummySeq)
 	lis, err := net.Listen("tcp", listenAddress)
 	if err != nil {
+		if errors.Is(err, syscall.EADDRINUSE) {
+			logger.Info(errSequencerAlreadyRunning.Error(), "address", listenAddress)
+			logger.Info("make sure your rollupID matches your sequencer", "rollupID", rollupId)
+			return nil, errSequencerAlreadyRunning
+		}
 		return nil, err
 	}
 	go func() {
 		_ = server.Serve(lis)
 	}()
+	logger.Info("Starting mock sequencer", "address", listenAddress, "rollupID", rollupId)
 	return server, nil
 }
 

cmd/rollkit/commands/run_node_test.go

@@ -209,7 +209,7 @@ func TestStartMockDAServJSONRPC(t *testing.T) {
 				return mockServer.Server
 			}
 
-			srv, err := startMockDAServJSONRPC(context.Background(), tt.daAddress, newServerFunc)
+			srv, err := tryStartMockDAServJSONRPC(context.Background(), tt.daAddress, newServerFunc)
 
 			if tt.expectedErr != nil {
 				assert.Error(t, err)

cmd/rollkit/docs/rollkit_start.md

@@ -45,6 +45,7 @@ rollkit start [flags]
       --rollkit.light                                   run light client
       --rollkit.max_pending_blocks uint                 limit of blocks pending DA submission (0 for no limit)
       --rollkit.sequencer_address string                sequencer middleware address (host:port) (default "localhost:50051")
+      --rollkit.sequencer_rollup_id string              sequencer middleware rollup ID (default: mock-rollup) (default "mock-rollup")
       --rollkit.trusted_hash string                     initial trusted hash to start the header exchange service
       --rpc.grpc_laddr string                           GRPC listen address (BroadcastTx only). Port required
       --rpc.laddr string                                RPC listen address. Port required (default "tcp://127.0.0.1:26657")

config/config.go

@@ -44,6 +44,8 @@ const (
 	FlagLazyBlockTime = "rollkit.lazy_block_time"
 	// FlagSequencerAddress is a flag for specifying the sequencer middleware address
 	FlagSequencerAddress = "rollkit.sequencer_address"
+	// FlagSequencerRollupID is a flag for specifying the sequencer middleware rollup ID
+	FlagSequencerRollupID = "rollkit.sequencer_rollup_id"
 )
 
 // NodeConfig stores Rollkit node configuration.
@@ -66,8 +68,9 @@ type NodeConfig struct {
 	DASubmitOptions    string                       `mapstructure:"da_submit_options"`
 
 	// CLI flags
-	DANamespace      string `mapstructure:"da_namespace"`
-	SequencerAddress string `mapstructure:"sequencer_address"`
+	DANamespace       string `mapstructure:"da_namespace"`
+	SequencerAddress  string `mapstructure:"sequencer_address"`
+	SequencerRollupID string `mapstructure:"sequencer_rollup_id"`
 }
 
 // HeaderConfig allows node to pass the initial trusted header hash to start the header exchange service
@@ -143,6 +146,7 @@ func (nc *NodeConfig) GetViperConfig(v *viper.Viper) error {
 	nc.DAMempoolTTL = v.GetUint64(FlagDAMempoolTTL)
 	nc.LazyBlockTime = v.GetDuration(FlagLazyBlockTime)
 	nc.SequencerAddress = v.GetString(FlagSequencerAddress)
+	nc.SequencerRollupID = v.GetString(FlagSequencerRollupID)
 
 	return nil
 }
@@ -170,4 +174,5 @@ func AddFlags(cmd *cobra.Command) {
 	cmd.Flags().Uint64(FlagDAMempoolTTL, def.DAMempoolTTL, "number of DA blocks until transaction is dropped from the mempool")
 	cmd.Flags().Duration(FlagLazyBlockTime, def.LazyBlockTime, "block time (for lazy mode)")
 	cmd.Flags().String(FlagSequencerAddress, def.SequencerAddress, "sequencer middleware address (host:port)")
+	cmd.Flags().String(FlagSequencerRollupID, def.SequencerRollupID, "sequencer middleware rollup ID (default: mock-rollup)")
 }

config/defaults.go

@@ -12,6 +12,12 @@ const (
 	// Version is the current rollkit version
 	// Please keep updated with each new release
 	Version = "0.38.5"
+	// DefaultDAAddress is the default address for the DA middleware
+	DefaultDAAddress = "http://localhost:26658"
+	// DefaultSequencerAddress is the default address for the sequencer middleware
+	DefaultSequencerAddress = "localhost:50051"
+	// DefaultSequencerRollupID is the default rollup ID for the sequencer middleware
+	DefaultSequencerRollupID = "mock-rollup"
 )
 
 // DefaultNodeConfig keeps default values of NodeConfig
@@ -27,13 +33,14 @@ var DefaultNodeConfig = NodeConfig{
 		LazyAggregator: false,
 		LazyBlockTime:  60 * time.Second,
 	},
-	DAAddress:       "http://localhost:26658",
+	DAAddress:       DefaultDAAddress,
 	DAGasPrice:      -1,
 	DAGasMultiplier: 0,
 	Light:           false,
 	HeaderConfig: HeaderConfig{
 		TrustedHash: "",
 	},
-	Instrumentation:  config.DefaultInstrumentationConfig(),
-	SequencerAddress: "localhost:50051",
+	Instrumentation:   config.DefaultInstrumentationConfig(),
+	SequencerAddress:  DefaultSequencerAddress,
+	SequencerRollupID: DefaultSequencerRollupID,
 }