feat: extract driver configuration outside of NewBatchSubmitter

go/batch-submitter/batch_submitter.go

@@ -5,7 +5,6 @@ import (
 	"crypto/ecdsa"
 	"crypto/tls"
 	"fmt"
-	"github.com/ethereum/go-ethereum/rpc"
 	"net/http"
 	"os"
 	"strconv"
@@ -21,6 +20,7 @@ import (
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/getsentry/sentry-go"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 	"github.com/urfave/cli"
@@ -37,8 +37,8 @@ const (
 // use of a closure allows the parameters bound to the top-level main package,
 // e.g. GitVersion, to be captured and used once the function is executed.
 func Main(gitVersion string) func(ctx *cli.Context) error {
-	return func(ctx *cli.Context) error {
-		cfg, err := NewConfig(ctx)
+	return func(cliCtx *cli.Context) error {
+		cfg, err := NewConfig(cliCtx)
 		if err != nil {
 			return err
 		}
@@ -51,197 +51,182 @@ func Main(gitVersion string) func(ctx *cli.Context) error {
 
 		log.Info("Initializing batch submitter")
 
-		batchSubmitter, err := NewBatchSubmitter(cfg, gitVersion)
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+
+		// Set up our logging. If Sentry is enabled, we will use our custom log
+		// handler that logs to stdout and forwards any error messages to Sentry
+		// for collection. Otherwise, logs will only be posted to stdout.
+		var logHandler log.Handler
+		if cfg.SentryEnable {
+			err := sentry.Init(sentry.ClientOptions{
+				Dsn:              cfg.SentryDsn,
+				Environment:      cfg.EthNetworkName,
+				Release:          "batch-submitter@" + gitVersion,
+				TracesSampleRate: traceRateToFloat64(cfg.SentryTraceRate),
+				Debug:            false,
+			})
+			if err != nil {
+				return err
+			}
+
+			logHandler = SentryStreamHandler(os.Stdout, log.TerminalFormat(true))
+		} else {
+			logHandler = log.StreamHandler(os.Stdout, log.TerminalFormat(true))
+		}
+
+		logLevel, err := log.LvlFromString(cfg.LogLevel)
 		if err != nil {
-			log.Error("Unable to create batch submitter", "error", err)
 			return err
 		}
 
-		log.Info("Starting batch submitter")
+		log.Root().SetHandler(log.LvlFilterHandler(logLevel, logHandler))
 
-		if err := batchSubmitter.Start(); err != nil {
+		// Parse sequencer private key and CTC contract address.
+		sequencerPrivKey, ctcAddress, err := parseWalletPrivKeyAndContractAddr(
+			"Sequencer", cfg.Mnemonic, cfg.SequencerHDPath,
+			cfg.SequencerPrivateKey, cfg.CTCAddress,
+		)
+		if err != nil {
 			return err
 		}
-		defer batchSubmitter.Stop()
 
-		log.Info("Batch submitter started")
+		// Parse proposer private key and SCC contract address.
+		proposerPrivKey, sccAddress, err := parseWalletPrivKeyAndContractAddr(
+			"Proposer", cfg.Mnemonic, cfg.ProposerHDPath,
+			cfg.ProposerPrivateKey, cfg.SCCAddress,
+		)
+		if err != nil {
+			return err
+		}
 
-		<-(chan struct{})(nil)
+		// Connect to L1 and L2 providers. Perform these last since they are the
+		// most expensive.
+		l1Client, err := dialL1EthClientWithTimeout(ctx, cfg.L1EthRpc, cfg.DisableHTTP2)
+		if err != nil {
+			return err
+		}
 
-		return nil
-	}
-}
+		l2Client, err := dialL2EthClientWithTimeout(ctx, cfg.L2EthRpc, cfg.DisableHTTP2)
+		if err != nil {
+			return err
+		}
 
-// BatchSubmitter is a service that configures the necessary resources for
-// running the TxBatchSubmitter and StateBatchSubmitter sub-services.
-type BatchSubmitter struct {
-	ctx              context.Context
-	cfg              Config
-	l1Client         *ethclient.Client
-	l2Client         *l2ethclient.Client
-	sequencerPrivKey *ecdsa.PrivateKey
-	proposerPrivKey  *ecdsa.PrivateKey
-	ctcAddress       common.Address
-	sccAddress       common.Address
-
-	batchTxService    *Service
-	batchStateService *Service
-}
+		if cfg.MetricsServerEnable {
+			go runMetricsServer(cfg.MetricsHostname, cfg.MetricsPort)
+		}
 
-// NewBatchSubmitter initializes the BatchSubmitter, gathering any resources
-// that will be needed by the TxBatchSubmitter and StateBatchSubmitter
-// sub-services.
-func NewBatchSubmitter(cfg Config, gitVersion string) (*BatchSubmitter, error) {
-	ctx := context.Background()
-
-	// Set up our logging. If Sentry is enabled, we will use our custom
-	// log handler that logs to stdout and forwards any error messages to
-	// Sentry for collection. Otherwise, logs will only be posted to stdout.
-	var logHandler log.Handler
-	if cfg.SentryEnable {
-		err := sentry.Init(sentry.ClientOptions{
-			Dsn:              cfg.SentryDsn,
-			Environment:      cfg.EthNetworkName,
-			Release:          "batch-submitter@" + gitVersion,
-			TracesSampleRate: traceRateToFloat64(cfg.SentryTraceRate),
-			Debug:            false,
-		})
+		chainID, err := l1Client.ChainID(ctx)
 		if err != nil {
-			return nil, err
+			return err
 		}
 
-		logHandler = SentryStreamHandler(os.Stdout, log.TerminalFormat(true))
-	} else {
-		logHandler = log.StreamHandler(os.Stdout, log.TerminalFormat(true))
-	}
-
-	logLevel, err := log.LvlFromString(cfg.LogLevel)
-	if err != nil {
-		return nil, err
-	}
+		txManagerConfig := txmgr.Config{
+			ResubmissionTimeout:  cfg.ResubmissionTimeout,
+			ReceiptQueryInterval: time.Second,
+			NumConfirmations:     cfg.NumConfirmations,
+		}
 
-	log.Root().SetHandler(log.LvlFilterHandler(logLevel, logHandler))
+		var services []*Service
+		if cfg.RunTxBatchSubmitter {
+			batchTxDriver, err := sequencer.NewDriver(sequencer.Config{
+				Name:        "Sequencer",
+				L1Client:    l1Client,
+				L2Client:    l2Client,
+				BlockOffset: cfg.BlockOffset,
+				MaxTxSize:   cfg.MaxL1TxSize,
+				CTCAddr:     ctcAddress,
+				ChainID:     chainID,
+				PrivKey:     sequencerPrivKey,
+			})
+			if err != nil {
+				return err
+			}
 
-	// Parse sequencer private key and CTC contract address.
-	sequencerPrivKey, ctcAddress, err := parseWalletPrivKeyAndContractAddr(
-		"Sequencer", cfg.Mnemonic, cfg.SequencerHDPath,
-		cfg.SequencerPrivateKey, cfg.CTCAddress,
-	)
-	if err != nil {
-		return nil, err
-	}
+			services = append(services, NewService(ServiceConfig{
+				Context:         ctx,
+				Driver:          batchTxDriver,
+				PollInterval:    cfg.PollInterval,
+				ClearPendingTx:  cfg.ClearPendingTxs,
+				L1Client:        l1Client,
+				TxManagerConfig: txManagerConfig,
+			}))
+		}
 
-	// Parse proposer private key and SCC contract address.
-	proposerPrivKey, sccAddress, err := parseWalletPrivKeyAndContractAddr(
-		"Proposer", cfg.Mnemonic, cfg.ProposerHDPath,
-		cfg.ProposerPrivateKey, cfg.SCCAddress,
-	)
-	if err != nil {
-		return nil, err
-	}
+		if cfg.RunStateBatchSubmitter {
+			batchStateDriver, err := proposer.NewDriver(proposer.Config{
+				Name:        "Proposer",
+				L1Client:    l1Client,
+				L2Client:    l2Client,
+				BlockOffset: cfg.BlockOffset,
+				MaxTxSize:   cfg.MaxL1TxSize,
+				SCCAddr:     sccAddress,
+				CTCAddr:     ctcAddress,
+				ChainID:     chainID,
+				PrivKey:     proposerPrivKey,
+			})
+			if err != nil {
+				return err
+			}
 
-	// Connect to L1 and L2 providers. Perform these last since they are the
-	// most expensive.
-	l1Client, err := dialL1EthClientWithTimeout(ctx, cfg.L1EthRpc, cfg.DisableHTTP2)
-	if err != nil {
-		return nil, err
-	}
+			services = append(services, NewService(ServiceConfig{
+				Context:         ctx,
+				Driver:          batchStateDriver,
+				PollInterval:    cfg.PollInterval,
+				ClearPendingTx:  cfg.ClearPendingTxs,
+				L1Client:        l1Client,
+				TxManagerConfig: txManagerConfig,
+			}))
+		}
 
-	l2Client, err := dialL2EthClientWithTimeout(ctx, cfg.L2EthRpc, cfg.DisableHTTP2)
-	if err != nil {
-		return nil, err
-	}
+		batchSubmitter, err := NewBatchSubmitter(ctx, cancel, services)
+		if err != nil {
+			log.Error("Unable to create batch submitter", "error", err)
+			return err
+		}
 
-	if cfg.MetricsServerEnable {
-		go runMetricsServer(cfg.MetricsHostname, cfg.MetricsPort)
-	}
+		log.Info("Starting batch submitter")
 
-	chainID, err := l1Client.ChainID(ctx)
-	if err != nil {
-		return nil, err
-	}
+		if err := batchSubmitter.Start(); err != nil {
+			return err
+		}
+		defer batchSubmitter.Stop()
 
-	txManagerConfig := txmgr.Config{
-		ResubmissionTimeout:  cfg.ResubmissionTimeout,
-		ReceiptQueryInterval: time.Second,
-		NumConfirmations:     cfg.NumConfirmations,
-	}
+		log.Info("Batch submitter started")
 
-	var batchTxService *Service
-	if cfg.RunTxBatchSubmitter {
-		batchTxDriver, err := sequencer.NewDriver(sequencer.Config{
-			Name:        "Sequencer",
-			L1Client:    l1Client,
-			L2Client:    l2Client,
-			BlockOffset: cfg.BlockOffset,
-			MaxTxSize:   cfg.MaxL1TxSize,
-			CTCAddr:     ctcAddress,
-			ChainID:     chainID,
-			PrivKey:     sequencerPrivKey,
-		})
-		if err != nil {
-			return nil, err
-		}
+		<-(chan struct{})(nil)
 
-		batchTxService = NewService(ServiceConfig{
-			Context:         ctx,
-			Driver:          batchTxDriver,
-			PollInterval:    cfg.PollInterval,
-			ClearPendingTx:  cfg.ClearPendingTxs,
-			L1Client:        l1Client,
-			TxManagerConfig: txManagerConfig,
-		})
+		return nil
 	}
+}
 
-	var batchStateService *Service
-	if cfg.RunStateBatchSubmitter {
-		batchStateDriver, err := proposer.NewDriver(proposer.Config{
-			Name:        "Proposer",
-			L1Client:    l1Client,
-			L2Client:    l2Client,
-			BlockOffset: cfg.BlockOffset,
-			MaxTxSize:   cfg.MaxL1TxSize,
-			SCCAddr:     sccAddress,
-			CTCAddr:     ctcAddress,
-			ChainID:     chainID,
-			PrivKey:     proposerPrivKey,
-		})
-		if err != nil {
-			return nil, err
-		}
+// BatchSubmitter is a service that configures the necessary resources for
+// running the TxBatchSubmitter and StateBatchSubmitter sub-services.
+type BatchSubmitter struct {
+	ctx      context.Context
+	services []*Service
+	cancel   func()
+}
 
-		batchStateService = NewService(ServiceConfig{
-			Context:         ctx,
-			Driver:          batchStateDriver,
-			PollInterval:    cfg.PollInterval,
-			ClearPendingTx:  cfg.ClearPendingTxs,
-			L1Client:        l1Client,
-			TxManagerConfig: txManagerConfig,
-		})
-	}
+// NewBatchSubmitter initializes the BatchSubmitter, gathering any resources
+// that will be needed by the TxBatchSubmitter and StateBatchSubmitter
+// sub-services.
+func NewBatchSubmitter(
+	ctx context.Context,
+	cancel func(),
+	services []*Service,
+) (*BatchSubmitter, error) {
 
 	return &BatchSubmitter{
-		ctx:               ctx,
-		cfg:               cfg,
-		l1Client:          l1Client,
-		l2Client:          l2Client,
-		sequencerPrivKey:  sequencerPrivKey,
-		proposerPrivKey:   proposerPrivKey,
-		ctcAddress:        ctcAddress,
-		sccAddress:        sccAddress,
-		batchTxService:    batchTxService,
-		batchStateService: batchStateService,
+		ctx:      ctx,
+		services: services,
+		cancel:   cancel,
 	}, nil
 }
 
 func (b *BatchSubmitter) Start() error {
-	if b.cfg.RunTxBatchSubmitter {
-		if err := b.batchTxService.Start(); err != nil {
-			return err
-		}
-	}
-	if b.cfg.RunStateBatchSubmitter {
-		if err := b.batchStateService.Start(); err != nil {
+	for _, service := range b.services {
+		if err := service.Start(); err != nil {
 			return err
 		}
 	}
@@ -249,11 +234,9 @@ func (b *BatchSubmitter) Start() error {
 }
 
 func (b *BatchSubmitter) Stop() {
-	if b.cfg.RunTxBatchSubmitter {
-		_ = b.batchTxService.Stop()
-	}
-	if b.cfg.RunStateBatchSubmitter {
-		_ = b.batchStateService.Stop()
+	b.cancel()
+	for _, service := range b.services {
+		_ = service.Stop()
 	}
 }