Merge branch 'aj/create-cannon' of github.com:ethereum-optimism/optimism into aj/create-cannon

.circleci/config.yml

@@ -1854,6 +1854,16 @@ workflows:
           context:
             - oplabs-gcr
             - slack
+      - docker-build:
+          name: contracts-bedrock-docker-publish
+          docker_name: contracts-bedrock
+          docker_tags: <<pipeline.git.revision>>,<<pipeline.git.branch>>
+          resource_class: xlarge
+          requires: [ 'chain-mon-docker-publish' ] # use the cached base image
+          publish: true
+          context:
+            - oplabs-gcr
+            - slack
       - docker-build:
           name: ufm-metamask-docker-publish
           docker_name: ufm-metamask

Makefile

@@ -39,6 +39,15 @@ golang-docker:
 			op-node op-batcher op-proposer op-challenger
 .PHONY: golang-docker
 
+contracts-bedrock-docker:
+	IMAGE_TAGS=$$(git rev-parse HEAD),latest \
+	docker buildx bake \
+			--progress plain \
+			--load \
+			-f docker-bake.hcl \
+		  contracts-bedrock
+.PHONY: contracts-bedrock-docker
+
 submodules:
 	git submodule update --init --recursive
 .PHONY: submodules

cannon/cmd/json.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"io"
 	"os"
-	"path"
 
 	"github.com/ethereum-optimism/optimism/op-service/ioutil"
 )
@@ -35,18 +34,16 @@ func writeJSON[X any](outputPath string, value X) error {
 	var out io.Writer
 	finish := func() error { return nil }
 	if outputPath != "-" {
-		// Write to a tmp file but reserve the file extension if present
-		tmpPath := outputPath + "-tmp" + path.Ext(outputPath)
-		f, err := ioutil.OpenCompressed(tmpPath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0755)
+		f, err := ioutil.NewAtomicWriterCompressed(outputPath, 0755)
 		if err != nil {
 			return fmt.Errorf("failed to open output file: %w", err)
 		}
+		// Ensure we close the stream even if failures occur.
 		defer f.Close()
 		out = f
-		finish = func() error {
-			// Rename the file into place as atomically as the OS will allow
-			return os.Rename(tmpPath, outputPath)
-		}
+		// Closing the file causes it to be renamed to the final destination
+		// so make sure we handle any errors it returns
+		finish = f.Close
 	} else {
 		out = os.Stdout
 	}

docker-bake.hcl

@@ -180,4 +180,10 @@ target "ci-builder" {
   tags = [for tag in split(",", IMAGE_TAGS) : "${REGISTRY}/${REPOSITORY}/ci-builder:${tag}"]
 }
 
-
+target "contracts-bedrock" {
+  dockerfile = "./ops/docker/Dockerfile.packages"
+  context = "."
+  target = "contracts-bedrock"
+  platforms = split(",", PLATFORMS)
+  tags = [for tag in split(",", IMAGE_TAGS) : "${REGISTRY}/${REPOSITORY}/contracts-bedrock:${tag}"]
+}

op-challenger/game/scheduler/coordinator.go

@@ -103,7 +103,7 @@ func (c *coordinator) createJob(game types.GameMetadata) (*job, error) {
 		c.states[game.Proxy] = state
 	}
 	if state.inflight {
-		c.logger.Debug("Not rescheduling already in-flight game", "game", game)
+		c.logger.Debug("Not rescheduling already in-flight game", "game", game.Proxy)
 		return nil, nil
 	}
 	// Create the player separately to the state so we retry creating it if it fails on the first attempt.
@@ -117,7 +117,7 @@ func (c *coordinator) createJob(game types.GameMetadata) (*job, error) {
 	}
 	state.inflight = true
 	if state.status != types.GameStatusInProgress {
-		c.logger.Debug("Not rescheduling resolved game", "game", game, "status", state.status)
+		c.logger.Debug("Not rescheduling resolved game", "game", game.Proxy, "status", state.status)
 		return nil, nil
 	}
 	return &job{addr: game.Proxy, player: state.player, status: state.status}, nil

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/driver.go

+package proposer
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"math/big"
+	_ "net/http/pprof"
+	"sync"
+	"time"
+
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/log"
+
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum-optimism/optimism/op-proposer/metrics"
+	"github.com/ethereum-optimism/optimism/op-service/eth"
+	"github.com/ethereum-optimism/optimism/op-service/txmgr"
+)
+
+var supportedL2OutputVersion = eth.Bytes32{}
+var ErrProposerNotRunning = errors.New("proposer is not running")
+
+type L1Client interface {
+	HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error)
+	// CodeAt returns the code of the given account. This is needed to differentiate
+	// between contract internal errors and the local chain being out of sync.
+	CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error)
+
+	// CallContract executes an Ethereum contract call with the specified data as the
+	// input.
+	CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error)
+}
+
+type RollupClient interface {
+	SyncStatus(ctx context.Context) (*eth.SyncStatus, error)
+	OutputAtBlock(ctx context.Context, blockNum uint64) (*eth.OutputResponse, error)
+}
+
+type DriverSetup struct {
+	Log      log.Logger
+	Metr     metrics.Metricer
+	Cfg      ProposerConfig
+	Txmgr    txmgr.TxManager
+	L1Client L1Client
+
+	// RollupClient is used to retrieve output roots from
+	RollupClient RollupClient
+}
+
+// L2OutputSubmitter is responsible for proposing outputs
+type L2OutputSubmitter struct {
+	DriverSetup
+
+	wg   sync.WaitGroup
+	done chan struct{}
+
+	ctx    context.Context
+	cancel context.CancelFunc
+
+	mutex   sync.Mutex
+	running bool
+
+	l2ooContract *bindings.L2OutputOracleCaller
+	l2ooABI      *abi.ABI
+}
+
+// NewL2OutputSubmitter creates a new L2 Output Submitter
+func NewL2OutputSubmitter(setup DriverSetup) (*L2OutputSubmitter, error) {
+	ctx, cancel := context.WithCancel(context.Background())
+
+	l2ooContract, err := bindings.NewL2OutputOracleCaller(setup.Cfg.L2OutputOracleAddr, setup.L1Client)
+	if err != nil {
+		cancel()
+		return nil, fmt.Errorf("failed to create L2OO at address %s: %w", setup.Cfg.L2OutputOracleAddr, err)
+	}
+
+	cCtx, cCancel := context.WithTimeout(ctx, setup.Cfg.NetworkTimeout)
+	defer cCancel()
+	version, err := l2ooContract.Version(&bind.CallOpts{Context: cCtx})
+	if err != nil {
+		cancel()
+		return nil, err
+	}
+	log.Info("Connected to L2OutputOracle", "address", setup.Cfg.L2OutputOracleAddr, "version", version)
+
+	parsed, err := bindings.L2OutputOracleMetaData.GetAbi()
+	if err != nil {
+		cancel()
+		return nil, err
+	}
+
+	return &L2OutputSubmitter{
+		DriverSetup: setup,
+		done:        make(chan struct{}),
+		ctx:         ctx,
+		cancel:      cancel,
+
+		l2ooContract: l2ooContract,
+		l2ooABI:      parsed,
+	}, nil
+}
+
+func (l *L2OutputSubmitter) StartL2OutputSubmitting() error {
+	l.Log.Info("Starting Proposer")
+
+	l.mutex.Lock()
+	defer l.mutex.Unlock()
+
+	if l.running {
+		return errors.New("Proposer is already running")
+	}
+	l.running = true
+
+	l.wg.Add(1)
+	go l.loop()
+
+	l.Log.Info("Proposer started")
+	return nil
+}
+
+func (l *L2OutputSubmitter) StopL2OutputSubmittingIfRunning() error {
+	err := l.StopL2OutputSubmitting()
+	if errors.Is(err, ErrProposerNotRunning) {
+		return nil
+	}
+	return err
+}
+
+func (l *L2OutputSubmitter) StopL2OutputSubmitting() error {
+	l.Log.Info("Stopping Proposer")
+
+	l.mutex.Lock()
+	defer l.mutex.Unlock()
+
+	if !l.running {
+		return ErrProposerNotRunning
+	}
+	l.running = false
+
+	l.cancel()
+	close(l.done)
+	l.wg.Wait()
+
+	l.Log.Info("Proposer stopped")
+	return nil
+}
+
+// FetchNextOutputInfo gets the block number of the next proposal.
+// It returns: the next block number, if the proposal should be made, error
+func (l *L2OutputSubmitter) FetchNextOutputInfo(ctx context.Context) (*eth.OutputResponse, bool, error) {
+	cCtx, cancel := context.WithTimeout(ctx, l.Cfg.NetworkTimeout)
+	defer cancel()
+	callOpts := &bind.CallOpts{
+		From:    l.Txmgr.From(),
+		Context: cCtx,
+	}
+	nextCheckpointBlock, err := l.l2ooContract.NextBlockNumber(callOpts)
+	if err != nil {
+		l.Log.Error("proposer unable to get next block number", "err", err)
+		return nil, false, err
+	}
+	// Fetch the current L2 heads
+	cCtx, cancel = context.WithTimeout(ctx, l.Cfg.NetworkTimeout)
+	defer cancel()
+	status, err := l.RollupClient.SyncStatus(cCtx)
+	if err != nil {
+		l.Log.Error("proposer unable to get sync status", "err", err)
+		return nil, false, err
+	}
+
+	// Use either the finalized or safe head depending on the config. Finalized head is default & safer.
+	var currentBlockNumber *big.Int
+	if l.Cfg.AllowNonFinalized {
+		currentBlockNumber = new(big.Int).SetUint64(status.SafeL2.Number)
+	} else {
+		currentBlockNumber = new(big.Int).SetUint64(status.FinalizedL2.Number)
+	}
+	// Ensure that we do not submit a block in the future
+	if currentBlockNumber.Cmp(nextCheckpointBlock) < 0 {
+		l.Log.Debug("proposer submission interval has not elapsed", "currentBlockNumber", currentBlockNumber, "nextBlockNumber", nextCheckpointBlock)
+		return nil, false, nil
+	}
+
+	return l.fetchOutput(ctx, nextCheckpointBlock)
+}
+
+func (l *L2OutputSubmitter) fetchOutput(ctx context.Context, block *big.Int) (*eth.OutputResponse, bool, error) {
+	ctx, cancel := context.WithTimeout(ctx, l.Cfg.NetworkTimeout)
+	defer cancel()
+	output, err := l.RollupClient.OutputAtBlock(ctx, block.Uint64())
+	if err != nil {
+		l.Log.Error("failed to fetch output at block %d: %w", block, err)
+		return nil, false, err
+	}
+	if output.Version != supportedL2OutputVersion {
+		l.Log.Error("unsupported l2 output version: %s", output.Version)
+		return nil, false, errors.New("unsupported l2 output version")
+	}
+	if output.BlockRef.Number != block.Uint64() { // sanity check, e.g. in case of bad RPC caching
+		l.Log.Error("invalid blockNumber: next blockNumber is %v, blockNumber of block is %v", block, output.BlockRef.Number)
+		return nil, false, errors.New("invalid blockNumber")
+	}
+
+	// Always propose if it's part of the Finalized L2 chain. Or if allowed, if it's part of the safe L2 chain.
+	if !(output.BlockRef.Number <= output.Status.FinalizedL2.Number || (l.Cfg.AllowNonFinalized && output.BlockRef.Number <= output.Status.SafeL2.Number)) {
+		l.Log.Debug("not proposing yet, L2 block is not ready for proposal",
+			"l2_proposal", output.BlockRef,
+			"l2_safe", output.Status.SafeL2,
+			"l2_finalized", output.Status.FinalizedL2,
+			"allow_non_finalized", l.Cfg.AllowNonFinalized)
+		return nil, false, nil
+	}
+	return output, true, nil
+}
+
+// ProposeL2OutputTxData creates the transaction data for the ProposeL2Output function
+func (l *L2OutputSubmitter) ProposeL2OutputTxData(output *eth.OutputResponse) ([]byte, error) {
+	return proposeL2OutputTxData(l.l2ooABI, output)
+}
+
+// proposeL2OutputTxData creates the transaction data for the ProposeL2Output function
+func proposeL2OutputTxData(abi *abi.ABI, output *eth.OutputResponse) ([]byte, error) {
+	return abi.Pack(
+		"proposeL2Output",
+		output.OutputRoot,
+		new(big.Int).SetUint64(output.BlockRef.Number),
+		output.Status.CurrentL1.Hash,
+		new(big.Int).SetUint64(output.Status.CurrentL1.Number))
+}
+
+// We wait until l1head advances beyond blocknum. This is used to make sure proposal tx won't
+// immediately fail when checking the l1 blockhash. Note that EstimateGas uses "latest" state to
+// execute the transaction by default, meaning inside the call, the head block is considered
+// "pending" instead of committed. In the case l1blocknum == l1head then, blockhash(l1blocknum)
+// will produce a value of 0 within EstimateGas, and the call will fail when the contract checks
+// that l1blockhash matches blockhash(l1blocknum).
+func (l *L2OutputSubmitter) waitForL1Head(ctx context.Context, blockNum uint64) error {
+	ticker := time.NewTicker(l.Cfg.PollInterval)
+	defer ticker.Stop()
+	l1head, err := l.Txmgr.BlockNumber(ctx)
+	if err != nil {
+		return err
+	}
+	for l1head <= blockNum {
+		l.Log.Debug("waiting for l1 head > l1blocknum1+1", "l1head", l1head, "l1blocknum", blockNum)
+		select {
+		case <-ticker.C:
+			l1head, err = l.Txmgr.BlockNumber(ctx)
+			if err != nil {
+				return err
+			}
+			break
+		case <-l.done:
+			return fmt.Errorf("L2OutputSubmitter is done()")
+		}
+	}
+	return nil
+}
+
+// sendTransaction creates & sends transactions through the underlying transaction manager.
+func (l *L2OutputSubmitter) sendTransaction(ctx context.Context, output *eth.OutputResponse) error {
+	err := l.waitForL1Head(ctx, output.Status.HeadL1.Number+1)
+	if err != nil {
+		return err
+	}
+	data, err := l.ProposeL2OutputTxData(output)
+	if err != nil {
+		return err
+	}
+	receipt, err := l.Txmgr.Send(ctx, txmgr.TxCandidate{
+		TxData:   data,
+		To:       &l.Cfg.L2OutputOracleAddr,
+		GasLimit: 0,
+	})
+	if err != nil {
+		return err
+	}
+	if receipt.Status == types.ReceiptStatusFailed {
+		l.Log.Error("proposer tx successfully published but reverted", "tx_hash", receipt.TxHash)
+	} else {
+		l.Log.Info("proposer tx successfully published",
+			"tx_hash", receipt.TxHash,
+			"l1blocknum", output.Status.CurrentL1.Number,
+			"l1blockhash", output.Status.CurrentL1.Hash)
+	}
+	return nil
+}
+
+// loop is responsible for creating & submitting the next outputs
+func (l *L2OutputSubmitter) loop() {
+	defer l.wg.Done()
+
+	ctx := l.ctx
+
+	ticker := time.NewTicker(l.Cfg.PollInterval)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ticker.C:
+			output, shouldPropose, err := l.FetchNextOutputInfo(ctx)
+			if err != nil {
+				break
+			}
+			if !shouldPropose {
+				break
+			}
+			cCtx, cancel := context.WithTimeout(ctx, 10*time.Minute)
+			if err := l.sendTransaction(cCtx, output); err != nil {
+				l.Log.Error("Failed to send proposal transaction",
+					"err", err,
+					"l1blocknum", output.Status.CurrentL1.Number,
+					"l1blockhash", output.Status.CurrentL1.Hash,
+					"l1head", output.Status.HeadL1.Number)
+				cancel()
+				break
+			}
+			l.Metr.RecordL2BlocksProposed(output.BlockRef)
+			cancel()
+
+		case <-l.done:
+			return
+		}
+	}
+}

op-proposer/proposer/l2_output_submitter.go

@@ -2,429 +2,33 @@ package proposer
 
 import (
 	"context"
-	"errors"
 	"fmt"
-	"math/big"
-	_ "net/http/pprof"
-	"sync"
-	"time"
 
 	"github.com/urfave/cli/v2"
 
-	"github.com/ethereum/go-ethereum/accounts/abi"
-	"github.com/ethereum/go-ethereum/accounts/abi/bind"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/log"
-
-	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-proposer/flags"
-	"github.com/ethereum-optimism/optimism/op-proposer/metrics"
 	opservice "github.com/ethereum-optimism/optimism/op-service"
-	"github.com/ethereum-optimism/optimism/op-service/dial"
-	"github.com/ethereum-optimism/optimism/op-service/eth"
+	"github.com/ethereum-optimism/optimism/op-service/cliapp"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
-	"github.com/ethereum-optimism/optimism/op-service/opio"
-	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"
 )
 
-var supportedL2OutputVersion = eth.Bytes32{}
-
-// Main is the entrypoint into the L2 Output Submitter. This method executes the
-// service and blocks until the service exits.
-func Main(version string, cliCtx *cli.Context) error {
-	if err := flags.CheckRequired(cliCtx); err != nil {
-		return err
-	}
-	cfg := NewConfig(cliCtx)
-	if err := cfg.Check(); err != nil {
-		return fmt.Errorf("invalid CLI flags: %w", err)
-	}
-
-	l := oplog.NewLogger(oplog.AppOut(cliCtx), cfg.LogConfig)
-	oplog.SetGlobalLogHandler(l.GetHandler())
-	opservice.ValidateEnvVars(flags.EnvVarPrefix, flags.Flags, l)
-	m := metrics.NewMetrics("default")
-	l.Info("Initializing L2 Output Submitter")
-
-	proposerConfig, err := NewL2OutputSubmitterConfigFromCLIConfig(cfg, l, m)
-	if err != nil {
-		l.Error("Unable to create the L2 Output Submitter", "error", err)
-		return err
-	}
-
-	l2OutputSubmitter, err := NewL2OutputSubmitter(*proposerConfig, l, m)
-	if err != nil {
-		l.Error("Unable to create the L2 Output Submitter", "error", err)
-		return err
-	}
-
-	l.Info("Starting L2 Output Submitter")
-	if err := l2OutputSubmitter.Start(); err != nil {
-		l.Error("Unable to start L2 Output Submitter", "error", err)
-		return err
-	}
-	defer l2OutputSubmitter.Stop()
-
-	l.Info("L2 Output Submitter started")
-	pprofConfig := cfg.PprofConfig
-	if pprofConfig.Enabled {
-		l.Debug("starting pprof", "addr", pprofConfig.ListenAddr, "port", pprofConfig.ListenPort)
-		pprofSrv, err := oppprof.StartServer(pprofConfig.ListenAddr, pprofConfig.ListenPort)
-		if err != nil {
-			l.Error("failed to start pprof server", "err", err)
-			return err
+// Main is the entrypoint into the L2OutputSubmitter.
+// This method returns a cliapp.LifecycleAction, to create an op-service CLI-lifecycle-managed L2Output-submitter
+func Main(version string) cliapp.LifecycleAction {
+	return func(cliCtx *cli.Context, closeApp context.CancelCauseFunc) (cliapp.Lifecycle, error) {
+		if err := flags.CheckRequired(cliCtx); err != nil {
+			return nil, err
 		}
-		l.Info("started pprof server", "addr", pprofSrv.Addr())
-		defer func() {
-			if err := pprofSrv.Stop(context.Background()); err != nil {
-				l.Error("failed to stop pprof server", "err", err)
-			}
-		}()
-	}
-
-	metricsCfg := cfg.MetricsConfig
-	if metricsCfg.Enabled {
-		l.Debug("starting metrics server", "addr", metricsCfg.ListenAddr, "port", metricsCfg.ListenPort)
-		metricsSrv, err := m.Start(metricsCfg.ListenAddr, metricsCfg.ListenPort)
-		if err != nil {
-			return fmt.Errorf("failed to start metrics server: %w", err)
-		}
-		l.Info("started metrics server", "addr", metricsSrv.Addr())
-		defer func() {
-			if err := metricsSrv.Stop(context.Background()); err != nil {
-				l.Error("failed to stop metrics server", "err", err)
-			}
-		}()
-		ctx, cancel := context.WithCancel(context.Background())
-		defer cancel()
-		m.StartBalanceMetrics(ctx, l, proposerConfig.L1Client, proposerConfig.TxManager.From())
-	}
-
-	rpcCfg := cfg.RPCConfig
-	server := oprpc.NewServer(rpcCfg.ListenAddr, rpcCfg.ListenPort, version, oprpc.WithLogger(l))
-	if rpcCfg.EnableAdmin {
-		server.AddAPI(oprpc.ToGethAdminAPI(oprpc.NewCommonAdminAPI(&m.RPCMetrics, l)))
-		l.Info("Admin RPC enabled")
-	}
-	if err := server.Start(); err != nil {
-		return fmt.Errorf("error starting RPC server: %w", err)
-	}
-
-	m.RecordInfo(version)
-	m.RecordUp()
-
-	opio.BlockOnInterrupts()
-
-	return nil
-}
-
-// L2OutputSubmitter is responsible for proposing outputs
-type L2OutputSubmitter struct {
-	txMgr txmgr.TxManager
-	wg    sync.WaitGroup
-	done  chan struct{}
-	log   log.Logger
-	metr  metrics.Metricer
-
-	ctx    context.Context
-	cancel context.CancelFunc
-
-	// RollupClient is used to retrieve output roots from
-	rollupClient *sources.RollupClient
-
-	l2ooContract     *bindings.L2OutputOracleCaller
-	l2ooContractAddr common.Address
-	l2ooABI          *abi.ABI
-
-	// 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
-	// How frequently to poll L2 for new finalized outputs
-	pollInterval   time.Duration
-	networkTimeout time.Duration
-}
-
-// NewL2OutputSubmitterFromCLIConfig creates a new L2 Output Submitter given the CLI Config
-func NewL2OutputSubmitterFromCLIConfig(cfg CLIConfig, l log.Logger, m metrics.Metricer) (*L2OutputSubmitter, error) {
-	proposerConfig, err := NewL2OutputSubmitterConfigFromCLIConfig(cfg, l, m)
-	if err != nil {
-		return nil, err
-	}
-	return NewL2OutputSubmitter(*proposerConfig, l, m)
-}
-
-// NewL2OutputSubmitterConfigFromCLIConfig creates the proposer config from the CLI config.
-func NewL2OutputSubmitterConfigFromCLIConfig(cfg CLIConfig, l log.Logger, m metrics.Metricer) (*Config, error) {
-	l2ooAddress, err := opservice.ParseAddress(cfg.L2OOAddress)
-	if err != nil {
-		return nil, err
-	}
-
-	txManager, err := txmgr.NewSimpleTxManager("proposer", l, m, cfg.TxMgrConfig)
-	if err != nil {
-		return nil, err
-	}
-
-	// Connect to L1 and L2 providers. Perform these last since they are the most expensive.
-	l1Client, err := dial.DialEthClientWithTimeout(context.Background(), dial.DefaultDialTimeout, l, cfg.L1EthRpc)
-	if err != nil {
-		return nil, err
-	}
-
-	rollupClient, err := dial.DialRollupClientWithTimeout(context.Background(), dial.DefaultDialTimeout, l, cfg.RollupRpc)
-	if err != nil {
-		return nil, err
-	}
-
-	return &Config{
-		L2OutputOracleAddr: l2ooAddress,
-		PollInterval:       cfg.PollInterval,
-		NetworkTimeout:     cfg.TxMgrConfig.NetworkTimeout,
-		L1Client:           l1Client,
-		RollupClient:       rollupClient,
-		AllowNonFinalized:  cfg.AllowNonFinalized,
-		TxManager:          txManager,
-	}, nil
-
-}
-
-// NewL2OutputSubmitter creates a new L2 Output Submitter
-func NewL2OutputSubmitter(cfg Config, l log.Logger, m metrics.Metricer) (*L2OutputSubmitter, error) {
-	ctx, cancel := context.WithCancel(context.Background())
-
-	l2ooContract, err := bindings.NewL2OutputOracleCaller(cfg.L2OutputOracleAddr, cfg.L1Client)
-	if err != nil {
-		cancel()
-		return nil, fmt.Errorf("failed to create L2OO at address %s: %w", cfg.L2OutputOracleAddr, err)
-	}
-
-	cCtx, cCancel := context.WithTimeout(ctx, cfg.NetworkTimeout)
-	defer cCancel()
-	version, err := l2ooContract.Version(&bind.CallOpts{Context: cCtx})
-	if err != nil {
-		cancel()
-		return nil, err
-	}
-	log.Info("Connected to L2OutputOracle", "address", cfg.L2OutputOracleAddr, "version", version)
-
-	parsed, err := bindings.L2OutputOracleMetaData.GetAbi()
-	if err != nil {
-		cancel()
-		return nil, err
-	}
-
-	return &L2OutputSubmitter{
-		txMgr:  cfg.TxManager,
-		done:   make(chan struct{}),
-		log:    l,
-		ctx:    ctx,
-		cancel: cancel,
-		metr:   m,
-
-		rollupClient: cfg.RollupClient,
-
-		l2ooContract:     l2ooContract,
-		l2ooContractAddr: cfg.L2OutputOracleAddr,
-		l2ooABI:          parsed,
-
-		allowNonFinalized: cfg.AllowNonFinalized,
-		pollInterval:      cfg.PollInterval,
-		networkTimeout:    cfg.NetworkTimeout,
-	}, nil
-}
-
-func (l *L2OutputSubmitter) Start() error {
-	l.wg.Add(1)
-	go l.loop()
-	return nil
-}
-
-func (l *L2OutputSubmitter) Stop() {
-	l.cancel()
-	close(l.done)
-	l.wg.Wait()
-}
-
-// FetchNextOutputInfo gets the block number of the next proposal.
-// It returns: the next block number, if the proposal should be made, error
-func (l *L2OutputSubmitter) FetchNextOutputInfo(ctx context.Context) (*eth.OutputResponse, bool, error) {
-	cCtx, cancel := context.WithTimeout(ctx, l.networkTimeout)
-	defer cancel()
-	callOpts := &bind.CallOpts{
-		From:    l.txMgr.From(),
-		Context: cCtx,
-	}
-	nextCheckpointBlock, err := l.l2ooContract.NextBlockNumber(callOpts)
-	if err != nil {
-		l.log.Error("proposer unable to get next block number", "err", err)
-		return nil, false, err
-	}
-	// Fetch the current L2 heads
-	cCtx, cancel = context.WithTimeout(ctx, l.networkTimeout)
-	defer cancel()
-	status, err := l.rollupClient.SyncStatus(cCtx)
-	if err != nil {
-		l.log.Error("proposer unable to get sync status", "err", err)
-		return nil, false, err
-	}
-
-	// Use either the finalized or safe head depending on the config. Finalized head is default & safer.
-	var currentBlockNumber *big.Int
-	if l.allowNonFinalized {
-		currentBlockNumber = new(big.Int).SetUint64(status.SafeL2.Number)
-	} else {
-		currentBlockNumber = new(big.Int).SetUint64(status.FinalizedL2.Number)
-	}
-	// Ensure that we do not submit a block in the future
-	if currentBlockNumber.Cmp(nextCheckpointBlock) < 0 {
-		l.log.Debug("proposer submission interval has not elapsed", "currentBlockNumber", currentBlockNumber, "nextBlockNumber", nextCheckpointBlock)
-		return nil, false, nil
-	}
-
-	return l.fetchOutput(ctx, nextCheckpointBlock)
-}
-
-func (l *L2OutputSubmitter) fetchOutput(ctx context.Context, block *big.Int) (*eth.OutputResponse, bool, error) {
-	ctx, cancel := context.WithTimeout(ctx, l.networkTimeout)
-	defer cancel()
-	output, err := l.rollupClient.OutputAtBlock(ctx, block.Uint64())
-	if err != nil {
-		l.log.Error("failed to fetch output at block %d: %w", block, err)
-		return nil, false, err
-	}
-	if output.Version != supportedL2OutputVersion {
-		l.log.Error("unsupported l2 output version: %s", output.Version)
-		return nil, false, errors.New("unsupported l2 output version")
-	}
-	if output.BlockRef.Number != block.Uint64() { // sanity check, e.g. in case of bad RPC caching
-		l.log.Error("invalid blockNumber: next blockNumber is %v, blockNumber of block is %v", block, output.BlockRef.Number)
-		return nil, false, errors.New("invalid blockNumber")
-	}
-
-	// Always propose if it's part of the Finalized L2 chain. Or if allowed, if it's part of the safe L2 chain.
-	if !(output.BlockRef.Number <= output.Status.FinalizedL2.Number || (l.allowNonFinalized && output.BlockRef.Number <= output.Status.SafeL2.Number)) {
-		l.log.Debug("not proposing yet, L2 block is not ready for proposal",
-			"l2_proposal", output.BlockRef,
-			"l2_safe", output.Status.SafeL2,
-			"l2_finalized", output.Status.FinalizedL2,
-			"allow_non_finalized", l.allowNonFinalized)
-		return nil, false, nil
-	}
-	return output, true, nil
-}
-
-// ProposeL2OutputTxData creates the transaction data for the ProposeL2Output function
-func (l *L2OutputSubmitter) ProposeL2OutputTxData(output *eth.OutputResponse) ([]byte, error) {
-	return proposeL2OutputTxData(l.l2ooABI, output)
-}
-
-// proposeL2OutputTxData creates the transaction data for the ProposeL2Output function
-func proposeL2OutputTxData(abi *abi.ABI, output *eth.OutputResponse) ([]byte, error) {
-	return abi.Pack(
-		"proposeL2Output",
-		output.OutputRoot,
-		new(big.Int).SetUint64(output.BlockRef.Number),
-		output.Status.CurrentL1.Hash,
-		new(big.Int).SetUint64(output.Status.CurrentL1.Number))
-}
-
-// We wait until l1head advances beyond blocknum. This is used to make sure proposal tx won't
-// immediately fail when checking the l1 blockhash. Note that EstimateGas uses "latest" state to
-// execute the transaction by default, meaning inside the call, the head block is considered
-// "pending" instead of committed. In the case l1blocknum == l1head then, blockhash(l1blocknum)
-// will produce a value of 0 within EstimateGas, and the call will fail when the contract checks
-// that l1blockhash matches blockhash(l1blocknum).
-func (l *L2OutputSubmitter) waitForL1Head(ctx context.Context, blockNum uint64) error {
-	ticker := time.NewTicker(l.pollInterval)
-	defer ticker.Stop()
-	l1head, err := l.txMgr.BlockNumber(ctx)
-	if err != nil {
-		return err
-	}
-	for l1head <= blockNum {
-		l.log.Debug("waiting for l1 head > l1blocknum1+1", "l1head", l1head, "l1blocknum", blockNum)
-		select {
-		case <-ticker.C:
-			l1head, err = l.txMgr.BlockNumber(ctx)
-			if err != nil {
-				return err
-			}
-			break
-		case <-l.done:
-			return fmt.Errorf("L2OutputSubmitter is done()")
+		cfg := NewConfig(cliCtx)
+		if err := cfg.Check(); err != nil {
+			return nil, fmt.Errorf("invalid CLI flags: %w", err)
 		}
-	}
-	return nil
-}
 
-// sendTransaction creates & sends transactions through the underlying transaction manager.
-func (l *L2OutputSubmitter) sendTransaction(ctx context.Context, output *eth.OutputResponse) error {
-	err := l.waitForL1Head(ctx, output.Status.HeadL1.Number+1)
-	if err != nil {
-		return err
-	}
-	data, err := l.ProposeL2OutputTxData(output)
-	if err != nil {
-		return err
-	}
-	receipt, err := l.txMgr.Send(ctx, txmgr.TxCandidate{
-		TxData:   data,
-		To:       &l.l2ooContractAddr,
-		GasLimit: 0,
-	})
-	if err != nil {
-		return err
-	}
-	if receipt.Status == types.ReceiptStatusFailed {
-		l.log.Error("proposer tx successfully published but reverted", "tx_hash", receipt.TxHash)
-	} else {
-		l.log.Info("proposer tx successfully published",
-			"tx_hash", receipt.TxHash,
-			"l1blocknum", output.Status.CurrentL1.Number,
-			"l1blockhash", output.Status.CurrentL1.Hash)
-	}
-	return nil
-}
-
-// loop is responsible for creating & submitting the next outputs
-func (l *L2OutputSubmitter) loop() {
-	defer l.wg.Done()
-
-	ctx := l.ctx
+		l := oplog.NewLogger(oplog.AppOut(cliCtx), cfg.LogConfig)
+		oplog.SetGlobalLogHandler(l.GetHandler())
+		opservice.ValidateEnvVars(flags.EnvVarPrefix, flags.Flags, l)
 
-	ticker := time.NewTicker(l.pollInterval)
-	defer ticker.Stop()
-	for {
-		select {
-		case <-ticker.C:
-			output, shouldPropose, err := l.FetchNextOutputInfo(ctx)
-			if err != nil {
-				break
-			}
-			if !shouldPropose {
-				break
-			}
-			cCtx, cancel := context.WithTimeout(ctx, 10*time.Minute)
-			if err := l.sendTransaction(cCtx, output); err != nil {
-				l.log.Error("Failed to send proposal transaction",
-					"err", err,
-					"l1blocknum", output.Status.CurrentL1.Number,
-					"l1blockhash", output.Status.CurrentL1.Hash,
-					"l1head", output.Status.HeadL1.Number)
-				cancel()
-				break
-			}
-			l.metr.RecordL2BlocksProposed(output.BlockRef)
-			cancel()
-
-		case <-l.done:
-			return
-		}
+		l.Info("Initializing L2Output Submitter")
+		return ProposerServiceFromCLIConfig(cliCtx.Context, version, cfg, l)
 	}
 }

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
+}

op-service/cliapp/lifecycle_test.go

@@ -48,12 +48,14 @@ var _ Lifecycle = (*fakeLifecycle)(nil)
 
 func TestLifecycleCmd(t *testing.T) {
 
-	appSetup := func(t *testing.T, shareApp **fakeLifecycle) (signalCh chan struct{}, initCh, startCh, stopCh, resultCh chan error) {
+	appSetup := func(t *testing.T) (signalCh chan struct{}, initCh, startCh, stopCh, resultCh chan error, appCh chan *fakeLifecycle) {
 		signalCh = make(chan struct{})
 		initCh = make(chan error)
 		startCh = make(chan error)
 		stopCh = make(chan error)
 		resultCh = make(chan error)
+		// optional channel to retrieve the fakeLifecycle from, available some time after init, before start.
+		appCh = make(chan *fakeLifecycle, 1)
 
 		// mock an application that may fail at different stages of its lifecycle
 		mockAppFn := func(ctx *cli.Context, close context.CancelCauseFunc) (Lifecycle, error) {
@@ -72,9 +74,7 @@ func TestLifecycleCmd(t *testing.T) {
 				stopped:   false,
 				selfClose: close,
 			}
-			if shareApp != nil {
-				*shareApp = app
-			}
+			appCh <- app
 			return app, nil
 		}
 
@@ -115,19 +115,20 @@ func TestLifecycleCmd(t *testing.T) {
 			close(startCh)
 			close(stopCh)
 			close(resultCh)
+			close(appCh)
 		})
 		return
 	}
 
 	t.Run("interrupt int", func(t *testing.T) {
-		signalCh, _, _, _, resultCh := appSetup(t, nil)
+		signalCh, _, _, _, resultCh, _ := appSetup(t)
 		signalCh <- struct{}{}
 		res := <-resultCh
 		require.ErrorIs(t, res, interruptErr)
 		require.ErrorContains(t, res, "failed to setup")
 	})
 	t.Run("failed init", func(t *testing.T) {
-		_, initCh, _, _, resultCh := appSetup(t, nil)
+		_, initCh, _, _, resultCh, _ := appSetup(t)
 		v := errors.New("TEST INIT ERRROR")
 		initCh <- v
 		res := <-resultCh
@@ -135,9 +136,9 @@ func TestLifecycleCmd(t *testing.T) {
 		require.ErrorContains(t, res, "failed to setup")
 	})
 	t.Run("interrupt start", func(t *testing.T) {
-		var app *fakeLifecycle
-		signalCh, initCh, _, _, resultCh := appSetup(t, &app)
+		signalCh, initCh, _, _, resultCh, appCh := appSetup(t)
 		initCh <- nil
+		app := <-appCh
 		require.False(t, app.Stopped())
 		signalCh <- struct{}{}
 		res := <-resultCh
@@ -146,9 +147,9 @@ func TestLifecycleCmd(t *testing.T) {
 		require.True(t, app.Stopped())
 	})
 	t.Run("failed start", func(t *testing.T) {
-		var app *fakeLifecycle
-		_, initCh, startCh, _, resultCh := appSetup(t, &app)
+		_, initCh, startCh, _, resultCh, appCh := appSetup(t)
 		initCh <- nil
+		app := <-appCh
 		require.False(t, app.Stopped())
 		v := errors.New("TEST START ERROR")
 		startCh <- v
@@ -158,9 +159,9 @@ func TestLifecycleCmd(t *testing.T) {
 		require.True(t, app.Stopped())
 	})
 	t.Run("graceful shutdown", func(t *testing.T) {
-		var app *fakeLifecycle
-		signalCh, initCh, startCh, stopCh, resultCh := appSetup(t, &app)
+		signalCh, initCh, startCh, stopCh, resultCh, appCh := appSetup(t)
 		initCh <- nil
+		app := <-appCh
 		require.False(t, app.Stopped())
 		startCh <- nil
 		signalCh <- struct{}{} // interrupt, but at an expected time
@@ -169,9 +170,9 @@ func TestLifecycleCmd(t *testing.T) {
 		require.True(t, app.Stopped())
 	})
 	t.Run("interrupted shutdown", func(t *testing.T) {
-		var app *fakeLifecycle
-		signalCh, initCh, startCh, _, resultCh := appSetup(t, &app)
+		signalCh, initCh, startCh, _, resultCh, appCh := appSetup(t)
 		initCh <- nil
+		app := <-appCh
 		require.False(t, app.Stopped())
 		startCh <- nil
 		signalCh <- struct{}{} // start graceful shutdown
@@ -182,9 +183,9 @@ func TestLifecycleCmd(t *testing.T) {
 		require.True(t, app.Stopped()) // still fully closes, interrupts only accelerate shutdown where possible.
 	})
 	t.Run("failed shutdown", func(t *testing.T) {
-		var app *fakeLifecycle
-		signalCh, initCh, startCh, stopCh, resultCh := appSetup(t, &app)
+		signalCh, initCh, startCh, stopCh, resultCh, appCh := appSetup(t)
 		initCh <- nil
+		app := <-appCh
 		require.False(t, app.Stopped())
 		startCh <- nil
 		signalCh <- struct{}{} // start graceful shutdown
@@ -196,9 +197,9 @@ func TestLifecycleCmd(t *testing.T) {
 		require.True(t, app.Stopped())
 	})
 	t.Run("app self-close", func(t *testing.T) {
-		var app *fakeLifecycle
-		_, initCh, startCh, stopCh, resultCh := appSetup(t, &app)
+		_, initCh, startCh, stopCh, resultCh, appCh := appSetup(t)
 		initCh <- nil
+		app := <-appCh
 		require.False(t, app.Stopped())
 		startCh <- nil
 		v := errors.New("TEST SELF CLOSE ERROR")

op-service/ioutil/atomic.go

+package ioutil
+
+import (
+	"io"
+	"os"
+	"path/filepath"
+)
+
+type atomicWriter struct {
+	dest string
+	temp string
+	out  io.WriteCloser
+}
+
+// NewAtomicWriterCompressed creates a io.WriteCloser that performs an atomic write.
+// The contents are initially written to a temporary file and only renamed into place when the writer is closed.
+// NOTE: It's vital to check if an error is returned from Close() as it may indicate the file could not be renamed
+// If path ends in .gz the contents written will be gzipped.
+func NewAtomicWriterCompressed(path string, perm os.FileMode) (io.WriteCloser, error) {
+	f, err := os.CreateTemp(filepath.Dir(path), filepath.Base(path))
+	if err != nil {
+		return nil, err
+	}
+	if err := f.Chmod(perm); err != nil {
+		_ = f.Close()
+		return nil, err
+	}
+	return &atomicWriter{
+		dest: path,
+		temp: f.Name(),
+		out:  CompressByFileType(path, f),
+	}, nil
+}
+
+func (a *atomicWriter) Write(p []byte) (n int, err error) {
+	return a.out.Write(p)
+}
+
+func (a *atomicWriter) Close() error {
+	// Attempt to clean up the temp file even if it can't be renamed into place.
+	defer os.Remove(a.temp)
+	if err := a.out.Close(); err != nil {
+		return err
+	}
+	return os.Rename(a.temp, a.dest)
+}

op-service/ioutil/atomic_test.go

+package ioutil
+
+import (
+	"io"
+	"io/fs"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestAtomicWriter_RenameOnClose(t *testing.T) {
+	dir := t.TempDir()
+	target := filepath.Join(dir, "target.txt")
+	f, err := NewAtomicWriterCompressed(target, 0755)
+	require.NoError(t, err)
+	defer f.Close()
+	_, err = os.Stat(target)
+	require.ErrorIs(t, err, os.ErrNotExist, "should not create target file when created")
+
+	content := ([]byte)("Hello world")
+	n, err := f.Write(content)
+	require.NoError(t, err)
+	require.Equal(t, len(content), n)
+	_, err = os.Stat(target)
+	require.ErrorIs(t, err, os.ErrNotExist, "should not create target file when writing")
+
+	require.NoError(t, f.Close())
+	stat, err := os.Stat(target)
+	require.NoError(t, err, "should create target file when closed")
+	require.EqualValues(t, fs.FileMode(0755), stat.Mode())
+
+	files, err := os.ReadDir(dir)
+	require.NoError(t, err)
+	require.Len(t, files, 1, "should not leave temporary files behind")
+}
+
+func TestAtomicWriter_MultipleClose(t *testing.T) {
+	dir := t.TempDir()
+	target := filepath.Join(dir, "target.txt")
+	f, err := NewAtomicWriterCompressed(target, 0755)
+	require.NoError(t, err)
+
+	require.NoError(t, f.Close())
+	require.ErrorIs(t, f.Close(), os.ErrClosed)
+}
+
+func TestAtomicWriter_ApplyGzip(t *testing.T) {
+	tests := []struct {
+		name       string
+		filename   string
+		compressed bool
+	}{
+		{"Uncompressed", "test.notgz", false},
+		{"Gzipped", "test.gz", true},
+	}
+	for _, test := range tests {
+		test := test
+		t.Run(test.name, func(t *testing.T) {
+			data := []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 0, 0}
+			dir := t.TempDir()
+			path := filepath.Join(dir, test.filename)
+			out, err := NewAtomicWriterCompressed(path, 0o644)
+			require.NoError(t, err)
+			defer out.Close()
+			_, err = out.Write(data)
+			require.NoError(t, err)
+			require.NoError(t, out.Close())
+
+			writtenData, err := os.ReadFile(path)
+			require.NoError(t, err)
+			if test.compressed {
+				require.NotEqual(t, data, writtenData, "should have compressed data on disk")
+			} else {
+				require.Equal(t, data, writtenData, "should not have compressed data on disk")
+			}
+
+			in, err := OpenDecompressed(path)
+			require.NoError(t, err)
+			readData, err := io.ReadAll(in)
+			require.NoError(t, err)
+			require.Equal(t, data, readData)
+		})
+	}
+}

op-service/ioutil/gzip.go

@@ -33,10 +33,7 @@ func OpenCompressed(file string, flag int, perm os.FileMode) (io.WriteCloser, er
 	if err != nil {
 		return nil, err
 	}
-	if IsGzip(file) {
-		out = gzip.NewWriter(out)
-	}
-	return out, nil
+	return CompressByFileType(file, out), nil
 }
 
 // WriteCompressedJson writes the object to the specified file as a compressed json object
@@ -58,3 +55,10 @@ func WriteCompressedJson(file string, obj any) error {
 func IsGzip(path string) bool {
 	return strings.HasSuffix(path, ".gz")
 }
+
+func CompressByFileType(file string, out io.WriteCloser) io.WriteCloser {
+	if IsGzip(file) {
+		return gzip.NewWriter(out)
+	}
+	return out
+}

ops/docker/Dockerfile.packages

@@ -57,6 +57,10 @@ RUN apt-get update && apt-get install -y \
   libudev-dev \
   --no-install-recommends
 
+COPY /ops/docker/oplabs.crt /usr/local/share/ca-certificates/oplabs.crt
+RUN chmod 644 /usr/local/share/ca-certificates/oplabs.crt \
+  && update-ca-certificates
+
 RUN npm install pnpm --global
 
 COPY --from=foundry /usr/local/bin/forge /usr/local/bin/forge
@@ -114,4 +118,6 @@ FROM base as wd-mon
 WORKDIR /opt/optimism/packages/chain-mon
 CMD ["start:wd-mon"]
 
-
+FROM base as contracts-bedrock
+WORKDIR /opt/optimism/packages/contracts-bedrock
+CMD ["deploy"]

ops/docker/oplabs.crt

+-----BEGIN CERTIFICATE-----
+MIICEDCCAZagAwIBAgIUALLKhe49OFLAGb5Zt+DZlvpKScswCgYIKoZIzj0EAwMw
+KTEQMA4GA1UEChMHT1AgTGFiczEVMBMGA1UEAxMMb3BsYWJzLmNsb3VkMB4XDTIy
+MTIxOTE3MDQwNFoXDTMyMTIxNjE3MDQwM1owKTEQMA4GA1UEChMHT1AgTGFiczEV
+MBMGA1UEAxMMb3BsYWJzLmNsb3VkMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEyCco
+PpvE5IRv5S0zqmpE2VsbhVzB+hiQjbQO3J6j5L+pAvWjXGvjZblGvNi5PIVBCxvm
+5UofdFrOCAiOdRfevhadv3zLzGUmoJ52iXCTPL01dlkQt5KUsoT+AU7GPW4Ko38w
+fTAOBgNVHQ8BAf8EBAMCAaYwEgYDVR0TAQH/BAgwBgEB/wIBCjAdBgNVHQ4EFgQU
+2AVLbBUBZcBOPkg8QCAOvSMrdj0wHwYDVR0jBBgwFoAU2AVLbBUBZcBOPkg8QCAO
+vSMrdj0wFwYDVR0RBBAwDoIMb3BsYWJzLmNsb3VkMAoGCCqGSM49BAMDA2gAMGUC
+MBuERHbRkWDwXm97jqKEGANU4VDBqgmRicdF7FspDqA5Zcpj+r+rQVaDlH0qvtxH
+SQIxAL3fjNoC1Kon4kKmPQdp5KNhvGzOaoQiqbb5JuL3+j6f3x0ucLVD1yWP/V/+
+zZ/vlQ==
+-----END CERTIFICATE-----

package.json

@@ -61,7 +61,7 @@
     "eslint-plugin-react": "^7.24.0",
     "eslint-plugin-unicorn": "^49.0.0",
     "husky": "^8.0.3",
-    "lint-staged": "15.0.2",
+    "lint-staged": "15.1.0",
     "markdownlint": "^0.32.0",
     "markdownlint-cli2": "0.4.0",
     "mocha": "^10.2.0",

packages/common-ts/package.json

@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "@eth-optimism/core-utils": "workspace:*",
-    "@sentry/node": "^7.80.0",
+    "@sentry/node": "^7.80.1",
     "bcfg": "^0.2.1",
     "body-parser": "^1.20.2",
     "commander": "^11.1.0",
@@ -55,7 +55,7 @@
     "@ethersproject/abstract-provider": "^5.7.0",
     "@ethersproject/abstract-signer": "^5.7.0",
     "@types/express": "^4.17.19",
-    "@types/morgan": "^1.9.7",
+    "@types/morgan": "^1.9.9",
     "@types/pino": "^7.0.5",
     "@types/pino-multi-stream": "^5.1.5",
     "chai": "^4.3.10",

packages/contracts-bedrock/package.json

@@ -20,6 +20,7 @@
     "test": "pnpm build:go-ffi && forge test",
     "coverage": "pnpm build:go-ffi && forge coverage",
     "coverage:lcov": "pnpm build:go-ffi && forge coverage --report lcov",
+    "deploy": "./scripts/deploy.sh",
     "gas-snapshot:no-build": "forge snapshot --no-match-test 'testDiff|testFuzz|invariant|generateArtifact'",
     "gas-snapshot": "pnpm build:go-ffi && pnpm gas-snapshot:no-build",
     "storage-snapshot": "./scripts/storage-snapshot.sh",
@@ -49,4 +50,4 @@
     "tsx": "^4.1.1",
     "typescript": "^5.2.2"
   }
-}
+}
\ No newline at end of file

packages/contracts-bedrock/scripts/deploy.sh

+#!/usr/bin/env bash
+set -euo pipefail
+
+verify_flag=""
+if [ -n "${DEPLOY_VERIFY:-}" ]; then
+  verify_flag="--verify"
+fi
+
+echo "> Deploying contracts"
+forge script -vvv scripts/Deploy.s.sol:Deploy --rpc-url "$DEPLOY_ETH_RPC_URL" --broadcast --private-key "$DEPLOY_PRIVATE_KEY" $verify_flag
+
+if [ -n "${DEPLOY_GENERATE_HARDHAT_ARTIFACTS:-}" ]; then
+  echo "> Generating hardhat artifacts"
+  forge script -vvv scripts/Deploy.s.sol:Deploy --sig 'sync()' --rpc-url "$DEPLOY_ETH_RPC_URL" --broadcast --private-key "$DEPLOY_PRIVATE_KEY"
+fi

packages/contracts-bedrock/test/setup/Setup.sol

@@ -185,5 +185,7 @@ contract Setup is Deploy {
         vm.label(Predeploys.GAS_PRICE_ORACLE, "GasPriceOracle");
         vm.label(Predeploys.LEGACY_MESSAGE_PASSER, "LegacyMessagePasser");
         vm.label(Predeploys.GOVERNANCE_TOKEN, "GovernanceToken");
+        vm.label(Predeploys.EAS, "EAS");
+        vm.label(Predeploys.SCHEMA_REGISTRY, "SchemaRegistry");
     }
 }

pnpm-lock.yaml

@@ -85,8 +85,8 @@ importers:
         specifier: ^8.0.3
         version: 8.0.3
       lint-staged:
-        specifier: 15.0.2
-        version: 15.0.2
+        specifier: 15.1.0
+        version: 15.1.0
       markdownlint:
         specifier: ^0.32.0
         version: 0.32.0
@@ -192,8 +192,8 @@ importers:
         specifier: workspace:*
         version: link:../core-utils
       '@sentry/node':
-        specifier: ^7.80.0
-        version: 7.80.0
+        specifier: ^7.80.1
+        version: 7.80.1
       bcfg:
         specifier: ^0.2.1
         version: 0.2.1
@@ -247,8 +247,8 @@ importers:
         specifier: ^4.17.19
         version: 4.17.19
       '@types/morgan':
-        specifier: ^1.9.7
-        version: 1.9.7
+        specifier: ^1.9.9
+        version: 1.9.9
       '@types/pino':
         specifier: ^7.0.5
         version: 7.0.5
@@ -3248,13 +3248,13 @@ packages:
       '@noble/hashes': 1.3.2
       '@scure/base': 1.1.3
 
-  /@sentry-internal/tracing@7.80.0:
-    resolution: {integrity: sha512-P1Ab9gamHLsbH9D82i1HY8xfq9dP8runvc4g50AAd6OXRKaJ45f2KGRZUmnMEVqBQ7YoPYp2LFMkrhNYbcZEoQ==}
+  /@sentry-internal/tracing@7.80.1:
+    resolution: {integrity: sha512-5gZ4LPIj2vpQl2/dHBM4uXMi9OI5E0VlOhJQt0foiuN6JJeiOjdpJFcfVqJk69wrc0deVENTtgKKktxqMwVeWQ==}
     engines: {node: '>=8'}
     dependencies:
-      '@sentry/core': 7.80.0
-      '@sentry/types': 7.80.0
-      '@sentry/utils': 7.80.0
+      '@sentry/core': 7.80.1
+      '@sentry/types': 7.80.1
+      '@sentry/utils': 7.80.1
     dev: false
 
   /@sentry/core@5.30.0:
@@ -3268,12 +3268,12 @@ packages:
       tslib: 1.14.1
     dev: true
 
-  /@sentry/core@7.80.0:
-    resolution: {integrity: sha512-nJiiymdTSEyI035/rdD3VOq6FlOZ2wWLR5bit9LK8a3rzHU3UXkwScvEo6zYgs0Xp1sC0yu1S9+0BEiYkmi29A==}
+  /@sentry/core@7.80.1:
+    resolution: {integrity: sha512-3Yh+O9Q86MxwIuJFYtuSSoUCpdx99P1xDAqL0FIPTJ+ekaVMiUJq9NmyaNh9uN2myPSmxvEXW6q3z37zta9ZHg==}
     engines: {node: '>=8'}
     dependencies:
-      '@sentry/types': 7.80.0
-      '@sentry/utils': 7.80.0
+      '@sentry/types': 7.80.1
+      '@sentry/utils': 7.80.1
     dev: false
 
   /@sentry/hub@5.30.0:
@@ -3311,14 +3311,14 @@ packages:
       - supports-color
     dev: true
 
-  /@sentry/node@7.80.0:
-    resolution: {integrity: sha512-J35fqe8J5ac/17ZXT0ML3opYGTOclqYNE9Sybs1y9n6BqacHyzH8By72YrdI03F7JJDHwrcGw+/H8hGpkCwi0Q==}
+  /@sentry/node@7.80.1:
+    resolution: {integrity: sha512-0NWfcZMlyQphKWsvyzfhGm2dCBk5DUPqOGW/vGx18G4tCCYtFcAIj/mCp/4XOEcZRPQgb9vkm+sidGD6DnwWlA==}
     engines: {node: '>=8'}
     dependencies:
-      '@sentry-internal/tracing': 7.80.0
-      '@sentry/core': 7.80.0
-      '@sentry/types': 7.80.0
-      '@sentry/utils': 7.80.0
+      '@sentry-internal/tracing': 7.80.1
+      '@sentry/core': 7.80.1
+      '@sentry/types': 7.80.1
+      '@sentry/utils': 7.80.1
       https-proxy-agent: 5.0.1
     transitivePeerDependencies:
       - supports-color
@@ -3340,8 +3340,8 @@ packages:
     engines: {node: '>=6'}
     dev: true
 
-  /@sentry/types@7.80.0:
-    resolution: {integrity: sha512-4bpMO+2jWiWLDa8zbTASWWNLWe6yhjfPsa7/6VH5y9x1NGtL8oRbqUsTgsvjF3nmeHEMkHQsC8NHPaQ/ibFmZQ==}
+  /@sentry/types@7.80.1:
+    resolution: {integrity: sha512-CVu4uPVTOI3U9kYiOdA085R7jX5H1oVODbs9y+A8opJ0dtJTMueCXgZyE8oXQ0NjGVs6HEeaLkOuiV0mj8X3yw==}
     engines: {node: '>=8'}
     dev: false
 
@@ -3353,11 +3353,11 @@ packages:
       tslib: 1.14.1
     dev: true
 
-  /@sentry/utils@7.80.0:
-    resolution: {integrity: sha512-XbBCEl6uLvE50ftKwrEo6XWdDaZXHXu+kkHXTPWQEcnbvfZKLuG9V0Hxtxxq3xQgyWmuF05OH1GcqYqiO+v5Yg==}
+  /@sentry/utils@7.80.1:
+    resolution: {integrity: sha512-bfFm2e/nEn+b9++QwjNEYCbS7EqmteT8uf0XUs7PljusSimIqqxDtK1pfD9zjynPgC8kW/fVBKv0pe2LufomeA==}
     engines: {node: '>=8'}
     dependencies:
-      '@sentry/types': 7.80.0
+      '@sentry/types': 7.80.1
     dev: false
 
   /@sinclair/typebox@0.27.8:
@@ -3996,10 +3996,10 @@ packages:
     resolution: {integrity: sha512-xKU7bUjiFTIttpWaIZ9qvgg+22O1nmbA+HRxdlR+u6TWsGfmFdXrheJoK4fFxrHNVIOBDvDNKZG+LYBpMHpX3w==}
     dev: true
 
-  /@types/morgan@1.9.7:
-    resolution: {integrity: sha512-4sJFBUBrIZkP5EvMm1L6VCXp3SQe8dnXqlVpe1jsmTjS1JQVmSjnpMNs8DosQd6omBi/K7BSKJ6z/Mc3ki0K9g==}
+  /@types/morgan@1.9.9:
+    resolution: {integrity: sha512-iRYSDKVaC6FkGSpEVVIvrRGw0DfJMiQzIn3qr2G5B3C//AWkulhXgaBd7tS9/J79GWSYMTHGs7PfI5b3Y8m+RQ==}
     dependencies:
-      '@types/node': 20.8.9
+      '@types/node': 20.9.0
     dev: true
 
   /@types/ms@0.7.31:
@@ -10178,8 +10178,8 @@ packages:
       uc.micro: 1.0.6
     dev: true
 
-  /lint-staged@15.0.2:
-    resolution: {integrity: sha512-vnEy7pFTHyVuDmCAIFKR5QDO8XLVlPFQQyujQ/STOxe40ICWqJ6knS2wSJ/ffX/Lw0rz83luRDh+ET7toN+rOw==}
+  /lint-staged@15.1.0:
+    resolution: {integrity: sha512-ZPKXWHVlL7uwVpy8OZ7YQjYDAuO5X4kMh0XgZvPNxLcCCngd0PO5jKQyy3+s4TL2EnHoIXIzP1422f/l3nZKMw==}
     engines: {node: '>=18.12.0'}
     hasBin: true
     dependencies:
@@ -10192,7 +10192,7 @@ packages:
       micromatch: 4.0.5
       pidtree: 0.6.0
       string-argv: 0.3.2
-      yaml: 2.3.3
+      yaml: 2.3.4
     transitivePeerDependencies:
       - supports-color
     dev: true
@@ -11913,7 +11913,7 @@ packages:
     engines: {node: '>=10'}
     hasBin: true
     dependencies:
-      '@sentry/node': 7.80.0
+      '@sentry/node': 7.80.1
       commander: 2.20.3
       pumpify: 2.0.1
       split2: 3.2.2
@@ -12007,7 +12007,7 @@ packages:
         optional: true
     dependencies:
       lilconfig: 2.1.0
-      yaml: 2.3.2
+      yaml: 2.3.3
     dev: true
 
   /postcss@8.4.27:
@@ -15440,13 +15440,13 @@ packages:
     engines: {node: '>= 14'}
     dev: true
 
-  /yaml@2.3.2:
-    resolution: {integrity: sha512-N/lyzTPaJasoDmfV7YTrYCI0G/3ivm/9wdG0aHuheKowWQwGTsK0Eoiw6utmzAnI6pkJa0DUVygvp3spqqEKXg==}
+  /yaml@2.3.3:
+    resolution: {integrity: sha512-zw0VAJxgeZ6+++/su5AFoqBbZbrEakwu+X0M5HmcwUiBL7AzcuPKjj5we4xfQLp78LkEMpD0cOnUhmgOVy3KdQ==}
     engines: {node: '>= 14'}
     dev: true
 
-  /yaml@2.3.3:
-    resolution: {integrity: sha512-zw0VAJxgeZ6+++/su5AFoqBbZbrEakwu+X0M5HmcwUiBL7AzcuPKjj5we4xfQLp78LkEMpD0cOnUhmgOVy3KdQ==}
+  /yaml@2.3.4:
+    resolution: {integrity: sha512-8aAvwVUSHpfEqTQ4w/KMlf3HcRdt50E5ODIQJBw1fQ5RL34xabzxtUlzTXVqc4rkZsPbvrXKWnABCD7kWSmocA==}
     engines: {node: '>= 14'}
     dev: true