Merge pull request #8040 from joohhnnn/proposer

op-proposer: service lifecycle cleanup

op-e2e/actions/l2_proposer.go

@@ -56,18 +56,22 @@ func (f fakeTxMgr) Send(_ context.Context, _ txmgr.TxCandidate) (*types.Receipt,
 }
 
 func NewL2Proposer(t Testing, log log.Logger, cfg *ProposerCfg, l1 *ethclient.Client, rollupCl *sources.RollupClient) *L2Proposer {
-	proposerCfg := proposer.Config{
-		L2OutputOracleAddr: cfg.OutputOracleAddr,
+	proposerConfig := proposer.ProposerConfig{
 		PollInterval:       time.Second,
 		NetworkTimeout:     time.Second,
-		L1Client:           l1,
-		RollupClient:       rollupCl,
+		L2OutputOracleAddr: cfg.OutputOracleAddr,
 		AllowNonFinalized:  cfg.AllowNonFinalized,
-		// We use custom signing here instead of using the transaction manager.
-		TxManager: fakeTxMgr{from: crypto.PubkeyToAddress(cfg.ProposerKey.PublicKey)},
+	}
+	driverSetup := proposer.DriverSetup{
+		Log:          log,
+		Metr:         metrics.NoopMetrics,
+		Cfg:          proposerConfig,
+		Txmgr:        fakeTxMgr{from: crypto.PubkeyToAddress(cfg.ProposerKey.PublicKey)},
+		L1Client:     l1,
+		RollupClient: rollupCl,
 	}
 
-	dr, err := proposer.NewL2OutputSubmitter(proposerCfg, log, metrics.NoopMetrics)
+	dr, err := proposer.NewL2OutputSubmitter(driverSetup)
 	require.NoError(t, err)
 	contract, err := bindings.NewL2OutputOracleCaller(cfg.OutputOracleAddr, l1)
 	require.NoError(t, err)

op-e2e/faultproof_test.go

@@ -531,8 +531,8 @@ func setupDisputeGameForInvalidOutputRoot(t *testing.T, outputRoot common.Hash)
 	// Wait for one valid output root to be submitted
 	l2oo.WaitForProposals(ctx, 1)
 
-	// Stop the honest output submitter so we can publish invalid outputs
-	sys.L2OutputSubmitter.Stop()
+	err := sys.L2OutputSubmitter.Driver().StopL2OutputSubmitting()
+	require.NoError(t, err)
 	sys.L2OutputSubmitter = nil
 
 	// Submit an invalid output root

op-e2e/setup.go

@@ -52,7 +52,6 @@ import (
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/driver"
-	proposermetrics "github.com/ethereum-optimism/optimism/op-proposer/metrics"
 	l2os "github.com/ethereum-optimism/optimism/op-proposer/proposer"
 	"github.com/ethereum-optimism/optimism/op-service/cliapp"
 	"github.com/ethereum-optimism/optimism/op-service/clock"
@@ -260,7 +259,7 @@ type System struct {
 	Clients           map[string]*ethclient.Client
 	RawClients        map[string]*rpc.Client
 	RollupNodes       map[string]*rollupNode.OpNode
-	L2OutputSubmitter *l2os.L2OutputSubmitter
+	L2OutputSubmitter *l2os.ProposerService
 	BatchSubmitter    *bss.BatcherService
 	Mocknet           mocknet.Mocknet
 
@@ -283,7 +282,7 @@ func (sys *System) Close() {
 	postCancel() // immediate shutdown, no allowance for idling
 
 	if sys.L2OutputSubmitter != nil {
-		sys.L2OutputSubmitter.Stop()
+		_ = sys.L2OutputSubmitter.Kill()
 	}
 	if sys.BatchSubmitter != nil {
 		_ = sys.BatchSubmitter.Kill()
@@ -679,7 +678,7 @@ func (cfg SystemConfig) Start(t *testing.T, _opts ...SystemConfigOption) (*Syste
 	}
 
 	// L2Output Submitter
-	sys.L2OutputSubmitter, err = l2os.NewL2OutputSubmitterFromCLIConfig(l2os.CLIConfig{
+	proposerCLIConfig := &l2os.CLIConfig{
 		L1EthRpc:          sys.EthInstances["l1"].WSEndpoint(),
 		RollupRpc:         sys.RollupNodes["sequencer"].HTTPEndpoint(),
 		L2OOAddress:       config.L1Deployments.L2OutputOracleProxy.Hex(),
@@ -690,14 +689,15 @@ func (cfg SystemConfig) Start(t *testing.T, _opts ...SystemConfigOption) (*Syste
 			Level:  log.LvlInfo,
 			Format: oplog.FormatText,
 		},
-	}, sys.cfg.Loggers["proposer"], proposermetrics.NoopMetrics)
+	}
+	proposer, err := l2os.ProposerServiceFromCLIConfig(context.Background(), "0.0.1", proposerCLIConfig, sys.cfg.Loggers["proposer"])
 	if err != nil {
 		return nil, fmt.Errorf("unable to setup l2 output submitter: %w", err)
 	}
-
-	if err := sys.L2OutputSubmitter.Start(); err != nil {
+	if err := proposer.Start(context.Background()); err != nil {
 		return nil, fmt.Errorf("unable to start l2 output submitter: %w", err)
 	}
+	sys.L2OutputSubmitter = proposer
 
 	var batchType uint = derive.SingularBatchType
 	if cfg.DeployConfig.L2GenesisSpanBatchTimeOffset != nil && *cfg.DeployConfig.L2GenesisSpanBatchTimeOffset == hexutil.Uint64(0) {

op-e2e/system_fpp_test.go

@@ -290,7 +290,8 @@ func testFaultProofProgramScenario(t *testing.T, ctx context.Context, sys *Syste
 	t.Log("Shutting down network")
 	// Shutdown the nodes from the actual chain. Should now be able to run using only the pre-fetched data.
 	require.NoError(t, sys.BatchSubmitter.Kill())
-	sys.L2OutputSubmitter.Stop()
+	err = sys.L2OutputSubmitter.Driver().StopL2OutputSubmitting()
+	require.NoError(t, err)
 	sys.L2OutputSubmitter = nil
 	for _, node := range sys.EthInstances {
 		node.Close()

op-proposer/cmd/main.go

@@ -30,7 +30,7 @@ func main() {
 	app.Name = "op-proposer"
 	app.Usage = "L2Output Submitter"
 	app.Description = "Service for generating and submitting L2 Output checkpoints to the L2OutputOracle contract"
-	app.Action = curryMain(Version)
+	app.Action = cliapp.LifecycleCmd(proposer.Main(Version))
 	app.Commands = []*cli.Command{
 		{
 			Name:        "doc",
@@ -43,11 +43,3 @@ func main() {
 		log.Crit("Application failed", "message", err)
 	}
 }
-
-// curryMain transforms the proposer.Main function into an app.Action
-// This is done to capture the Version of the proposer.
-func curryMain(version string) func(ctx *cli.Context) error {
-	return func(ctx *cli.Context) error {
-		return proposer.Main(version, ctx)
-	}
-}

op-proposer/metrics/metrics.go

 package metrics
 
 import (
-	"context"
+	"io"
 
 	"github.com/prometheus/client_golang/prometheus"
 
@@ -10,13 +10,15 @@ import (
 	"github.com/ethereum/go-ethereum/log"
 
 	"github.com/ethereum-optimism/optimism/op-service/eth"
-	"github.com/ethereum-optimism/optimism/op-service/httputil"
 	opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics"
 	txmetrics "github.com/ethereum-optimism/optimism/op-service/txmgr/metrics"
 )
 
 const Namespace = "op_proposer"
 
+// implements the Registry getter, for metrics HTTP server to hook into
+var _ opmetrics.RegistryMetricer = (*Metrics)(nil)
+
 type Metricer interface {
 	RecordInfo(version string)
 	RecordUp()
@@ -27,6 +29,10 @@ type Metricer interface {
 	// Record Tx metrics
 	txmetrics.TxMetricer
 
+	opmetrics.RPCMetricer
+
+	StartBalanceMetrics(l log.Logger, client *ethclient.Client, account common.Address) io.Closer
+
 	RecordL2BlocksProposed(l2ref eth.L2BlockRef)
 }
 
@@ -78,18 +84,12 @@ func NewMetrics(procName string) *Metrics {
 	}
 }
 
-func (m *Metrics) Start(host string, port int) (*httputil.HTTPServer, error) {
-	return opmetrics.StartServer(m.registry, host, port)
+func (m *Metrics) Registry() *prometheus.Registry {
+	return m.registry
 }
 
-func (m *Metrics) StartBalanceMetrics(ctx context.Context,
-	l log.Logger, client *ethclient.Client, account common.Address) {
-	// TODO(7684): util was refactored to close, but ctx is still being used by caller for shutdown
-	balanceMetric := opmetrics.LaunchBalanceMetrics(l, m.registry, m.ns, client, account)
-	go func() {
-		<-ctx.Done()
-		_ = balanceMetric.Close()
-	}()
+func (m *Metrics) StartBalanceMetrics(l log.Logger, client *ethclient.Client, account common.Address) io.Closer {
+	return opmetrics.LaunchBalanceMetrics(l, m.registry, m.ns, client, account)
 }
 
 // RecordInfo sets a pseudo-metric that contains versioning and

op-proposer/metrics/noop.go

 package metrics
 
 import (
+	"io"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/log"
+
 	"github.com/ethereum-optimism/optimism/op-service/eth"
 	opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics"
 	txmetrics "github.com/ethereum-optimism/optimism/op-service/txmgr/metrics"
@@ -9,6 +15,7 @@ import (
 type noopMetrics struct {
 	opmetrics.NoopRefMetrics
 	txmetrics.NoopTxMetrics
+	opmetrics.NoopRPCMetrics
 }
 
 var NoopMetrics Metricer = new(noopMetrics)
@@ -17,3 +24,7 @@ func (*noopMetrics) RecordInfo(version string) {}
 func (*noopMetrics) RecordUp()                 {}
 
 func (*noopMetrics) RecordL2BlocksProposed(l2ref eth.L2BlockRef) {}
+
+func (*noopMetrics) StartBalanceMetrics(log.Logger, *ethclient.Client, common.Address) io.Closer {
+	return nil
+}

op-proposer/proposer/config.go

@@ -3,13 +3,9 @@ package proposer
 import (
 	"time"
 
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/urfave/cli/v2"
 
 	"github.com/ethereum-optimism/optimism/op-proposer/flags"
-	"github.com/ethereum-optimism/optimism/op-service/sources"
-
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
 	opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics"
 	oppprof "github.com/ethereum-optimism/optimism/op-service/pprof"
@@ -17,18 +13,6 @@ import (
 	"github.com/ethereum-optimism/optimism/op-service/txmgr"
 )
 
-// Config contains the well typed fields that are used to initialize the output submitter.
-// It is intended for programmatic use.
-type Config struct {
-	L2OutputOracleAddr common.Address
-	PollInterval       time.Duration
-	NetworkTimeout     time.Duration
-	TxManager          txmgr.TxManager
-	L1Client           *ethclient.Client
-	RollupClient       *sources.RollupClient
-	AllowNonFinalized  bool
-}
-
 // CLIConfig is a well typed config that is parsed from the CLI params.
 // This also contains config options for auxiliary services.
 // It is transformed into a `Config` before the L2 output submitter is started.
@@ -63,7 +47,7 @@ type CLIConfig struct {
 	PprofConfig oppprof.CLIConfig
 }
 
-func (c CLIConfig) Check() error {
+func (c *CLIConfig) Check() error {
 	if err := c.RPCConfig.Check(); err != nil {
 		return err
 	}
@@ -80,8 +64,8 @@ func (c CLIConfig) Check() error {
 }
 
 // NewConfig parses the Config from the provided flags or environment variables.
-func NewConfig(ctx *cli.Context) CLIConfig {
-	return CLIConfig{
+func NewConfig(ctx *cli.Context) *CLIConfig {
+	return &CLIConfig{
 		// Required Flags
 		L1EthRpc:     ctx.String(flags.L1EthRpcFlag.Name),
 		RollupRpc:    ctx.String(flags.RollupRpcFlag.Name),

op-proposer/proposer/rpc/api.go

+package rpc
+
+import (
+	"context"
+
+	"github.com/ethereum/go-ethereum/log"
+	gethrpc "github.com/ethereum/go-ethereum/rpc"
+
+	"github.com/ethereum-optimism/optimism/op-service/metrics"
+	"github.com/ethereum-optimism/optimism/op-service/rpc"
+)
+
+type ProposerDriver interface {
+	StartL2OutputSubmitting() error
+	StopL2OutputSubmitting() error
+}
+
+type adminAPI struct {
+	*rpc.CommonAdminAPI
+	b ProposerDriver
+}
+
+func NewAdminAPI(dr ProposerDriver, m metrics.RPCMetricer, log log.Logger) *adminAPI {
+	return &adminAPI{
+		CommonAdminAPI: rpc.NewCommonAdminAPI(m, log),
+		b:              dr,
+	}
+}
+
+func GetAdminAPI(api *adminAPI) gethrpc.API {
+	return gethrpc.API{
+		Namespace: "admin",
+		Service:   api,
+	}
+}
+
+func (a *adminAPI) StartProposer(_ context.Context) error {
+	return a.b.StartL2OutputSubmitting()
+}
+
+func (a *adminAPI) StopProposer(ctx context.Context) error {
+	return a.b.StopL2OutputSubmitting()
+}

op-proposer/proposer/service.go

+package proposer
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"strconv"
+	"sync/atomic"
+	"time"
+
+	"github.com/ethereum-optimism/optimism/op-proposer/metrics"
+	"github.com/ethereum-optimism/optimism/op-proposer/proposer/rpc"
+	opservice "github.com/ethereum-optimism/optimism/op-service"
+	"github.com/ethereum-optimism/optimism/op-service/cliapp"
+	"github.com/ethereum-optimism/optimism/op-service/dial"
+	"github.com/ethereum-optimism/optimism/op-service/httputil"
+	opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics"
+	oppprof "github.com/ethereum-optimism/optimism/op-service/pprof"
+	oprpc "github.com/ethereum-optimism/optimism/op-service/rpc"
+	"github.com/ethereum-optimism/optimism/op-service/sources"
+	"github.com/ethereum-optimism/optimism/op-service/txmgr"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/log"
+)
+
+type ProposerConfig struct {
+	// How frequently to poll L2 for new finalized outputs
+	PollInterval   time.Duration
+	NetworkTimeout time.Duration
+
+	L2OutputOracleAddr common.Address
+	// AllowNonFinalized enables the proposal of safe, but non-finalized L2 blocks.
+	// The L1 block-hash embedded in the proposal TX is checked and should ensure the proposal
+	// is never valid on an alternative L1 chain that would produce different L2 data.
+	// This option is not necessary when higher proposal latency is acceptable and L1 is healthy.
+	AllowNonFinalized bool
+}
+
+type ProposerService struct {
+	Log     log.Logger
+	Metrics metrics.Metricer
+
+	ProposerConfig
+
+	TxManager    txmgr.TxManager
+	L1Client     *ethclient.Client
+	RollupClient *sources.RollupClient
+
+	driver *L2OutputSubmitter
+
+	Version string
+
+	pprofSrv   *httputil.HTTPServer
+	metricsSrv *httputil.HTTPServer
+	rpcServer  *oprpc.Server
+
+	balanceMetricer io.Closer
+
+	stopped atomic.Bool
+}
+
+// ProposerServiceFromCLIConfig creates a new ProposerService from a CLIConfig.
+// The service components are fully started, except for the driver,
+// which will not be submitting state (if it was configured to) until the Start part of the lifecycle.
+func ProposerServiceFromCLIConfig(ctx context.Context, version string, cfg *CLIConfig, log log.Logger) (*ProposerService, error) {
+	var ps ProposerService
+	if err := ps.initFromCLIConfig(ctx, version, cfg, log); err != nil {
+		return nil, errors.Join(err, ps.Stop(ctx)) // try to clean up our failed initialization attempt
+	}
+	return &ps, nil
+}
+
+func (ps *ProposerService) initFromCLIConfig(ctx context.Context, version string, cfg *CLIConfig, log log.Logger) error {
+	ps.Version = version
+	ps.Log = log
+
+	ps.initMetrics(cfg)
+
+	ps.PollInterval = cfg.PollInterval
+	ps.NetworkTimeout = cfg.TxMgrConfig.NetworkTimeout
+	ps.AllowNonFinalized = cfg.AllowNonFinalized
+
+	if err := ps.initRPCClients(ctx, cfg); err != nil {
+		return err
+	}
+	if err := ps.initTxManager(cfg); err != nil {
+		return fmt.Errorf("failed to init Tx manager: %w", err)
+	}
+	ps.initBalanceMonitor(cfg)
+	if err := ps.initMetricsServer(cfg); err != nil {
+		return fmt.Errorf("failed to start metrics server: %w", err)
+	}
+	if err := ps.initPProf(cfg); err != nil {
+		return fmt.Errorf("failed to start pprof server: %w", err)
+	}
+	if err := ps.initL2ooAddress(cfg); err != nil {
+		return fmt.Errorf("failed to init L2ooAddress: %w", err)
+	}
+	if err := ps.initDriver(); err != nil {
+		return fmt.Errorf("failed to init Driver: %w", err)
+	}
+	if err := ps.initRPCServer(cfg); err != nil {
+		return fmt.Errorf("failed to start RPC server: %w", err)
+	}
+
+	ps.Metrics.RecordInfo(ps.Version)
+	ps.Metrics.RecordUp()
+	return nil
+}
+
+func (ps *ProposerService) initRPCClients(ctx context.Context, cfg *CLIConfig) error {
+	l1Client, err := dial.DialEthClientWithTimeout(ctx, dial.DefaultDialTimeout, ps.Log, cfg.L1EthRpc)
+	if err != nil {
+		return fmt.Errorf("failed to dial L1 RPC: %w", err)
+	}
+	ps.L1Client = l1Client
+
+	rollupClient, err := dial.DialRollupClientWithTimeout(ctx, dial.DefaultDialTimeout, ps.Log, cfg.RollupRpc)
+	if err != nil {
+		return fmt.Errorf("failed to dial L2 rollup-client RPC: %w", err)
+	}
+	ps.RollupClient = rollupClient
+	return nil
+}
+
+func (ps *ProposerService) initMetrics(cfg *CLIConfig) {
+	if cfg.MetricsConfig.Enabled {
+		procName := "default"
+		ps.Metrics = metrics.NewMetrics(procName)
+	} else {
+		ps.Metrics = metrics.NoopMetrics
+	}
+}
+
+// initBalanceMonitor depends on Metrics, L1Client and TxManager to start background-monitoring of the Proposer balance.
+func (ps *ProposerService) initBalanceMonitor(cfg *CLIConfig) {
+	if cfg.MetricsConfig.Enabled {
+		ps.balanceMetricer = ps.Metrics.StartBalanceMetrics(ps.Log, ps.L1Client, ps.TxManager.From())
+	}
+}
+
+func (ps *ProposerService) initTxManager(cfg *CLIConfig) error {
+	txManager, err := txmgr.NewSimpleTxManager("proposer", ps.Log, ps.Metrics, cfg.TxMgrConfig)
+	if err != nil {
+		return err
+	}
+	ps.TxManager = txManager
+	return nil
+}
+
+func (ps *ProposerService) initPProf(cfg *CLIConfig) error {
+	if !cfg.PprofConfig.Enabled {
+		return nil
+	}
+	log.Debug("starting pprof server", "addr", net.JoinHostPort(cfg.PprofConfig.ListenAddr, strconv.Itoa(cfg.PprofConfig.ListenPort)))
+	srv, err := oppprof.StartServer(cfg.PprofConfig.ListenAddr, cfg.PprofConfig.ListenPort)
+	if err != nil {
+		return err
+	}
+	ps.pprofSrv = srv
+	log.Info("started pprof server", "addr", srv.Addr())
+	return nil
+}
+
+func (ps *ProposerService) initMetricsServer(cfg *CLIConfig) error {
+	if !cfg.MetricsConfig.Enabled {
+		ps.Log.Info("metrics disabled")
+		return nil
+	}
+	m, ok := ps.Metrics.(opmetrics.RegistryMetricer)
+	if !ok {
+		return fmt.Errorf("metrics were enabled, but metricer %T does not expose registry for metrics-server", ps.Metrics)
+	}
+	ps.Log.Debug("starting metrics server", "addr", cfg.MetricsConfig.ListenAddr, "port", cfg.MetricsConfig.ListenPort)
+	metricsSrv, err := opmetrics.StartServer(m.Registry(), cfg.MetricsConfig.ListenAddr, cfg.MetricsConfig.ListenPort)
+	if err != nil {
+		return fmt.Errorf("failed to start metrics server: %w", err)
+	}
+	ps.Log.Info("started metrics server", "addr", metricsSrv.Addr())
+	ps.metricsSrv = metricsSrv
+	return nil
+}
+
+func (ps *ProposerService) initL2ooAddress(cfg *CLIConfig) error {
+	l2ooAddress, err := opservice.ParseAddress(cfg.L2OOAddress)
+	if err != nil {
+		return nil
+	}
+	ps.L2OutputOracleAddr = l2ooAddress
+	return nil
+}
+
+func (ps *ProposerService) initDriver() error {
+	driver, err := NewL2OutputSubmitter(DriverSetup{
+		Log:          ps.Log,
+		Metr:         ps.Metrics,
+		Cfg:          ps.ProposerConfig,
+		Txmgr:        ps.TxManager,
+		L1Client:     ps.L1Client,
+		RollupClient: ps.RollupClient,
+	})
+	if err != nil {
+		return err
+	}
+	ps.driver = driver
+	return nil
+}
+
+func (ps *ProposerService) initRPCServer(cfg *CLIConfig) error {
+	server := oprpc.NewServer(
+		cfg.RPCConfig.ListenAddr,
+		cfg.RPCConfig.ListenPort,
+		ps.Version,
+		oprpc.WithLogger(ps.Log),
+	)
+	if cfg.RPCConfig.EnableAdmin {
+		adminAPI := rpc.NewAdminAPI(ps.driver, ps.Metrics, ps.Log)
+		server.AddAPI(rpc.GetAdminAPI(adminAPI))
+		ps.Log.Info("Admin RPC enabled")
+	}
+	ps.Log.Info("Starting JSON-RPC server")
+	if err := server.Start(); err != nil {
+		return fmt.Errorf("unable to start RPC server: %w", err)
+	}
+	ps.rpcServer = server
+	return nil
+}
+
+// Start runs once upon start of the proposer lifecycle,
+// and starts L2Output-submission work if the proposer is configured to start submit data on startup.
+func (ps *ProposerService) Start(_ context.Context) error {
+	ps.driver.Log.Info("Starting Proposer")
+
+	return ps.driver.StartL2OutputSubmitting()
+}
+
+func (ps *ProposerService) Stopped() bool {
+	return ps.stopped.Load()
+}
+
+// Kill is a convenience method to forcefully, non-gracefully, stop the ProposerService.
+func (ps *ProposerService) Kill() error {
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+	return ps.Stop(ctx)
+}
+
+// Stop fully stops the L2Output-submitter and all its resources gracefully. After stopping, it cannot be restarted.
+// See driver.StopL2OutputSubmitting to temporarily stop the L2Output submitter.
+func (ps *ProposerService) Stop(ctx context.Context) error {
+	if ps.stopped.Load() {
+		return errors.New("already stopped")
+	}
+	ps.Log.Info("Stopping Proposer")
+
+	var result error
+	if ps.driver != nil {
+		if err := ps.driver.StopL2OutputSubmittingIfRunning(); err != nil {
+			result = errors.Join(result, fmt.Errorf("failed to stop L2Output submitting: %w", err))
+		}
+	}
+
+	if ps.rpcServer != nil {
+		// TODO(7685): the op-service RPC server is not built on top of op-service httputil Server, and has poor shutdown
+		if err := ps.rpcServer.Stop(); err != nil {
+			result = errors.Join(result, fmt.Errorf("failed to stop RPC server: %w", err))
+		}
+	}
+	if ps.pprofSrv != nil {
+		if err := ps.pprofSrv.Stop(ctx); err != nil {
+			result = errors.Join(result, fmt.Errorf("failed to stop PProf server: %w", err))
+		}
+	}
+	if ps.balanceMetricer != nil {
+		if err := ps.balanceMetricer.Close(); err != nil {
+			result = errors.Join(result, fmt.Errorf("failed to close balance metricer: %w", err))
+		}
+	}
+	if ps.metricsSrv != nil {
+		if err := ps.metricsSrv.Stop(ctx); err != nil {
+			result = errors.Join(result, fmt.Errorf("failed to stop metrics server: %w", err))
+		}
+	}
+
+	if ps.L1Client != nil {
+		ps.L1Client.Close()
+	}
+
+	if ps.RollupClient != nil {
+		ps.RollupClient.Close()
+	}
+
+	if result == nil {
+		ps.stopped.Store(true)
+		ps.Log.Info("L2Output Submitter stopped")
+	}
+
+	return result
+}
+
+var _ cliapp.Lifecycle = (*ProposerService)(nil)
+
+// Driver returns the handler on the L2Output-submitter driver element,
+// to start/stop/restart the L2Output-submission work, for use in testing.
+func (ps *ProposerService) Driver() rpc.ProposerDriver {
+	return ps.driver
+}