Merge branch 'develop' into feat/tx-delay-pm

.changeset/tough-flies-fetch.md

+---
+'@eth-optimism/sdk': patch
+---
+
+Add warning if bedrock is not turned on

.circleci/config.yml

@@ -3,6 +3,7 @@ version: 2.1
 orbs:
   go: circleci/go@1.5.0
   gcp-cli: circleci/gcp-cli@3.0.1
+  slack: circleci/slack@4.10.1
 commands:
   gcp-oidc-authenticate:
     description: "Authenticate with GCP using a CircleCI OIDC token."
@@ -611,10 +612,20 @@ jobs:
       - run:
           name: markdown lint
           command: yarn lint:specs:check
+
+  bedrock-markdown-links:
+    machine:
+      image: ubuntu-2204:2022.07.1
+    steps:
+      - checkout
       - run:
           name: link lint
           command: |
-            docker run --init -it -v `pwd`:/input lycheeverse/lychee --verbose --no-progress --exclude-loopback --exclude twitter.com --exclude-mail /input/README.md "/input/specs/**/*.md"
+            make bedrock-markdown-links
+      - slack/notify:
+          channel: C055R639XT9 #notify-link-check
+          event: fail
+          template: basic_fail_1
 
   fuzz-op-node:
     docker:
@@ -1105,6 +1116,21 @@ jobs:
     steps:
       - run: echo Done
 
+  fpp-verify:
+    docker:
+      - image: cimg/go:1.19
+    steps:
+      - checkout
+      - run:
+          name: verify-goerli
+          command: |
+            make verify-goerli
+          working_directory: op-program
+      - slack/notify:
+          channel: C03N11M0BBN
+          event: fail
+          template: basic_fail_1
+
 workflows:
   main:
     jobs:
@@ -1478,7 +1504,7 @@ workflows:
           type: approval
           filters:
             tags:
-              only: /^op-[a-z0-9\-]*\/v.*/
+              only: /^(proxyd|op-[a-z0-9\-]*)\/v.*/
             branches:
               ignore: /.*/
       - docker-release:
@@ -1560,6 +1586,21 @@ workflows:
             - oplabs-gcr-release
           requires:
             - hold
+      - docker-release:
+          name: proxyd-docker-release
+          filters:
+            tags:
+              only: /^proxyd\/v.*/
+            branches:
+              ignore: /.*/
+          docker_file: proxyd/Dockerfile
+          docker_name: proxyd
+          docker_tags: <<pipeline.git.revision>>,<<pipeline.git.branch>>
+          docker_context: .
+          context:
+            - oplabs-gcr-release
+          requires:
+            - hold
   release-ci-builder:
     jobs:
       - docker-publish:
@@ -1575,3 +1616,28 @@ workflows:
           docker_context: ./ops/docker/ci-builder
           context:
             - oplabs-gcr
+  scheduled-fpp:
+    triggers:
+      - schedule:
+          # run every 4 hours
+          cron: "0 0,6,12,18 * * *"
+          filters:
+            branches:
+              only: [ "develop" ]
+    jobs:
+      - fpp-verify:
+          context:
+            - slack
+            - oplabs-fpp-nodes
+
+  scheduled-link-check:
+    triggers:
+      - schedule:
+          # Run once a day, only on the develop branch
+          cron: "0 0 * * *"
+          filters:
+            branches:
+              only: [ "develop" ]
+    jobs:
+      - bedrock-markdown-links:
+          context: slack

.github/CODEOWNERS

@@ -13,13 +13,13 @@
 /packages/core-utils            @ethereum-optimism/legacy-reviewers
 /packages/data-transport-layer  @ethereum-optimism/legacy-reviewers
 /packages/chain-mon             @smartcontracts
-/packages/fault-detector        @ethereum-optimism/legacy-reviewers
+/packages/fault-detector        @ethereum-optimism/devxpod
 /packages/hardhat-deploy-config @ethereum-optimism/legacy-reviewers
 /packages/message-relayer       @ethereum-optimism/legacy-reviewers
 /packages/migration-data        @ethereum-optimism/legacy-reviewers
 /packages/replica-healthcheck   @ethereum-optimism/legacy-reviewers
-/packages/sdk                   @ethereum-optimism/ecopod
-/packages/atst                  @ethereum-optimism/ecopod
+/packages/sdk                   @ethereum-optimism/devxpod
+/packages/atst                  @ethereum-optimism/devxpod
 
 # Bedrock codebases
 /bedrock-devnet @ethereum-optimism/go-reviewers
@@ -42,7 +42,7 @@
 
 # Misc
 /proxyd           @ethereum-optimism/infra-reviewers
-/indexer          @ethereum-optimism/infra-reviewers
+/indexer          @ethereum-optimism/devxpod
 /infra            @ethereum-optimism/infra-reviewers
 /specs            @ethereum-optimism/contract-reviewers @ethereum-optimism/go-reviewers
 /endpoint-monitor @ethereum-optimism/infra-reviewers

Makefile

@@ -120,3 +120,6 @@ tag-bedrock-go-modules:
 update-op-geth:
 	./ops/scripts/update-op-geth.py
 .PHONY: update-op-geth
+
+bedrock-markdown-links:
+	docker run --init -it -v `pwd`:/input lycheeverse/lychee --verbose --no-progress --exclude-loopback --exclude twitter.com --exclude explorer.optimism.io --exclude-mail /input/README.md "/input/specs/**/*.md"

op-batcher/batcher/batch_submitter.go

@@ -7,7 +7,6 @@ import (
 	"os"
 	"os/signal"
 	"syscall"
-	"time"
 
 	gethrpc "github.com/ethereum/go-ethereum/rpc"
 	"github.com/urfave/cli"
@@ -15,17 +14,12 @@ import (
 	"github.com/ethereum-optimism/optimism/op-batcher/flags"
 	"github.com/ethereum-optimism/optimism/op-batcher/metrics"
 	"github.com/ethereum-optimism/optimism/op-batcher/rpc"
+	opservice "github.com/ethereum-optimism/optimism/op-service"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
 	oppprof "github.com/ethereum-optimism/optimism/op-service/pprof"
 	oprpc "github.com/ethereum-optimism/optimism/op-service/rpc"
 )
 
-const (
-	// defaultDialTimeout is default duration the service will wait on
-	// startup to make a connection to either the L1 or L2 backends.
-	defaultDialTimeout = 5 * time.Second
-)
-
 // Main is the entrypoint into the Batch Submitter. This method returns a
 // closure that executes the service and blocks until the service exits. The use
 // of a closure allows the parameters bound to the top-level main package, e.g.
@@ -40,6 +34,7 @@ func Main(version string, cliCtx *cli.Context) error {
 	}
 
 	l := oplog.NewLogger(cfg.LogConfig)
+	opservice.ValidateEnvVars(flags.EnvVarPrefix, flags.Flags, l)
 	m := metrics.NewMetrics("default")
 	l.Info("Initializing Batch Submitter")
 

op-batcher/batcher/driver.go

@@ -13,6 +13,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-batcher/metrics"
 	"github.com/ethereum-optimism/optimism/op-node/eth"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
+	opclient "github.com/ethereum-optimism/optimism/op-service/client"
 	"github.com/ethereum-optimism/optimism/op-service/txmgr"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/types"
@@ -49,17 +50,17 @@ func NewBatchSubmitterFromCLIConfig(cfg CLIConfig, l log.Logger, m metrics.Metri
 
 	// Connect to L1 and L2 providers. Perform these last since they are the
 	// most expensive.
-	l1Client, err := dialEthClientWithTimeout(ctx, cfg.L1EthRpc)
+	l1Client, err := opclient.DialEthClientWithTimeout(ctx, cfg.L1EthRpc, opclient.DefaultDialTimeout)
 	if err != nil {
 		return nil, err
 	}
 
-	l2Client, err := dialEthClientWithTimeout(ctx, cfg.L2EthRpc)
+	l2Client, err := opclient.DialEthClientWithTimeout(ctx, cfg.L2EthRpc, opclient.DefaultDialTimeout)
 	if err != nil {
 		return nil, err
 	}
 
-	rollupClient, err := dialRollupClientWithTimeout(ctx, cfg.RollupRpc)
+	rollupClient, err := opclient.DialRollupClientWithTimeout(ctx, cfg.RollupRpc, opclient.DefaultDialTimeout)
 	if err != nil {
 		return nil, err
 	}

op-batcher/flags/flags.go

@@ -15,24 +15,24 @@ import (
 	"github.com/ethereum-optimism/optimism/op-service/txmgr"
 )
 
-const envVarPrefix = "OP_BATCHER"
+const EnvVarPrefix = "OP_BATCHER"
 
 var (
 	// Required flags
 	L1EthRpcFlag = cli.StringFlag{
 		Name:   "l1-eth-rpc",
 		Usage:  "HTTP provider URL for L1",
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "L1_ETH_RPC"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "L1_ETH_RPC"),
 	}
 	L2EthRpcFlag = cli.StringFlag{
 		Name:   "l2-eth-rpc",
 		Usage:  "HTTP provider URL for L2 execution engine",
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "L2_ETH_RPC"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "L2_ETH_RPC"),
 	}
 	RollupRpcFlag = cli.StringFlag{
 		Name:   "rollup-rpc",
 		Usage:  "HTTP provider URL for Rollup node",
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "ROLLUP_RPC"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "ROLLUP_RPC"),
 	}
 	// Optional flags
 	SubSafetyMarginFlag = cli.Uint64Flag{
@@ -41,54 +41,54 @@ var (
 			"from a channel's timeout and sequencing window, to guarantee safe inclusion " +
 			"of a channel on L1.",
 		Value:  10,
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "SUB_SAFETY_MARGIN"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "SUB_SAFETY_MARGIN"),
 	}
 	PollIntervalFlag = cli.DurationFlag{
 		Name:   "poll-interval",
 		Usage:  "How frequently to poll L2 for new blocks",
 		Value:  6 * time.Second,
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "POLL_INTERVAL"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "POLL_INTERVAL"),
 	}
 	MaxPendingTransactionsFlag = cli.Uint64Flag{
 		Name:   "max-pending-tx",
 		Usage:  "The maximum number of pending transactions. 0 for no limit.",
 		Value:  1,
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "MAX_PENDING_TX"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "MAX_PENDING_TX"),
 	}
 	MaxChannelDurationFlag = cli.Uint64Flag{
 		Name:   "max-channel-duration",
 		Usage:  "The maximum duration of L1-blocks to keep a channel open. 0 to disable.",
 		Value:  0,
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "MAX_CHANNEL_DURATION"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "MAX_CHANNEL_DURATION"),
 	}
 	MaxL1TxSizeBytesFlag = cli.Uint64Flag{
 		Name:   "max-l1-tx-size-bytes",
 		Usage:  "The maximum size of a batch tx submitted to L1.",
 		Value:  120_000,
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "MAX_L1_TX_SIZE_BYTES"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "MAX_L1_TX_SIZE_BYTES"),
 	}
 	TargetL1TxSizeBytesFlag = cli.Uint64Flag{
 		Name:   "target-l1-tx-size-bytes",
 		Usage:  "The target size of a batch tx submitted to L1.",
 		Value:  100_000,
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "TARGET_L1_TX_SIZE_BYTES"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "TARGET_L1_TX_SIZE_BYTES"),
 	}
 	TargetNumFramesFlag = cli.IntFlag{
 		Name:   "target-num-frames",
 		Usage:  "The target number of frames to create per channel",
 		Value:  1,
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "TARGET_NUM_FRAMES"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "TARGET_NUM_FRAMES"),
 	}
 	ApproxComprRatioFlag = cli.Float64Flag{
 		Name:   "approx-compr-ratio",
 		Usage:  "The approximate compression ratio (<= 1.0)",
 		Value:  0.4,
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "APPROX_COMPR_RATIO"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "APPROX_COMPR_RATIO"),
 	}
 	StoppedFlag = cli.BoolFlag{
 		Name:   "stopped",
 		Usage:  "Initialize the batcher in a stopped state. The batcher can be started using the admin_startBatcher RPC",
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "STOPPED"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "STOPPED"),
 	}
 	// Legacy Flags
 	SequencerHDPathFlag = txmgr.SequencerHDPathFlag
@@ -114,12 +114,12 @@ var optionalFlags = []cli.Flag{
 }
 
 func init() {
-	optionalFlags = append(optionalFlags, oprpc.CLIFlags(envVarPrefix)...)
-	optionalFlags = append(optionalFlags, oplog.CLIFlags(envVarPrefix)...)
-	optionalFlags = append(optionalFlags, opmetrics.CLIFlags(envVarPrefix)...)
-	optionalFlags = append(optionalFlags, oppprof.CLIFlags(envVarPrefix)...)
-	optionalFlags = append(optionalFlags, rpc.CLIFlags(envVarPrefix)...)
-	optionalFlags = append(optionalFlags, txmgr.CLIFlags(envVarPrefix)...)
+	optionalFlags = append(optionalFlags, oprpc.CLIFlags(EnvVarPrefix)...)
+	optionalFlags = append(optionalFlags, oplog.CLIFlags(EnvVarPrefix)...)
+	optionalFlags = append(optionalFlags, opmetrics.CLIFlags(EnvVarPrefix)...)
+	optionalFlags = append(optionalFlags, oppprof.CLIFlags(EnvVarPrefix)...)
+	optionalFlags = append(optionalFlags, rpc.CLIFlags(EnvVarPrefix)...)
+	optionalFlags = append(optionalFlags, txmgr.CLIFlags(EnvVarPrefix)...)
 
 	Flags = append(requiredFlags, optionalFlags...)
 }

op-bindings/bindings/weth9_more.go

@@ -13,7 +13,7 @@ const WETH9StorageLayoutJSON = "{\"storage\":[{\"astId\":1000,\"contract\":\"con
 
 var WETH9StorageLayout = new(solc.StorageLayout)
 
-var WETH9DeployedBin = "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"
+var WETH9DeployedBin = "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"
 
 func init() {
 	if err := json.Unmarshal([]byte(WETH9StorageLayoutJSON), WETH9StorageLayout); err != nil {

op-challenger/challenger/challenger.go

+package challenger
+
+import (
+	"context"
+	_ "net/http/pprof"
+	"sync"
+	"time"
+
+	abi "github.com/ethereum/go-ethereum/accounts/abi"
+	bind "github.com/ethereum/go-ethereum/accounts/abi/bind"
+	common "github.com/ethereum/go-ethereum/common"
+	ethclient "github.com/ethereum/go-ethereum/ethclient"
+	log "github.com/ethereum/go-ethereum/log"
+
+	config "github.com/ethereum-optimism/optimism/op-challenger/config"
+	metrics "github.com/ethereum-optimism/optimism/op-challenger/metrics"
+
+	bindings "github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	sources "github.com/ethereum-optimism/optimism/op-node/sources"
+	opclient "github.com/ethereum-optimism/optimism/op-service/client"
+	txmgr "github.com/ethereum-optimism/optimism/op-service/txmgr"
+)
+
+// Challenger contests invalid L2OutputOracle outputs
+type Challenger struct {
+	txMgr txmgr.TxManager
+	wg    sync.WaitGroup
+	done  chan struct{}
+
+	log  log.Logger
+	metr metrics.Metricer
+
+	ctx    context.Context
+	cancel context.CancelFunc
+
+	l1Client *ethclient.Client
+
+	rollupClient *sources.RollupClient
+
+	// l2 Output Oracle contract
+	l2ooContract     *bindings.L2OutputOracleCaller
+	l2ooContractAddr common.Address
+	l2ooABI          *abi.ABI
+
+	// dispute game factory contract
+	// dgfContract     *bindings.DisputeGameFactoryCaller
+	dgfContractAddr common.Address
+	// dgfABI          *abi.ABI
+
+	networkTimeout time.Duration
+}
+
+// NewChallenger creates a new Challenger
+func NewChallenger(cfg config.Config, l log.Logger, m metrics.Metricer) (*Challenger, error) {
+	ctx, cancel := context.WithCancel(context.Background())
+
+	txManager, err := txmgr.NewSimpleTxManager("challenger", l, m, *cfg.TxMgrConfig)
+	if err != nil {
+		cancel()
+		return nil, err
+	}
+
+	// Connect to L1 and L2 providers. Perform these last since they are the most expensive.
+	l1Client, err := opclient.DialEthClientWithTimeout(ctx, cfg.L1EthRpc, opclient.DefaultDialTimeout)
+	if err != nil {
+		cancel()
+		return nil, err
+	}
+
+	rollupClient, err := opclient.DialRollupClientWithTimeout(ctx, cfg.RollupRpc, opclient.DefaultDialTimeout)
+	if err != nil {
+		cancel()
+		return nil, err
+	}
+
+	l2ooContract, err := bindings.NewL2OutputOracleCaller(cfg.L2OOAddress, l1Client)
+	if err != nil {
+		cancel()
+		return nil, 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
+	}
+	l.Info("Connected to L2OutputOracle", "address", cfg.L2OOAddress, "version", version)
+
+	parsed, err := bindings.L2OutputOracleMetaData.GetAbi()
+	if err != nil {
+		cancel()
+		return nil, err
+	}
+
+	return &Challenger{
+		txMgr: txManager,
+		done:  make(chan struct{}),
+
+		log:  l,
+		metr: m,
+
+		ctx:    ctx,
+		cancel: cancel,
+
+		rollupClient: rollupClient,
+
+		l1Client: l1Client,
+
+		l2ooContract:     l2ooContract,
+		l2ooContractAddr: cfg.L2OOAddress,
+		l2ooABI:          parsed,
+
+		dgfContractAddr: cfg.DGFAddress,
+
+		networkTimeout: cfg.NetworkTimeout,
+	}, nil
+}
+
+// Start runs the challenger in a goroutine.
+func (c *Challenger) Start() error {
+	c.log.Error("challenger not implemented.")
+	return nil
+}
+
+// Stop closes the challenger and waits for spawned goroutines to exit.
+func (c *Challenger) Stop() {
+	c.cancel()
+	close(c.done)
+	c.wg.Wait()
+}

op-challenger/challenger/config.go

-package challenger
-
-import (
-	"time"
-
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/ethclient"
-	"github.com/urfave/cli"
-
-	flags "github.com/ethereum-optimism/optimism/op-challenger/flags"
-	sources "github.com/ethereum-optimism/optimism/op-node/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"
-	oprpc "github.com/ethereum-optimism/optimism/op-service/rpc"
-	txmgr "github.com/ethereum-optimism/optimism/op-service/txmgr"
-)
-
-// Config contains the well typed fields that are used to initialize the challenger.
-// It is intended for programmatic use.
-type Config struct {
-	L2OutputOracleAddr common.Address
-	DisputeGameFactory common.Address
-	NetworkTimeout     time.Duration
-	TxManager          txmgr.TxManager
-	L1Client           *ethclient.Client
-	RollupClient       *sources.RollupClient
-}
-
-// 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 Challenger is started.
-type CLIConfig struct {
-	// L1EthRpc is the HTTP provider URL for L1.
-	L1EthRpc string
-
-	// RollupRpc is the HTTP provider URL for the rollup node.
-	RollupRpc string
-
-	// L2OOAddress is the L2OutputOracle contract address.
-	L2OOAddress string
-
-	// DGFAddress is the DisputeGameFactory contract address.
-	DGFAddress string
-
-	TxMgrConfig txmgr.CLIConfig
-
-	RPCConfig oprpc.CLIConfig
-
-	LogConfig oplog.CLIConfig
-
-	MetricsConfig opmetrics.CLIConfig
-
-	PprofConfig oppprof.CLIConfig
-}
-
-func (c CLIConfig) Check() error {
-	if err := c.RPCConfig.Check(); err != nil {
-		return err
-	}
-	if err := c.LogConfig.Check(); err != nil {
-		return err
-	}
-	if err := c.MetricsConfig.Check(); err != nil {
-		return err
-	}
-	if err := c.PprofConfig.Check(); err != nil {
-		return err
-	}
-	if err := c.TxMgrConfig.Check(); err != nil {
-		return err
-	}
-	return nil
-}
-
-// NewConfig parses the Config from the provided flags or environment variables.
-func NewConfig(ctx *cli.Context) CLIConfig {
-	return CLIConfig{
-		// Required Flags
-		L1EthRpc:    ctx.GlobalString(flags.L1EthRpcFlag.Name),
-		RollupRpc:   ctx.GlobalString(flags.RollupRpcFlag.Name),
-		L2OOAddress: ctx.GlobalString(flags.L2OOAddressFlag.Name),
-		DGFAddress:  ctx.GlobalString(flags.DGFAddressFlag.Name),
-		TxMgrConfig: txmgr.ReadCLIConfig(ctx),
-		// Optional Flags
-		RPCConfig:     oprpc.ReadCLIConfig(ctx),
-		LogConfig:     oplog.ReadCLIConfig(ctx),
-		MetricsConfig: opmetrics.ReadCLIConfig(ctx),
-		PprofConfig:   oppprof.ReadCLIConfig(ctx),
-	}
-}

op-challenger/challenger/entrypoint.go

+package challenger
+
+import (
+	"context"
+	"fmt"
+	_ "net/http/pprof"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"github.com/ethereum/go-ethereum/log"
+
+	"github.com/ethereum-optimism/optimism/op-challenger/config"
+	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
+	oppprof "github.com/ethereum-optimism/optimism/op-service/pprof"
+	oprpc "github.com/ethereum-optimism/optimism/op-service/rpc"
+)
+
+// Main is the entrypoint into the Challenger. This method executes the
+// service and blocks until the service exits.
+func Main(logger log.Logger, version string, cfg *config.Config) error {
+	if err := cfg.Check(); err != nil {
+		return fmt.Errorf("invalid config: %w", err)
+	}
+
+	m := metrics.NewMetrics("default")
+	logger.Info("Initializing Challenger")
+
+	challenger, err := NewChallenger(*cfg, logger, m)
+	if err != nil {
+		logger.Error("Unable to create the Challenger", "error", err)
+		return err
+	}
+
+	logger.Info("Starting Challenger")
+	ctx, cancel := context.WithCancel(context.Background())
+	if err := challenger.Start(); err != nil {
+		cancel()
+		logger.Error("Unable to start Challenger", "error", err)
+		return err
+	}
+	defer challenger.Stop()
+
+	logger.Info("Challenger started")
+	pprofConfig := cfg.PprofConfig
+	if pprofConfig.Enabled {
+		logger.Info("starting pprof", "addr", pprofConfig.ListenAddr, "port", pprofConfig.ListenPort)
+		go func() {
+			if err := oppprof.ListenAndServe(ctx, pprofConfig.ListenAddr, pprofConfig.ListenPort); err != nil {
+				logger.Error("error starting pprof", "err", err)
+			}
+		}()
+	}
+
+	metricsCfg := cfg.MetricsConfig
+	if metricsCfg.Enabled {
+		log.Info("starting metrics server", "addr", metricsCfg.ListenAddr, "port", metricsCfg.ListenPort)
+		go func() {
+			if err := m.Serve(ctx, metricsCfg.ListenAddr, metricsCfg.ListenPort); err != nil {
+				logger.Error("error starting metrics server", err)
+			}
+		}()
+		m.StartBalanceMetrics(ctx, logger, challenger.l1Client, challenger.txMgr.From())
+	}
+
+	rpcCfg := cfg.RPCConfig
+	server := oprpc.NewServer(rpcCfg.ListenAddr, rpcCfg.ListenPort, version, oprpc.WithLogger(logger))
+	if err := server.Start(); err != nil {
+		cancel()
+		return fmt.Errorf("error starting RPC server: %w", err)
+	}
+
+	m.RecordInfo(version)
+	m.RecordUp()
+
+	interruptChannel := make(chan os.Signal, 1)
+	signal.Notify(interruptChannel, []os.Signal{
+		os.Interrupt,
+		os.Kill,
+		syscall.SIGTERM,
+		syscall.SIGQUIT,
+	}...)
+	<-interruptChannel
+	cancel()
+
+	return nil
+}

op-challenger/cmd/main.go

 package main
 
 import (
+	"fmt"
 	"os"
 
+	challenger "github.com/ethereum-optimism/optimism/op-challenger/challenger"
+	config "github.com/ethereum-optimism/optimism/op-challenger/config"
 	flags "github.com/ethereum-optimism/optimism/op-challenger/flags"
+	version "github.com/ethereum-optimism/optimism/op-challenger/version"
 
 	log "github.com/ethereum/go-ethereum/log"
 	cli "github.com/urfave/cli"
@@ -11,24 +15,71 @@ import (
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
 )
 
-const Version = "0.1.0"
+var (
+	GitCommit = ""
+	GitDate   = ""
+)
+
+// VersionWithMeta holds the textual version string including the metadata.
+var VersionWithMeta = func() string {
+	v := version.Version
+	if GitCommit != "" {
+		v += "-" + GitCommit[:8]
+	}
+	if GitDate != "" {
+		v += "-" + GitDate
+	}
+	if version.Meta != "" {
+		v += "-" + version.Meta
+	}
+	return v
+}()
 
 func main() {
+	args := os.Args
+	if err := run(args, challenger.Main); err != nil {
+		log.Crit("Application failed", "err", err)
+	}
+}
+
+type ConfigAction func(log log.Logger, version string, config *config.Config) error
+
+// run parses the supplied args to create a config.Config instance, sets up logging
+// then calls the supplied ConfigAction.
+// This allows testing the translation from CLI arguments to Config
+func run(args []string, action ConfigAction) error {
+	// Set up logger with a default INFO level in case we fail to parse flags,
+	// otherwise the final critical log won't show what the parsing error was.
 	oplog.SetupDefaults()
 
 	app := cli.NewApp()
+	app.Version = VersionWithMeta
 	app.Flags = flags.Flags
-	app.Version = Version
 	app.Name = "op-challenger"
-	app.Usage = "Challenge invalid L2OutputOracle outputs"
+	app.Usage = "Challenge Invalid L2OutputOracle Outputs"
 	app.Description = "A modular op-stack challenge agent for dispute games written in golang."
-
 	app.Action = func(ctx *cli.Context) error {
-		log.Debug("Challenger not implemented...")
-		return nil
+		logger, err := setupLogging(ctx)
+		if err != nil {
+			return err
+		}
+		logger.Info("Starting challenger", "version", VersionWithMeta)
+
+		cfg, err := config.NewConfigFromCLI(ctx)
+		if err != nil {
+			return err
+		}
+		return action(logger, VersionWithMeta, cfg)
 	}
-	err := app.Run(os.Args)
-	if err != nil {
-		log.Crit("Application failed", "message", err)
+
+	return app.Run(args)
+}
+
+func setupLogging(ctx *cli.Context) (log.Logger, error) {
+	logCfg := oplog.ReadCLIConfig(ctx)
+	if err := logCfg.Check(); err != nil {
+		return nil, fmt.Errorf("log config error: %w", err)
 	}
+	logger := oplog.NewLogger(logCfg)
+	return logger, nil
 }

op-challenger/config/config.go

+package config
+
+import (
+	"errors"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/urfave/cli"
+
+	flags "github.com/ethereum-optimism/optimism/op-challenger/flags"
+
+	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"
+	oprpc "github.com/ethereum-optimism/optimism/op-service/rpc"
+	txmgr "github.com/ethereum-optimism/optimism/op-service/txmgr"
+)
+
+var (
+	ErrMissingL1EthRPC       = errors.New("missing l1 eth rpc url")
+	ErrMissingRollupRpc      = errors.New("missing rollup rpc url")
+	ErrMissingL2OOAddress    = errors.New("missing l2 output oracle contract address")
+	ErrMissingDGFAddress     = errors.New("missing dispute game factory contract address")
+	ErrInvalidNetworkTimeout = errors.New("invalid network timeout")
+	ErrMissingTxMgrConfig    = errors.New("missing tx manager config")
+	ErrMissingRPCConfig      = errors.New("missing rpc config")
+	ErrMissingLogConfig      = errors.New("missing log config")
+	ErrMissingMetricsConfig  = errors.New("missing metrics config")
+	ErrMissingPprofConfig    = errors.New("missing pprof config")
+)
+
+// Config is a well typed config that is parsed from the CLI params.
+// This also contains config options for auxiliary services.
+// It is used to initialize the challenger.
+type Config struct {
+	// L1EthRpc is the HTTP provider URL for L1.
+	L1EthRpc string
+
+	// RollupRpc is the HTTP provider URL for the rollup node.
+	RollupRpc string
+
+	// L2OOAddress is the L2OutputOracle contract address.
+	L2OOAddress common.Address
+
+	// DGFAddress is the DisputeGameFactory contract address.
+	DGFAddress common.Address
+
+	// NetworkTimeout is the timeout for network requests.
+	NetworkTimeout time.Duration
+
+	TxMgrConfig *txmgr.CLIConfig
+
+	RPCConfig *oprpc.CLIConfig
+
+	LogConfig *oplog.CLIConfig
+
+	MetricsConfig *opmetrics.CLIConfig
+
+	PprofConfig *oppprof.CLIConfig
+}
+
+func (c Config) Check() error {
+	if c.L1EthRpc == "" {
+		return ErrMissingL1EthRPC
+	}
+	if c.RollupRpc == "" {
+		return ErrMissingRollupRpc
+	}
+	if c.L2OOAddress == (common.Address{}) {
+		return ErrMissingL2OOAddress
+	}
+	if c.DGFAddress == (common.Address{}) {
+		return ErrMissingDGFAddress
+	}
+	if c.NetworkTimeout == 0 {
+		return ErrInvalidNetworkTimeout
+	}
+	if c.TxMgrConfig == nil {
+		return ErrMissingTxMgrConfig
+	}
+	if c.RPCConfig == nil {
+		return ErrMissingRPCConfig
+	}
+	if c.LogConfig == nil {
+		return ErrMissingLogConfig
+	}
+	if c.MetricsConfig == nil {
+		return ErrMissingMetricsConfig
+	}
+	if c.PprofConfig == nil {
+		return ErrMissingPprofConfig
+	}
+	if err := c.RPCConfig.Check(); err != nil {
+		return err
+	}
+	if err := c.LogConfig.Check(); err != nil {
+		return err
+	}
+	if err := c.MetricsConfig.Check(); err != nil {
+		return err
+	}
+	if err := c.PprofConfig.Check(); err != nil {
+		return err
+	}
+	if err := c.TxMgrConfig.Check(); err != nil {
+		return err
+	}
+	return nil
+}
+
+// NewConfig creates a Config with all optional values set to the CLI default value
+func NewConfig(
+	L1EthRpc string,
+	RollupRpc string,
+	L2OOAddress common.Address,
+	DGFAddress common.Address,
+	NetworkTimeout time.Duration,
+	TxMgrConfig *txmgr.CLIConfig,
+	RPCConfig *oprpc.CLIConfig,
+	LogConfig *oplog.CLIConfig,
+	MetricsConfig *opmetrics.CLIConfig,
+	PprofConfig *oppprof.CLIConfig,
+) *Config {
+	return &Config{
+		L1EthRpc:       L1EthRpc,
+		RollupRpc:      RollupRpc,
+		L2OOAddress:    L2OOAddress,
+		DGFAddress:     DGFAddress,
+		NetworkTimeout: NetworkTimeout,
+		TxMgrConfig:    TxMgrConfig,
+		RPCConfig:      RPCConfig,
+		LogConfig:      LogConfig,
+		MetricsConfig:  MetricsConfig,
+		PprofConfig:    PprofConfig,
+	}
+}
+
+// NewConfigFromCLI parses the Config from the provided flags or environment variables.
+func NewConfigFromCLI(ctx *cli.Context) (*Config, error) {
+	if err := flags.CheckRequired(ctx); err != nil {
+		return nil, err
+	}
+	l1EthRpc := ctx.GlobalString(flags.L1EthRpcFlag.Name)
+	if l1EthRpc == "" {
+		return nil, ErrMissingL1EthRPC
+	}
+	rollupRpc := ctx.GlobalString(flags.RollupRpcFlag.Name)
+	if rollupRpc == "" {
+		return nil, ErrMissingRollupRpc
+	}
+	l2ooAddress := common.HexToAddress(ctx.GlobalString(flags.L2OOAddressFlag.Name))
+	if l2ooAddress == (common.Address{}) {
+		return nil, ErrMissingL2OOAddress
+	}
+	dgfAddress := common.HexToAddress(ctx.GlobalString(flags.DGFAddressFlag.Name))
+	if dgfAddress == (common.Address{}) {
+		return nil, ErrMissingDGFAddress
+	}
+
+	txMgrConfig := txmgr.ReadCLIConfig(ctx)
+	rpcConfig := oprpc.ReadCLIConfig(ctx)
+	logConfig := oplog.ReadCLIConfig(ctx)
+	metricsConfig := opmetrics.ReadCLIConfig(ctx)
+	pprofConfig := oppprof.ReadCLIConfig(ctx)
+
+	return &Config{
+		// Required Flags
+		L1EthRpc:    l1EthRpc,
+		RollupRpc:   rollupRpc,
+		L2OOAddress: l2ooAddress,
+		DGFAddress:  dgfAddress,
+		TxMgrConfig: &txMgrConfig,
+		// Optional Flags
+		RPCConfig:     &rpcConfig,
+		LogConfig:     &logConfig,
+		MetricsConfig: &metricsConfig,
+		PprofConfig:   &pprofConfig,
+	}, nil
+}

op-challenger/config/config_test.go

+package config
+
+import (
+	"testing"
+	"time"
+
+	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"
+	oprpc "github.com/ethereum-optimism/optimism/op-service/rpc"
+	txmgr "github.com/ethereum-optimism/optimism/op-service/txmgr"
+	client "github.com/ethereum-optimism/optimism/op-signer/client"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/stretchr/testify/require"
+)
+
+var (
+	validL1EthRpc       = "http://localhost:8545"
+	validRollupRpc      = "http://localhost:8546"
+	validL2OOAddress    = common.HexToAddress("0x7bdd3b028C4796eF0EAf07d11394d0d9d8c24139")
+	validDGFAddress     = common.HexToAddress("0x7bdd3b028C4796eF0EAf07d11394d0d9d8c24139")
+	validNetworkTimeout = time.Duration(5) * time.Second
+)
+
+var validTxMgrConfig = txmgr.CLIConfig{
+	L1RPCURL:                  validL1EthRpc,
+	NumConfirmations:          10,
+	NetworkTimeout:            validNetworkTimeout,
+	ResubmissionTimeout:       time.Duration(5) * time.Second,
+	ReceiptQueryInterval:      time.Duration(5) * time.Second,
+	TxNotInMempoolTimeout:     time.Duration(5) * time.Second,
+	SafeAbortNonceTooLowCount: 10,
+	SignerCLIConfig: client.CLIConfig{
+		Endpoint: "http://localhost:8547",
+		// First address for the default hardhat mnemonic
+		Address: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+	},
+}
+
+var validRPCConfig = oprpc.CLIConfig{
+	ListenAddr: "localhost:8547",
+	ListenPort: 8547,
+}
+
+var validLogConfig = oplog.DefaultCLIConfig()
+
+var validMetricsConfig = opmetrics.CLIConfig{
+	Enabled: false,
+}
+
+var validPprofConfig = oppprof.CLIConfig{
+	Enabled: false,
+}
+
+func validConfig() *Config {
+	cfg := NewConfig(
+		validL1EthRpc,
+		validRollupRpc,
+		validL2OOAddress,
+		validDGFAddress,
+		validNetworkTimeout,
+		&validTxMgrConfig,
+		&validRPCConfig,
+		&validLogConfig,
+		&validMetricsConfig,
+		&validPprofConfig,
+	)
+	return cfg
+}
+
+// TestValidConfigIsValid checks that the config provided by validConfig is actually valid
+func TestValidConfigIsValid(t *testing.T) {
+	err := validConfig().Check()
+	require.NoError(t, err)
+}
+
+func TestTxMgrConfig(t *testing.T) {
+	t.Run("Required", func(t *testing.T) {
+		config := validConfig()
+		config.TxMgrConfig = nil
+		err := config.Check()
+		require.ErrorIs(t, err, ErrMissingTxMgrConfig)
+	})
+
+	t.Run("Invalid", func(t *testing.T) {
+		config := validConfig()
+		config.TxMgrConfig = &txmgr.CLIConfig{}
+		err := config.Check()
+		require.Equal(t, err.Error(), "must provide a L1 RPC url")
+	})
+}
+
+func TestL1EthRpcRequired(t *testing.T) {
+	config := validConfig()
+	config.L1EthRpc = ""
+	err := config.Check()
+	require.ErrorIs(t, err, ErrMissingL1EthRPC)
+}
+
+func TestRollupRpcRequired(t *testing.T) {
+	config := validConfig()
+	config.RollupRpc = ""
+	err := config.Check()
+	require.ErrorIs(t, err, ErrMissingRollupRpc)
+}
+
+func TestL2OOAddressRequired(t *testing.T) {
+	config := validConfig()
+	config.L2OOAddress = common.Address{}
+	err := config.Check()
+	require.ErrorIs(t, err, ErrMissingL2OOAddress)
+}
+
+func TestDGFAddressRequired(t *testing.T) {
+	config := validConfig()
+	config.DGFAddress = common.Address{}
+	err := config.Check()
+	require.ErrorIs(t, err, ErrMissingDGFAddress)
+}
+
+func TestNetworkTimeoutRequired(t *testing.T) {
+	config := validConfig()
+	config.NetworkTimeout = 0
+	err := config.Check()
+	require.ErrorIs(t, err, ErrInvalidNetworkTimeout)
+}

op-challenger/flags/flags_test.go

+package flags
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/urfave/cli"
+)
+
+// TestUniqueFlags asserts that all flag names are unique, to avoid accidental conflicts between the many flags.
+func TestUniqueFlags(t *testing.T) {
+	seenCLI := make(map[string]struct{})
+	for _, flag := range Flags {
+		name := flag.GetName()
+		if _, ok := seenCLI[name]; ok {
+			t.Errorf("duplicate flag %s", name)
+			continue
+		}
+		seenCLI[name] = struct{}{}
+	}
+}
+
+// TestUniqueEnvVars asserts that all flag env vars are unique, to avoid accidental conflicts between the many flags.
+func TestUniqueEnvVars(t *testing.T) {
+	seenCLI := make(map[string]struct{})
+	for _, flag := range Flags {
+		envVar := envVarForFlag(flag)
+		if _, ok := seenCLI[envVar]; envVar != "" && ok {
+			t.Errorf("duplicate flag env var %s", envVar)
+			continue
+		}
+		seenCLI[envVar] = struct{}{}
+	}
+}
+
+func TestCorrectEnvVarPrefix(t *testing.T) {
+	for _, flag := range Flags {
+		envVar := envVarForFlag(flag)
+		if envVar == "" {
+			t.Errorf("Failed to find EnvVar for flag %v", flag.GetName())
+		}
+		if envVar[:len("OP_CHALLENGER_")] != "OP_CHALLENGER_" {
+			t.Errorf("Flag %v env var (%v) does not start with OP_CHALLENGER_", flag.GetName(), envVar)
+		}
+		if strings.Contains(envVar, "__") {
+			t.Errorf("Flag %v env var (%v) has duplicate underscores", flag.GetName(), envVar)
+		}
+	}
+}
+
+func envVarForFlag(flag cli.Flag) string {
+	values := reflect.ValueOf(flag)
+	envVarValue := values.FieldByName("EnvVar")
+	if envVarValue == (reflect.Value{}) {
+		return ""
+	}
+	return envVarValue.String()
+}

op-challenger/version/version.go

+package version
+
+var (
+	Version = "v0.1.0"
+	Meta    = "dev"
+)

op-e2e/system_test.go

@@ -393,6 +393,9 @@ func TestMissingBatchE2E(t *testing.T) {
 
 	l2Seq := sys.Clients["sequencer"]
 	l2Verif := sys.Clients["verifier"]
+	seqRollupRPCClient, err := rpc.DialContext(context.Background(), sys.RollupNodes["sequencer"].HTTPEndpoint())
+	require.Nil(t, err)
+	seqRollupClient := sources.NewRollupClient(client.NewBaseRPCClient(seqRollupRPCClient))
 
 	// Transactor Account
 	ethPrivKey := cfg.Secrets.Alice
@@ -414,8 +417,8 @@ func TestMissingBatchE2E(t *testing.T) {
 	require.Equal(t, ethereum.NotFound, err, "Found transaction in verifier when it should not have been included")
 
 	// Wait a short time for the L2 reorg to occur on the sequencer as well.
-	// The proper thing to do is to wait until the sequencer marks this block safe.
-	<-time.After(2 * time.Second)
+	err = waitForSafeHead(ctx, receipt.BlockNumber.Uint64(), seqRollupClient)
+	require.Nil(t, err, "timeout waiting for L2 reorg on sequencer safe head")
 
 	// Assert that the reconciliation process did an L2 reorg on the sequencer to remove the invalid block
 	ctx2, cancel := context.WithTimeout(context.Background(), time.Second)

op-node/chaincfg/chains.go

@@ -10,6 +10,43 @@ import (
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
 )
 
+var Mainnet = rollup.Config{
+	Genesis: rollup.Genesis{
+		L1: eth.BlockID{
+			// moose: Update this during migration
+			Hash: common.HexToHash("0x"),
+			// moose: Update this during migration
+			Number: 0,
+		},
+		L2: eth.BlockID{
+			// moose: Update this during migration
+			Hash: common.HexToHash("0x"),
+			// moose: Update this during migration
+			Number: 0,
+		},
+		// moose: Update this during migration
+		L2Time: 0,
+		SystemConfig: eth.SystemConfig{
+			BatcherAddr: common.HexToAddress("0x70997970C51812dc3A010C7d01b50e0d17dc79C8"),
+			Overhead:    eth.Bytes32(common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000834")),
+			Scalar:      eth.Bytes32(common.HexToHash("0x00000000000000000000000000000000000000000000000000000000000f4240")),
+			GasLimit:    25_000_000,
+		},
+	},
+	BlockTime:         2,
+	MaxSequencerDrift: 600,
+	SeqWindowSize:     3600,
+	ChannelTimeout:    300,
+	L1ChainID:         big.NewInt(1),
+	L2ChainID:         big.NewInt(10),
+	BatchInboxAddress: common.HexToAddress("0xff00000000000000000000000000000000000010"),
+	// moose: Update this during migration
+	DepositContractAddress: common.HexToAddress("0x"),
+	// moose: Update this during migration
+	L1SystemConfigAddress: common.HexToAddress("0x"),
+	RegolithTime:          u64Ptr(0),
+}
+
 var Goerli = rollup.Config{
 	Genesis: rollup.Genesis{
 		L1: eth.BlockID{
@@ -42,6 +79,8 @@ var Goerli = rollup.Config{
 
 var NetworksByName = map[string]rollup.Config{
 	"goerli": Goerli,
+	// moose: Update this during migration
+	// "mainnet": Mainnet,
 }
 
 var L2ChainIDToNetworkName = func() map[string]string {

op-node/cmd/main.go

@@ -23,6 +23,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-node/metrics"
 	"github.com/ethereum-optimism/optimism/op-node/node"
 	"github.com/ethereum-optimism/optimism/op-node/version"
+	opservice "github.com/ethereum-optimism/optimism/op-service"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
 	oppprof "github.com/ethereum-optimism/optimism/op-service/pprof"
 )
@@ -88,6 +89,7 @@ func RollupNodeMain(ctx *cli.Context) error {
 		return err
 	}
 	log := oplog.NewLogger(logCfg)
+	opservice.ValidateEnvVars(flags.EnvVarPrefix, flags.Flags, log)
 	m := metrics.NewMetrics("default")
 
 	cfg, err := opnode.NewConfig(ctx, log)

op-node/flags/flags.go

@@ -14,10 +14,10 @@ import (
 
 // Flags
 
-const envVarPrefix = "OP_NODE"
+const EnvVarPrefix = "OP_NODE"
 
 func prefixEnvVar(name string) string {
-	return envVarPrefix + "_" + name
+	return EnvVarPrefix + "_" + name
 }
 
 var (
@@ -251,7 +251,7 @@ var Flags []cli.Flag
 
 func init() {
 	optionalFlags = append(optionalFlags, p2pFlags...)
-	optionalFlags = append(optionalFlags, oplog.CLIFlags(envVarPrefix)...)
+	optionalFlags = append(optionalFlags, oplog.CLIFlags(EnvVarPrefix)...)
 	Flags = append(requiredFlags, optionalFlags...)
 }
 

op-node/metrics/metrics.go

@@ -103,6 +103,8 @@ type Metrics struct {
 	SequencerInconsistentL1Origin *EventMetrics
 	SequencerResets               *EventMetrics
 
+	L1RequestDurationSeconds *prometheus.HistogramVec
+
 	SequencerBuildingDiffDurationSeconds prometheus.Histogram
 	SequencerBuildingDiffTotal           prometheus.Counter
 
@@ -378,6 +380,14 @@ func NewMetrics(procName string) *Metrics {
 			Help:      "number of unverified execution payloads buffered in quarantine",
 		}),
 
+		L1RequestDurationSeconds: factory.NewHistogramVec(prometheus.HistogramOpts{
+			Namespace: ns,
+			Name:      "l1_request_seconds",
+			Buckets: []float64{
+				.005, .01, .025, .05, .1, .25, .5, 1, 2.5, 5, 10},
+			Help: "Histogram of L1 request time",
+		}, []string{"request"}),
+
 		SequencerBuildingDiffDurationSeconds: factory.NewHistogram(prometheus.HistogramOpts{
 			Namespace: ns,
 			Name:      "sequencer_building_diff_seconds",
@@ -589,6 +599,11 @@ func (m *Metrics) RecordBandwidth(ctx context.Context, bwc *libp2pmetrics.Bandwi
 	}
 }
 
+// RecordL1RequestTime tracks the amount of time the derivation pipeline spent waiting for L1 data requests.
+func (m *Metrics) RecordL1RequestTime(method string, duration time.Duration) {
+	m.L1RequestDurationSeconds.WithLabelValues(method).Observe(float64(duration) / float64(time.Second))
+}
+
 // RecordSequencerBuildingDiffTime tracks the amount of time the sequencer was allowed between
 // start to finish, incl. sealing, minus the block time.
 // Ideally this is 0, realistically the sequencer scheduler may be busy with other jobs like syncing sometimes.

op-node/rollup/driver/driver.go

@@ -30,6 +30,7 @@ type Metrics interface {
 	RecordL1ReorgDepth(d uint64)
 
 	EngineMetrics
+	L1FetcherMetrics
 	SequencerMetrics
 }
 
@@ -103,6 +104,7 @@ type AltSync interface {
 
 // NewDriver composes an events handler that tracks L1 state, triggers L2 derivation, and optionally sequences new L2 blocks.
 func NewDriver(driverCfg *Config, cfg *rollup.Config, l2 L2Chain, l1 L1Chain, altSync AltSync, network Network, log log.Logger, snapshotLog log.Logger, metrics Metrics) *Driver {
+	l1 = NewMeteredL1Fetcher(l1, metrics)
 	l1State := NewL1State(log, metrics)
 	sequencerConfDepth := NewConfDepth(driverCfg.SequencerConfDepth, l1State.L1Head, l1)
 	findL1Origin := NewL1OriginSelector(log, cfg, sequencerConfDepth)

op-node/rollup/driver/metered_l1fetcher.go

+package driver
+
+import (
+	"context"
+	"time"
+
+	"github.com/ethereum-optimism/optimism/op-node/eth"
+	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+type L1FetcherMetrics interface {
+	RecordL1RequestTime(method string, duration time.Duration)
+}
+
+type MeteredL1Fetcher struct {
+	inner   derive.L1Fetcher
+	metrics L1FetcherMetrics
+	now     func() time.Time
+}
+
+func NewMeteredL1Fetcher(inner derive.L1Fetcher, metrics L1FetcherMetrics) *MeteredL1Fetcher {
+	return &MeteredL1Fetcher{
+		inner:   inner,
+		metrics: metrics,
+		now:     time.Now,
+	}
+}
+func (m *MeteredL1Fetcher) L1BlockRefByLabel(ctx context.Context, label eth.BlockLabel) (eth.L1BlockRef, error) {
+	defer m.recordTime("L1BlockRefByLabel")()
+	return m.inner.L1BlockRefByLabel(ctx, label)
+}
+
+func (m *MeteredL1Fetcher) L1BlockRefByNumber(ctx context.Context, num uint64) (eth.L1BlockRef, error) {
+	defer m.recordTime("L1BlockRefByNumber")()
+	return m.inner.L1BlockRefByNumber(ctx, num)
+}
+
+func (m *MeteredL1Fetcher) L1BlockRefByHash(ctx context.Context, hash common.Hash) (eth.L1BlockRef, error) {
+	defer m.recordTime("L1BlockRefByHash")()
+	return m.inner.L1BlockRefByHash(ctx, hash)
+}
+
+func (m *MeteredL1Fetcher) InfoByHash(ctx context.Context, hash common.Hash) (eth.BlockInfo, error) {
+	defer m.recordTime("InfoByHash")()
+	return m.inner.InfoByHash(ctx, hash)
+}
+
+func (m *MeteredL1Fetcher) InfoAndTxsByHash(ctx context.Context, hash common.Hash) (eth.BlockInfo, types.Transactions, error) {
+	defer m.recordTime("InfoAndTxsByHash")()
+	return m.inner.InfoAndTxsByHash(ctx, hash)
+}
+
+func (m *MeteredL1Fetcher) FetchReceipts(ctx context.Context, blockHash common.Hash) (eth.BlockInfo, types.Receipts, error) {
+	defer m.recordTime("FetchReceipts")()
+	return m.inner.FetchReceipts(ctx, blockHash)
+}
+
+var _ derive.L1Fetcher = (*MeteredL1Fetcher)(nil)
+
+func (m *MeteredL1Fetcher) recordTime(method string) func() {
+	start := m.now()
+	return func() {
+		end := m.now()
+		m.metrics.RecordL1RequestTime(method, end.Sub(start))
+	}
+}

op-node/rollup/driver/metered_l1fetcher_test.go

+package driver
+
+import (
+	"context"
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/ethereum-optimism/optimism/op-node/eth"
+	"github.com/ethereum-optimism/optimism/op-node/testutils"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+)
+
+func TestDurationRecorded(t *testing.T) {
+	num := uint64(1234)
+	hash := common.Hash{0xaa}
+	ref := eth.L1BlockRef{Number: num}
+	info := &testutils.MockBlockInfo{}
+	expectedErr := errors.New("test error")
+
+	tests := []struct {
+		method string
+		expect func(inner *testutils.MockL1Source)
+		call   func(t *testing.T, fetcher *MeteredL1Fetcher, inner *testutils.MockL1Source)
+	}{
+		{
+			method: "L1BlockRefByLabel",
+			call: func(t *testing.T, fetcher *MeteredL1Fetcher, inner *testutils.MockL1Source) {
+				inner.ExpectL1BlockRefByLabel(eth.Finalized, ref, expectedErr)
+
+				result, err := fetcher.L1BlockRefByLabel(context.Background(), eth.Finalized)
+				require.Equal(t, ref, result)
+				require.Equal(t, expectedErr, err)
+			},
+		},
+		{
+			method: "L1BlockRefByNumber",
+			call: func(t *testing.T, fetcher *MeteredL1Fetcher, inner *testutils.MockL1Source) {
+				inner.ExpectL1BlockRefByNumber(num, ref, expectedErr)
+
+				result, err := fetcher.L1BlockRefByNumber(context.Background(), num)
+				require.Equal(t, ref, result)
+				require.Equal(t, expectedErr, err)
+			},
+		},
+		{
+			method: "L1BlockRefByHash",
+			call: func(t *testing.T, fetcher *MeteredL1Fetcher, inner *testutils.MockL1Source) {
+				inner.ExpectL1BlockRefByHash(hash, ref, expectedErr)
+
+				result, err := fetcher.L1BlockRefByHash(context.Background(), hash)
+				require.Equal(t, ref, result)
+				require.Equal(t, expectedErr, err)
+			},
+		},
+		{
+			method: "InfoByHash",
+			call: func(t *testing.T, fetcher *MeteredL1Fetcher, inner *testutils.MockL1Source) {
+				inner.ExpectInfoByHash(hash, info, expectedErr)
+
+				result, err := fetcher.InfoByHash(context.Background(), hash)
+				require.Equal(t, info, result)
+				require.Equal(t, expectedErr, err)
+			},
+		},
+		{
+			method: "InfoAndTxsByHash",
+			call: func(t *testing.T, fetcher *MeteredL1Fetcher, inner *testutils.MockL1Source) {
+				txs := types.Transactions{
+					&types.Transaction{},
+				}
+				inner.ExpectInfoAndTxsByHash(hash, info, txs, expectedErr)
+
+				actualInfo, actualTxs, err := fetcher.InfoAndTxsByHash(context.Background(), hash)
+				require.Equal(t, info, actualInfo)
+				require.Equal(t, txs, actualTxs)
+				require.Equal(t, expectedErr, err)
+			},
+		},
+		{
+			method: "FetchReceipts",
+			call: func(t *testing.T, fetcher *MeteredL1Fetcher, inner *testutils.MockL1Source) {
+				rcpts := types.Receipts{
+					&types.Receipt{},
+				}
+				inner.ExpectFetchReceipts(hash, info, rcpts, expectedErr)
+
+				actualInfo, actualRcpts, err := fetcher.FetchReceipts(context.Background(), hash)
+				require.Equal(t, info, actualInfo)
+				require.Equal(t, rcpts, actualRcpts)
+				require.Equal(t, expectedErr, err)
+			},
+		},
+	}
+	for _, test := range tests {
+		test := test
+		t.Run(test.method, func(t *testing.T) {
+			duration := 200 * time.Millisecond
+			fetcher, inner, metrics := createFetcher(duration)
+			defer inner.AssertExpectations(t)
+			defer metrics.AssertExpectations(t)
+
+			metrics.ExpectRecordRequestTime(test.method, duration)
+
+			test.call(t, fetcher, inner)
+		})
+	}
+}
+
+// createFetcher creates a MeteredL1Fetcher with a mock inner.
+// The clock used to calculate the current time will advance by clockIncrement on each call, making it appear as if
+// each request takes that amount of time to execute.
+func createFetcher(clockIncrement time.Duration) (*MeteredL1Fetcher, *testutils.MockL1Source, *mockMetrics) {
+	inner := &testutils.MockL1Source{}
+	currTime := time.UnixMilli(1294812934000000)
+	clock := func() time.Time {
+		currTime = currTime.Add(clockIncrement)
+		return currTime
+	}
+	metrics := &mockMetrics{}
+	fetcher := MeteredL1Fetcher{
+		inner:   inner,
+		metrics: metrics,
+		now:     clock,
+	}
+	return &fetcher, inner, metrics
+}
+
+type mockMetrics struct {
+	mock.Mock
+}
+
+func (m *mockMetrics) RecordL1RequestTime(method string, duration time.Duration) {
+	m.MethodCalled("RecordL1RequestTime", method, duration)
+}
+
+func (m *mockMetrics) ExpectRecordRequestTime(method string, duration time.Duration) {
+	m.On("RecordL1RequestTime", method, duration).Once()
+}

op-program/Makefile

@@ -33,6 +33,9 @@ test:
 lint:
 	golangci-lint run -E goimports,sqlclosecheck,bodyclose,asciicheck,misspell,errorlint -e "errors.As" -e "errors.Is"
 
+verify-goerli: op-program-host op-program-client
+	env GO111MODULE=on go run ./verify/cmd/goerli.go $$L1URL $$L2URL
+
 .PHONY: \
 	op-program \
 	clean \

op-program/host/flags/flags.go

@@ -13,69 +13,69 @@ import (
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
 )
 
-const envVarPrefix = "OP_PROGRAM"
+const EnvVarPrefix = "OP_PROGRAM"
 
 var (
 	RollupConfig = cli.StringFlag{
 		Name:   "rollup.config",
 		Usage:  "Rollup chain parameters",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "ROLLUP_CONFIG"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "ROLLUP_CONFIG"),
 	}
 	Network = cli.StringFlag{
 		Name:   "network",
 		Usage:  fmt.Sprintf("Predefined network selection. Available networks: %s", strings.Join(chaincfg.AvailableNetworks(), ", ")),
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "NETWORK"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "NETWORK"),
 	}
 	DataDir = cli.StringFlag{
 		Name:   "datadir",
 		Usage:  "Directory to use for preimage data storage. Default uses in-memory storage",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "DATADIR"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "DATADIR"),
 	}
 	L2NodeAddr = cli.StringFlag{
 		Name:   "l2",
 		Usage:  "Address of L2 JSON-RPC endpoint to use (eth and debug namespace required)",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "L2_RPC"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "L2_RPC"),
 	}
 	L1Head = cli.StringFlag{
 		Name:   "l1.head",
 		Usage:  "Hash of the L1 head block. Derivation stops after this block is processed.",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "L1_HEAD"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "L1_HEAD"),
 	}
 	L2Head = cli.StringFlag{
 		Name:   "l2.head",
 		Usage:  "Hash of the agreed L2 block to start derivation from",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "L2_HEAD"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "L2_HEAD"),
 	}
 	L2Claim = cli.StringFlag{
 		Name:   "l2.claim",
 		Usage:  "Claimed L2 output root to validate",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "L2_CLAIM"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "L2_CLAIM"),
 	}
 	L2BlockNumber = cli.Uint64Flag{
 		Name:   "l2.blocknumber",
 		Usage:  "Number of the L2 block that the claim is from",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "L2_BLOCK_NUM"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "L2_BLOCK_NUM"),
 	}
 	L2GenesisPath = cli.StringFlag{
 		Name:   "l2.genesis",
 		Usage:  "Path to the op-geth genesis file",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "L2_GENESIS"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "L2_GENESIS"),
 	}
 	L1NodeAddr = cli.StringFlag{
 		Name:   "l1",
 		Usage:  "Address of L1 JSON-RPC endpoint to use (eth namespace required)",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "L1_RPC"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "L1_RPC"),
 	}
 	L1TrustRPC = cli.BoolFlag{
 		Name:   "l1.trustrpc",
 		Usage:  "Trust the L1 RPC, sync faster at risk of malicious/buggy RPC providing bad or inconsistent L1 data",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "L1_TRUST_RPC"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "L1_TRUST_RPC"),
 	}
 	L1RPCProviderKind = cli.GenericFlag{
 		Name: "l1.rpckind",
 		Usage: "The kind of RPC provider, used to inform optimal transactions receipts fetching, and thus reduce costs. Valid options: " +
 			nodeflags.EnumString[sources.RPCProviderKind](sources.RPCProviderKinds),
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "L1_RPC_KIND"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "L1_RPC_KIND"),
 		Value: func() *sources.RPCProviderKind {
 			out := sources.RPCKindBasic
 			return &out
@@ -84,12 +84,12 @@ var (
 	Exec = cli.StringFlag{
 		Name:   "exec",
 		Usage:  "Run the specified client program as a separate process detached from the host. Default is to run the client program in the host process.",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "EXEC"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "EXEC"),
 	}
 	Server = cli.BoolFlag{
 		Name:   "server",
 		Usage:  "Run in pre-image server mode without executing any client program.",
-		EnvVar: service.PrefixEnvVar(envVarPrefix, "SERVER"),
+		EnvVar: service.PrefixEnvVar(EnvVarPrefix, "SERVER"),
 	}
 )
 
@@ -116,7 +116,7 @@ var programFlags = []cli.Flag{
 }
 
 func init() {
-	Flags = append(Flags, oplog.CLIFlags(envVarPrefix)...)
+	Flags = append(Flags, oplog.CLIFlags(EnvVarPrefix)...)
 	Flags = append(Flags, requiredFlags...)
 	Flags = append(Flags, programFlags...)
 }

op-program/host/host.go

@@ -15,10 +15,12 @@ import (
 	cl "github.com/ethereum-optimism/optimism/op-program/client"
 	"github.com/ethereum-optimism/optimism/op-program/client/driver"
 	"github.com/ethereum-optimism/optimism/op-program/host/config"
+	"github.com/ethereum-optimism/optimism/op-program/host/flags"
 	"github.com/ethereum-optimism/optimism/op-program/host/kvstore"
 	"github.com/ethereum-optimism/optimism/op-program/host/prefetcher"
 	oppio "github.com/ethereum-optimism/optimism/op-program/io"
 	"github.com/ethereum-optimism/optimism/op-program/preimage"
+	opservice "github.com/ethereum-optimism/optimism/op-service"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
 )
@@ -32,6 +34,7 @@ func Main(logger log.Logger, cfg *config.Config) error {
 	if err := cfg.Check(); err != nil {
 		return fmt.Errorf("invalid config: %w", err)
 	}
+	opservice.ValidateEnvVars(flags.EnvVarPrefix, flags.Flags, logger)
 	cfg.Rollup.LogDescription(logger, chaincfg.L2ChainIDToNetworkName)
 
 	ctx := context.Background()

op-program/verify/cmd/goerli.go

+package main
+
+import (
+	"context"
+	"fmt"
+	"math/big"
+	"os"
+	"os/exec"
+	"time"
+
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/rpc"
+)
+
+const agreedBlockTrailingDistance = 100
+
+func main() {
+	if len(os.Args) != 3 {
+		_, _ = fmt.Fprintln(os.Stderr, "Must specify L1 RPC URL and L2 RPC URL as arguments")
+		os.Exit(2)
+	}
+	l1RpcUrl := os.Args[1]
+	l2RpcUrl := os.Args[2]
+	goerliOutputAddress := common.HexToAddress("0xE6Dfba0953616Bacab0c9A8ecb3a9BBa77FC15c0")
+	err := Run(l1RpcUrl, l2RpcUrl, goerliOutputAddress)
+	if err != nil {
+		_, _ = fmt.Fprintf(os.Stderr, "Failed: %v\n", err.Error())
+		os.Exit(1)
+	}
+}
+
+func Run(l1RpcUrl string, l2RpcUrl string, l2OracleAddr common.Address) error {
+	ctx := context.Background()
+	l1RpcClient, err := rpc.Dial(l1RpcUrl)
+	if err != nil {
+		return fmt.Errorf("dial L1 client: %w", err)
+	}
+	l1Client := ethclient.NewClient(l1RpcClient)
+
+	l2RpcClient, err := rpc.Dial(l2RpcUrl)
+	if err != nil {
+		return fmt.Errorf("dial L2 client: %w", err)
+	}
+	l2Client := ethclient.NewClient(l2RpcClient)
+
+	outputOracle, err := bindings.NewL2OutputOracle(l2OracleAddr, l1Client)
+	if err != nil {
+		return fmt.Errorf("create output oracle bindings: %w", err)
+	}
+
+	// Find L2 finalized head. This is far enough back that we know it's submitted to L1 and won't be re-orged
+	l2FinalizedHead, err := l2Client.BlockByNumber(ctx, big.NewInt(int64(rpc.FinalizedBlockNumber)))
+	if err != nil {
+		return fmt.Errorf("get l2 safe head: %w", err)
+	}
+
+	// Find L1 finalized block. Can't be re-orged and must contain all batches for the L2 finalized block
+	l1BlockNum := big.NewInt(int64(rpc.FinalizedBlockNumber))
+	l1HeadBlock, err := l1Client.BlockByNumber(ctx, l1BlockNum)
+	if err != nil {
+		return fmt.Errorf("find L1 head: %w", err)
+	}
+
+	// Get the most published L2 output from before the finalized block
+	callOpts := &bind.CallOpts{Context: ctx}
+	outputIndex, err := outputOracle.GetL2OutputIndexAfter(callOpts, l2FinalizedHead.Number())
+	if err != nil {
+		return fmt.Errorf("get output index after finalized block: %w", err)
+	}
+	outputIndex = outputIndex.Sub(outputIndex, big.NewInt(1))
+	output, err := outputOracle.GetL2Output(callOpts, outputIndex)
+	if err != nil {
+		return fmt.Errorf("retrieve latest output: %w", err)
+	}
+
+	l1Head := l1HeadBlock.Hash()
+	l2Claim := common.Hash(output.OutputRoot)
+	l2BlockNumber := output.L2BlockNumber
+
+	// Use an agreed starting L2 block some distance before the block the output claim is from
+	agreedBlockNumber := uint64(0)
+	if l2BlockNumber.Uint64() > agreedBlockTrailingDistance {
+		agreedBlockNumber = l2BlockNumber.Uint64() - agreedBlockTrailingDistance
+	}
+	l2AgreedBlock, err := l2Client.BlockByNumber(ctx, big.NewInt(int64(agreedBlockNumber)))
+	if err != nil {
+		return fmt.Errorf("retrieve agreed l2 block: %w", err)
+	}
+	l2Head := l2AgreedBlock.Hash()
+
+	temp, err := os.MkdirTemp("", "oracledata")
+	if err != nil {
+		return fmt.Errorf("create temp dir: %w", err)
+	}
+	defer func() {
+		err := os.RemoveAll(temp)
+		if err != nil {
+			println("Failed to remove temp dir:" + err.Error())
+		}
+	}()
+	fmt.Printf("Using temp dir: %s\n", temp)
+	args := []string{
+		"--network", "goerli",
+		"--exec", "./bin/op-program-client",
+		"--datadir", temp,
+		"--l1.head", l1Head.Hex(),
+		"--l2.head", l2Head.Hex(),
+		"--l2.claim", l2Claim.Hex(),
+		"--l2.blocknumber", l2BlockNumber.String(),
+	}
+	fmt.Printf("Configuration: %s\n", args)
+	fmt.Println("Running in online mode")
+	err = runFaultProofProgram(ctx, append(args, "--l1", l1RpcUrl, "--l2", l2RpcUrl))
+	if err != nil {
+		return fmt.Errorf("online mode failed: %w", err)
+	}
+
+	fmt.Println("Running in offline mode")
+	err = runFaultProofProgram(ctx, args)
+	if err != nil {
+		return fmt.Errorf("offline mode failed: %w", err)
+	}
+	return nil
+}
+
+func runFaultProofProgram(ctx context.Context, args []string) error {
+	ctx, cancel := context.WithTimeout(ctx, 60*time.Minute)
+	defer cancel()
+	cmd := exec.CommandContext(ctx, "./bin/op-program", args...)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
+}

op-proposer/flags/flags.go

@@ -14,24 +14,24 @@ import (
 	"github.com/ethereum-optimism/optimism/op-service/txmgr"
 )
 
-const envVarPrefix = "OP_PROPOSER"
+const EnvVarPrefix = "OP_PROPOSER"
 
 var (
 	// Required Flags
 	L1EthRpcFlag = cli.StringFlag{
 		Name:   "l1-eth-rpc",
 		Usage:  "HTTP provider URL for L1",
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "L1_ETH_RPC"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "L1_ETH_RPC"),
 	}
 	RollupRpcFlag = cli.StringFlag{
 		Name:   "rollup-rpc",
 		Usage:  "HTTP provider URL for the rollup node",
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "ROLLUP_RPC"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "ROLLUP_RPC"),
 	}
 	L2OOAddressFlag = cli.StringFlag{
 		Name:   "l2oo-address",
 		Usage:  "Address of the L2OutputOracle contract",
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "L2OO_ADDRESS"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "L2OO_ADDRESS"),
 	}
 
 	// Optional flags
@@ -39,12 +39,12 @@ var (
 		Name:   "poll-interval",
 		Usage:  "How frequently to poll L2 for new blocks",
 		Value:  6 * time.Second,
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "POLL_INTERVAL"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "POLL_INTERVAL"),
 	}
 	AllowNonFinalizedFlag = cli.BoolFlag{
 		Name:   "allow-non-finalized",
 		Usage:  "Allow the proposer to submit proposals for L2 blocks derived from non-finalized L1 blocks.",
-		EnvVar: opservice.PrefixEnvVar(envVarPrefix, "ALLOW_NON_FINALIZED"),
+		EnvVar: opservice.PrefixEnvVar(EnvVarPrefix, "ALLOW_NON_FINALIZED"),
 	}
 	// Legacy Flags
 	L2OutputHDPathFlag = txmgr.L2OutputHDPathFlag
@@ -63,11 +63,11 @@ var optionalFlags = []cli.Flag{
 }
 
 func init() {
-	optionalFlags = append(optionalFlags, oprpc.CLIFlags(envVarPrefix)...)
-	optionalFlags = append(optionalFlags, oplog.CLIFlags(envVarPrefix)...)
-	optionalFlags = append(optionalFlags, opmetrics.CLIFlags(envVarPrefix)...)
-	optionalFlags = append(optionalFlags, oppprof.CLIFlags(envVarPrefix)...)
-	optionalFlags = append(optionalFlags, txmgr.CLIFlags(envVarPrefix)...)
+	optionalFlags = append(optionalFlags, oprpc.CLIFlags(EnvVarPrefix)...)
+	optionalFlags = append(optionalFlags, oplog.CLIFlags(EnvVarPrefix)...)
+	optionalFlags = append(optionalFlags, opmetrics.CLIFlags(EnvVarPrefix)...)
+	optionalFlags = append(optionalFlags, oppprof.CLIFlags(EnvVarPrefix)...)
+	optionalFlags = append(optionalFlags, txmgr.CLIFlags(EnvVarPrefix)...)
 
 	Flags = append(requiredFlags, optionalFlags...)
 }

op-proposer/proposer/l2_output_submitter.go

@@ -22,7 +22,10 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-node/eth"
 	"github.com/ethereum-optimism/optimism/op-node/sources"
+	"github.com/ethereum-optimism/optimism/op-proposer/flags"
 	"github.com/ethereum-optimism/optimism/op-proposer/metrics"
+	opservice "github.com/ethereum-optimism/optimism/op-service"
+	opclient "github.com/ethereum-optimism/optimism/op-service/client"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
 	oppprof "github.com/ethereum-optimism/optimism/op-service/pprof"
 	oprpc "github.com/ethereum-optimism/optimism/op-service/rpc"
@@ -34,12 +37,16 @@ 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(cfg.LogConfig)
+	opservice.ValidateEnvVars(flags.EnvVarPrefix, flags.Flags, l)
 	m := metrics.NewMetrics("default")
 	l.Info("Initializing L2 Output Submitter")
 
@@ -148,7 +155,7 @@ func NewL2OutputSubmitterFromCLIConfig(cfg CLIConfig, l log.Logger, m metrics.Me
 
 // NewL2OutputSubmitterConfigFromCLIConfig creates the proposer config from the CLI config.
 func NewL2OutputSubmitterConfigFromCLIConfig(cfg CLIConfig, l log.Logger, m metrics.Metricer) (*Config, error) {
-	l2ooAddress, err := parseAddress(cfg.L2OOAddress)
+	l2ooAddress, err := opservice.ParseAddress(cfg.L2OOAddress)
 	if err != nil {
 		return nil, err
 	}
@@ -160,12 +167,12 @@ func NewL2OutputSubmitterConfigFromCLIConfig(cfg CLIConfig, l log.Logger, m metr
 
 	// Connect to L1 and L2 providers. Perform these last since they are the most expensive.
 	ctx := context.Background()
-	l1Client, err := dialEthClientWithTimeout(ctx, cfg.L1EthRpc)
+	l1Client, err := opclient.DialEthClientWithTimeout(ctx, cfg.L1EthRpc, opclient.DefaultDialTimeout)
 	if err != nil {
 		return nil, err
 	}
 
-	rollupClient, err := dialRollupClientWithTimeout(ctx, cfg.RollupRpc)
+	rollupClient, err := opclient.DialRollupClientWithTimeout(ctx, cfg.RollupRpc, opclient.DefaultDialTimeout)
 	if err != nil {
 		return nil, err
 	}

op-proposer/proposer/utils.go

-package proposer
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"github.com/ethereum-optimism/optimism/op-node/client"
-	"github.com/ethereum-optimism/optimism/op-node/sources"
-	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/ethclient"
-	"github.com/ethereum/go-ethereum/rpc"
-)
-
-var defaultDialTimeout = 5 * time.Second
-
-// dialEthClientWithTimeout attempts to dial the L1 provider using the provided
-// URL. If the dial doesn't complete within defaultDialTimeout seconds, this
-// method will return an error.
-func dialEthClientWithTimeout(ctx context.Context, url string) (*ethclient.Client, error) {
-	ctxt, cancel := context.WithTimeout(ctx, defaultDialTimeout)
-	defer cancel()
-
-	return ethclient.DialContext(ctxt, url)
-}
-
-// dialRollupClientWithTimeout attempts to dial the RPC provider using the provided
-// URL. If the dial doesn't complete within defaultDialTimeout seconds, this
-// method will return an error.
-func dialRollupClientWithTimeout(ctx context.Context, url string) (*sources.RollupClient, error) {
-	ctxt, cancel := context.WithTimeout(ctx, defaultDialTimeout)
-	defer cancel()
-
-	rpcCl, err := rpc.DialContext(ctxt, url)
-	if err != nil {
-		return nil, err
-	}
-
-	return sources.NewRollupClient(client.NewBaseRPCClient(rpcCl)), nil
-}
-
-// parseAddress parses an ETH address from a hex string. This method will fail if
-// the address is not a valid hexadecimal address.
-func parseAddress(address string) (common.Address, error) {
-	if common.IsHexAddress(address) {
-		return common.HexToAddress(address), nil
-	}
-	return common.Address{}, fmt.Errorf("invalid address: %v", address)
-}

op-service/client/ethclient.go

+package client
+
+import (
+	"context"
+	"time"
+
+	"github.com/ethereum/go-ethereum/ethclient"
+)
+
+// DialEthClientWithTimeout attempts to dial the L1 provider using the provided
+// URL. If the dial doesn't complete within defaultDialTimeout seconds, this
+// method will return an error.
+func DialEthClientWithTimeout(ctx context.Context, url string, timeout time.Duration) (*ethclient.Client, error) {
+	ctxt, cancel := context.WithTimeout(ctx, timeout)
+	defer cancel()
+
+	return ethclient.DialContext(ctxt, url)
+}

op-batcher/batcher/utils.go → op-service/client/rollup.go

-package batcher
+package client
 
 import (
 	"context"
+	"time"
 
 	"github.com/ethereum-optimism/optimism/op-node/client"
 	"github.com/ethereum-optimism/optimism/op-node/sources"
-	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/ethereum/go-ethereum/rpc"
 )
 
-// dialEthClientWithTimeout attempts to dial the L1 provider using the provided
+// DialRollupClientWithTimeout attempts to dial the RPC provider using the provided
 // URL. If the dial doesn't complete within defaultDialTimeout seconds, this
 // method will return an error.
-func dialEthClientWithTimeout(ctx context.Context, url string) (*ethclient.Client, error) {
-
-	ctxt, cancel := context.WithTimeout(ctx, defaultDialTimeout)
-	defer cancel()
-
-	return ethclient.DialContext(ctxt, url)
-}
-
-// dialRollupClientWithTimeout attempts to dial the RPC provider using the provided
-// URL. If the dial doesn't complete within defaultDialTimeout seconds, this
-// method will return an error.
-func dialRollupClientWithTimeout(ctx context.Context, url string) (*sources.RollupClient, error) {
-	ctxt, cancel := context.WithTimeout(ctx, defaultDialTimeout)
+func DialRollupClientWithTimeout(ctx context.Context, url string, timeout time.Duration) (*sources.RollupClient, error) {
+	ctxt, cancel := context.WithTimeout(ctx, timeout)
 	defer cancel()
 
 	rpcCl, err := rpc.DialContext(ctxt, url)

op-service/client/timeout.go

+package client
+
+import (
+	"time"
+)
+
+// DefaultDialTimeout is a default timeout for dialing a client.
+const DefaultDialTimeout = 5 * time.Second

op-service/util.go

@@ -3,16 +3,71 @@ package op_service
 import (
 	"context"
 	"errors"
+	"fmt"
 	"os"
 	"os/signal"
+	"reflect"
+	"strings"
 	"syscall"
 	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/urfave/cli"
 )
 
 func PrefixEnvVar(prefix, suffix string) string {
 	return prefix + "_" + suffix
 }
 
+// ValidateEnvVars logs all env vars that are found where the env var is
+// prefixed with the supplied prefix (like OP_BATCHER) but there is no
+// actual env var with that name.
+// It helps validate that the supplied env vars are in fact valid.
+func ValidateEnvVars(prefix string, flags []cli.Flag, log log.Logger) {
+	for _, envVar := range validateEnvVars(prefix, os.Environ(), cliFlagsToEnvVars(flags)) {
+		log.Warn("Unknown env var", "prefix", prefix, "env_var", envVar)
+	}
+}
+
+func cliFlagsToEnvVars(flags []cli.Flag) map[string]struct{} {
+	definedEnvVars := make(map[string]struct{})
+	for _, flag := range flags {
+		envVarField := reflect.ValueOf(flag).FieldByName("EnvVar")
+		if envVarField.IsValid() {
+			definedEnvVars[envVarField.String()] = struct{}{}
+		}
+	}
+	return definedEnvVars
+}
+
+// validateEnvVars returns a list of the unknown environment variables that match the prefix.
+func validateEnvVars(prefix string, providedEnvVars []string, definedEnvVars map[string]struct{}) []string {
+	var out []string
+	for _, envVar := range providedEnvVars {
+		parts := strings.Split(envVar, "=")
+		if len(parts) == 0 {
+			continue
+		}
+		key := parts[0]
+		if strings.HasPrefix(key, prefix) {
+			if _, ok := definedEnvVars[key]; !ok {
+				out = append(out, envVar)
+			}
+		}
+	}
+	return out
+}
+
+// ParseAddress parses an ETH address from a hex string. This method will fail if
+// the address is not a valid hexadecimal address.
+func ParseAddress(address string) (common.Address, error) {
+	if common.IsHexAddress(address) {
+		return common.HexToAddress(address), nil
+	}
+	return common.Address{}, fmt.Errorf("invalid address: %v", address)
+}
+
 // CloseAction runs the function in the background, until it finishes or until it is closed by the user with an interrupt.
 func CloseAction(fn func(ctx context.Context, shutdown <-chan struct{}) error) error {
 	stopped := make(chan error, 1)

op-service/util_test.go

+package op_service
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/urfave/cli"
+)
+
+func TestCLIFlagsToEnvVars(t *testing.T) {
+	flags := []cli.Flag{
+		cli.StringFlag{
+			Name:   "test",
+			EnvVar: "OP_NODE_TEST_VAR",
+		},
+		cli.IntFlag{
+			Name: "no env var",
+		},
+	}
+	res := cliFlagsToEnvVars(flags)
+	require.Contains(t, res, "OP_NODE_TEST_VAR")
+}
+
+func TestValidateEnvVars(t *testing.T) {
+	provided := []string{"OP_BATCHER_CONFIG=true", "OP_BATCHER_FAKE=false", "LD_PRELOAD=/lib/fake.so"}
+	defined := map[string]struct{}{
+		"OP_BATCHER_CONFIG": {},
+		"OP_BATCHER_OTHER":  {},
+	}
+	invalids := validateEnvVars("OP_BATCHER", provided, defined)
+	require.ElementsMatch(t, invalids, []string{"OP_BATCHER_FAKE=false"})
+}

ops/scripts/ci-docker-tag-op-stack-release.sh

@@ -6,7 +6,7 @@ DOCKER_REPO=$1
 GIT_TAG=$2
 GIT_SHA=$3
 
-IMAGE_NAME=$(echo "$GIT_TAG" | grep -Eow '^op-[a-z0-9\-]*' || true)
+IMAGE_NAME=$(echo "$GIT_TAG" | grep -Eow '^(proxyd|op-[a-z0-9\-]*)' || true)
 if [ -z "$IMAGE_NAME" ]; then
   echo "image name could not be parsed from git tag '$GIT_TAG'"
   exit 1

package.json

@@ -25,6 +25,7 @@
       "@eth-optimism/contracts-bedrock/ds-test",
       "@eth-optimism/contracts-bedrock/forge-std",
       "@eth-optimism/contracts-bedrock/@rari-capital/solmate",
+      "@eth-optimism/contracts-bedrock/clones-with-immutable-args",
       "**/@openzeppelin/*",
       "@eth-optimism/contracts-periphery/ds-test",
       "@eth-optimism/contracts-periphery/forge-std",

packages/contracts-bedrock/.gas-snapshot

@@ -27,6 +27,11 @@ CrossDomainOwnable_Test:test_onlyOwner_notOwner_reverts() (gas: 10597)
 CrossDomainOwnable_Test:test_onlyOwner_succeeds() (gas: 34883)
 DeployerWhitelist_Test:test_owner_succeeds() (gas: 7582)
 DeployerWhitelist_Test:test_storageSlots_succeeds() (gas: 33395)
+DisputeGameFactory_Test:test_owner_succeeds() (gas: 7582)
+DisputeGameFactory_Test:test_setImplementation_notOwner_reverts() (gas: 11191)
+DisputeGameFactory_Test:test_setImplementation_succeeds() (gas: 32635)
+DisputeGameFactory_Test:test_transferOwnership_notOwner_reverts() (gas: 10979)
+DisputeGameFactory_Test:test_transferOwnership_succeeds() (gas: 13180)
 FeeVault_Test:test_constructor_succeeds() (gas: 10736)
 FeeVault_Test:test_minWithdrawalAmount_succeeds() (gas: 10713)
 GasBenchMark_L1CrossDomainMessenger:test_sendMessage_benchmark_0() (gas: 352135)

packages/contracts-bedrock/contracts/dispute/DisputeGameFactory.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.15;
+
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+import { ClonesWithImmutableArgs } from "@cwia/ClonesWithImmutableArgs.sol";
+
+import { Claim } from "../libraries/DisputeTypes.sol";
+import { Hash } from "../libraries/DisputeTypes.sol";
+import { GameType } from "../libraries/DisputeTypes.sol";
+
+import { NoImplementation } from "../libraries/DisputeErrors.sol";
+import { GameAlreadyExists } from "../libraries/DisputeErrors.sol";
+
+import { IDisputeGame } from "./IDisputeGame.sol";
+import { IBondManager } from "./IBondManager.sol";
+import { IDisputeGameFactory } from "./IDisputeGameFactory.sol";
+
+/**
+ * @title DisputeGameFactory
+ * @notice A factory contract for creating `IDisputeGame` contracts.
+ */
+contract DisputeGameFactory is Ownable, IDisputeGameFactory {
+    /**
+     * @dev Allows for the creation of clone proxies with immutable arguments.
+     */
+    using ClonesWithImmutableArgs for address;
+
+    /**
+     * @notice Mapping of `GameType`s to their respective `IDisputeGame` implementations.
+     */
+    mapping(GameType => IDisputeGame) public gameImpls;
+
+    /**
+     * @notice Mapping of a hash of `gameType . rootClaim . extraData` to
+     *         the deployed `IDisputeGame` clone.
+     * @dev Note: `.` denotes concatenation.
+     */
+    mapping(Hash => IDisputeGame) internal disputeGames;
+
+    /**
+     * @notice Constructs a new DisputeGameFactory contract.
+     * @param _owner The owner of the contract.
+     */
+    constructor(address _owner) Ownable() {
+        transferOwnership(_owner);
+    }
+
+    /**
+     * @notice Retrieves the hash of `gameType . rootClaim . extraData`
+     *         to the deployed `DisputeGame` clone.
+     * @dev Note: `.` denotes concatenation.
+     * @param gameType The type of the DisputeGame.
+     *        Used to decide the implementation to clone.
+     * @param rootClaim The root claim of the DisputeGame.
+     * @param extraData Any extra data that should be provided to the
+     *        created dispute game.
+     * @return _proxy The clone of the `DisputeGame` created with the
+     *         given parameters. `address(0)` if nonexistent.
+     */
+    function games(
+        GameType gameType,
+        Claim rootClaim,
+        bytes calldata extraData
+    ) external view returns (IDisputeGame _proxy) {
+        return disputeGames[getGameUUID(gameType, rootClaim, extraData)];
+    }
+
+    /**
+     * @notice Creates a new DisputeGame proxy contract.
+     * @notice If a dispute game with the given parameters already exists,
+     *         it will be returned.
+     * @param gameType The type of the DisputeGame.
+     *        Used to decide the proxy implementation.
+     * @param rootClaim The root claim of the DisputeGame.
+     * @param extraData Any extra data that should be provided
+     *        to the created dispute game.
+     * @return proxy The clone of the `DisputeGame`.
+     */
+    function create(
+        GameType gameType,
+        Claim rootClaim,
+        bytes calldata extraData
+    ) external returns (IDisputeGame proxy) {
+        // Grab the implementation contract for the given `GameType`.
+        IDisputeGame impl = gameImpls[gameType];
+
+        // If there is no implementation to clone for the given `GameType`, revert.
+        if (address(impl) == address(0)) {
+            revert NoImplementation(gameType);
+        }
+
+        // Clone the implementation contract and initialize it with the given parameters.
+        bytes memory data = abi.encodePacked(rootClaim, extraData);
+        proxy = IDisputeGame(address(impl).clone(data));
+        proxy.initialize();
+
+        // Compute the unique identifier for the dispute game.
+        Hash uuid = getGameUUID(gameType, rootClaim, extraData);
+
+        // If a dispute game with the same UUID already exists, revert.
+        if (address(disputeGames[uuid]) != address(0)) {
+            revert GameAlreadyExists(uuid);
+        }
+
+        // Store the dispute game in the mapping & emit the `DisputeGameCreated` event.
+        disputeGames[uuid] = proxy;
+        emit DisputeGameCreated(address(proxy), gameType, rootClaim);
+    }
+
+    /**
+     * @notice Sets the implementation contract for a specific `GameType`.
+     * @param gameType The type of the DisputeGame.
+     * @param impl The implementation contract for the given `GameType`.
+     */
+    function setImplementation(GameType gameType, IDisputeGame impl) external onlyOwner {
+        gameImpls[gameType] = impl;
+    }
+
+    /**
+     * @notice Returns a unique identifier for the given dispute game parameters.
+     * @dev Hashes the concatenation of `gameType . rootClaim . extraData`
+     *      without expanding memory.
+     * @param gameType The type of the DisputeGame.
+     * @param rootClaim The root claim of the DisputeGame.
+     * @param extraData Any extra data that should be provided to the created dispute game.
+     * @return _uuid The unique identifier for the given dispute game parameters.
+     */
+    function getGameUUID(
+        GameType gameType,
+        Claim rootClaim,
+        bytes memory extraData
+    ) public pure returns (Hash _uuid) {
+        assembly {
+            // Grab the offsets of the other memory locations we will need to temporarily overwrite.
+            let gameTypeOffset := sub(extraData, 0x60)
+            let rootClaimOffset := add(gameTypeOffset, 0x20)
+            let pointerOffset := add(rootClaimOffset, 0x20)
+
+            // Copy the memory that we will temporarily overwrite onto the stack
+            // so we can restore it later
+            let tempA := mload(gameTypeOffset)
+            let tempB := mload(rootClaimOffset)
+            let tempC := mload(pointerOffset)
+
+            // Overwrite the memory with the data we want to hash
+            mstore(gameTypeOffset, gameType)
+            mstore(rootClaimOffset, rootClaim)
+            mstore(pointerOffset, 0x60)
+
+            // Compute the length of the memory to hash
+            // `0x60 + 0x20 + extraData.length` rounded to the *next* multiple of 32.
+            let hashLen := and(add(mload(extraData), 0x9F), not(0x1F))
+
+            // Hash the memory to produce the UUID digest
+            _uuid := keccak256(gameTypeOffset, hashLen)
+
+            // Restore the memory prior to `extraData`
+            mstore(gameTypeOffset, tempA)
+            mstore(rootClaimOffset, tempB)
+            mstore(pointerOffset, tempC)
+        }
+    }
+}

packages/contracts-bedrock/contracts/dispute/IAttestationDisputeGame.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.15;
+
+import { IDisputeGame } from "./IDisputeGame.sol";
+
+/**
+ * @title IAttestationDisputeGame
+ * @notice The interface for an attestation-based DisputeGame meant to contest output
+ *         proposals in Optimism's `L2OutputOracle` contract.
+ */
+interface IAttestationDisputeGame is IDisputeGame {
+    /**
+     * @notice A mapping of addresses from the `signerSet` to booleans signifying whether
+     *         or not they have authorized the `rootClaim` to be invalidated.
+     * @param challenger The address to check for authorization.
+     * @return _challenged Whether or not the `challenger` has challenged the `rootClaim`.
+     */
+    function challenges(address challenger) external view returns (bool _challenged);
+
+    /**
+     * @notice The signer set consists of authorized public keys that may challenge
+     *         the `rootClaim`.
+     * @param addr The address to check for authorization.
+     * @return _isAuthorized Whether or not the `addr` is part of the signer set.
+     */
+    function signerSet(address addr) external view returns (bool _isAuthorized);
+
+    /**
+     * @notice The amount of signatures required to successfully challenge the `rootClaim`
+     *         output proposal. Once this threshold is met by members of the `signerSet`
+     *         calling `challenge`, the game will be resolved to `CHALLENGER_WINS`.
+     * @custom:invariant The `signatureThreshold` may never be greater than the length
+     *                   of the `signerSet`.
+     * @return _signatureThreshold The amount of signatures required to successfully
+     *         challenge the `rootClaim` output proposal.
+     */
+    function frozenSignatureThreshold() external view returns (uint256 _signatureThreshold);
+
+    /**
+     * @notice Returns the L2 Block Number that the `rootClaim` commits to.
+     *         Exists within the `extraData`.
+     * @return _l2BlockNumber The L2 Block Number that the `rootClaim` commits to.
+     */
+    function l2BlockNumber() external view returns (uint256 _l2BlockNumber);
+
+    /**
+     * @notice Challenge the `rootClaim`.
+     * @dev - If the `ecrecover`ed address that created the signature is not a part of
+     *        the signer set returned by `signerSet`, this function should revert.
+     *      - If the `ecrecover`ed address that created the signature is not the
+     *        msg.sender, this function should revert.
+     *      - If the signature provided is the signature that breaches the signature
+     *        threshold, the function should call the `resolve` function to resolve
+     *        the game as `CHALLENGER_WINS`.
+     *      - When the game resolves, the bond attached to the root claim should be
+     *        distributed among the signers who participated in challenging the
+     *        invalid claim.
+     * @param signature An EIP-712 signature committing to the `rootClaim` and
+     *        `l2BlockNumber` (within the `extraData`) from a key that exists
+     *         within the `signerSet`.
+     */
+    function challenge(bytes calldata signature) external;
+}

packages/contracts-bedrock/contracts/dispute/IBondManager.sol

+/// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.15;
+
+/**
+ * @title IBondManager
+ * @notice The Bond Manager holds ether posted as a bond for a bond id.
+ */
+interface IBondManager {
+    /**
+     * @notice Post a bond with a given id and owner.
+     * @dev This function will revert if the provided bondId is already in use.
+     * @param bondId is the id of the bond.
+     * @param owner is the address that owns the bond.
+     * @param minClaimHold is the minimum amount of time the owner
+     *        must wait before reclaiming their bond.
+     */
+    function post(
+        bytes32 bondId,
+        address owner,
+        uint256 minClaimHold
+    ) external payable;
+
+    /**
+     * @notice Seizes the bond with the given id.
+     * @dev This function will revert if there is no bond at the given id.
+     * @param bondId is the id of the bond.
+     */
+    function seize(bytes32 bondId) external;
+
+    /**
+     * @notice Seizes the bond with the given id and distributes it to recipients.
+     * @dev This function will revert if there is no bond at the given id.
+     * @param bondId is the id of the bond.
+     * @param recipients is a set of addresses to split the bond amongst.
+     */
+    function seizeAndSplit(bytes32 bondId, address[] calldata recipients) external;
+
+    /**
+     * @notice Reclaims the bond of the bond owner.
+     * @dev This function will revert if there is no bond at the given id.
+     * @param bondId is the id of the bond.
+     */
+    function reclaim(bytes32 bondId) external;
+}

packages/contracts-bedrock/contracts/dispute/IDisputeGame.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.15;
+
+import { Claim, GameType, GameStatus, Timestamp } from "../libraries/DisputeTypes.sol";
+
+import { IVersioned } from "./IVersioned.sol";
+import { IBondManager } from "./IBondManager.sol";
+import { IInitializable } from "./IInitializable.sol";
+
+/**
+ * @title IDisputeGame
+ * @notice The generic interface for a DisputeGame contract.
+ */
+interface IDisputeGame is IInitializable, IVersioned {
+    /**
+     * @notice Emitted when the game is resolved.
+     * @param status The status of the game after resolution.
+     */
+    event Resolved(GameStatus indexed status);
+
+    /// @notice Returns the timestamp that the DisputeGame contract was created at.
+
+    /**
+     * @notice Returns the timestamp that the DisputeGame contract was created at.
+     * @return _createdAt The timestamp that the DisputeGame contract was created at.
+     */
+    function createdAt() external view returns (Timestamp _createdAt);
+
+    /**
+     * @notice Returns the current status of the game.
+     * @return _status The current status of the game.
+     */
+    function status() external view returns (GameStatus _status);
+
+    /**
+     * @notice Getter for the game type.
+     * @dev `clones-with-immutable-args` argument #1
+     * @dev The reference impl should be entirely different depending on the type (fault, validity)
+     *      i.e. The game type should indicate the security model.
+     * @return _gameType The type of proof system being used.
+     */
+    function gameType() external view returns (GameType _gameType);
+
+    /**
+     * @notice Getter for the root claim.
+     * @dev `clones-with-immutable-args` argument #2
+     * @return _rootClaim The root claim of the DisputeGame.
+     */
+    function rootClaim() external view returns (Claim _rootClaim);
+
+    /**
+     * @notice Getter for the extra data.
+     * @dev `clones-with-immutable-args` argument #3
+     * @return _extraData Any extra data supplied to the dispute game contract by the creator.
+     */
+    function extraData() external view returns (bytes memory _extraData);
+
+    /**
+     * @notice Returns the address of the `BondManager` used.
+     * @return _bondManager The address of the `BondManager` used.
+     */
+    function bondManager() external view returns (IBondManager _bondManager);
+
+    /**
+     * @notice If all necessary information has been gathered, this function should mark the game
+     *         status as either `CHALLENGER_WINS` or `DEFENDER_WINS` and return the status of
+     *         the resolved game. It is at this stage that the bonds should be awarded to the
+     *         necessary parties.
+     * @dev May only be called if the `status` is `IN_PROGRESS`.
+     * @return _status The status of the game after resolution.
+     */
+    function resolve() external returns (GameStatus _status);
+}

packages/contracts-bedrock/contracts/dispute/IDisputeGameFactory.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.15;
+
+import { Claim, GameType } from "../libraries/DisputeTypes.sol";
+
+import { IDisputeGame } from "./IDisputeGame.sol";
+
+/**
+ * @title IDisputeGameFactory
+ * @notice The interface for a DisputeGameFactory contract.
+ */
+interface IDisputeGameFactory {
+    /**
+     * @notice Emitted when a new dispute game is created
+     * @param disputeProxy The address of the dispute game proxy
+     * @param gameType The type of the dispute game proxy's implementation
+     * @param rootClaim The root claim of the dispute game
+     */
+    event DisputeGameCreated(
+        address indexed disputeProxy,
+        GameType indexed gameType,
+        Claim indexed rootClaim
+    );
+
+    /**
+     * @notice `games` queries an internal a mapping that maps the hash of
+     *         `gameType ++ rootClaim ++ extraData` to the deployed `DisputeGame` clone.
+     * @dev `++` equates to concatenation.
+     * @param gameType The type of the DisputeGame - used to decide the proxy implementation
+     * @param rootClaim The root claim of the DisputeGame.
+     * @param extraData Any extra data that should be provided to the created dispute game.
+     * @return _proxy The clone of the `DisputeGame` created with the given parameters.
+     *         Returns `address(0)` if nonexistent.
+     */
+    function games(
+        GameType gameType,
+        Claim rootClaim,
+        bytes calldata extraData
+    ) external view returns (IDisputeGame _proxy);
+
+    /**
+     * @notice `gameImpls` is a mapping that maps `GameType`s to their respective
+     *         `IDisputeGame` implementations.
+     * @param gameType The type of the dispute game.
+     * @return _impl The address of the implementation of the game type.
+     *         Will be cloned on creation of a new dispute game with the given `gameType`.
+     */
+    function gameImpls(GameType gameType) external view returns (IDisputeGame _impl);
+
+    /**
+     * @notice Creates a new DisputeGame proxy contract.
+     * @param gameType The type of the DisputeGame - used to decide the proxy implementation
+     * @param rootClaim The root claim of the DisputeGame.
+     * @param extraData Any extra data that should be provided to the created dispute game.
+     * @return proxy The address of the created DisputeGame proxy.
+     */
+    function create(
+        GameType gameType,
+        Claim rootClaim,
+        bytes calldata extraData
+    ) external returns (IDisputeGame proxy);
+
+    /**
+     * @notice Sets the implementation contract for a specific `GameType`.
+     * @dev May only be called by the `owner`.
+     * @param gameType The type of the DisputeGame.
+     * @param impl The implementation contract for the given `GameType`.
+     */
+    function setImplementation(GameType gameType, IDisputeGame impl) external;
+}

packages/contracts-bedrock/contracts/dispute/IFaultDisputeGame.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.15;
+
+import { Claim, ClaimHash, Clock, Bond, Position, Timestamp } from "../libraries/DisputeTypes.sol";
+
+import { IDisputeGame } from "./IDisputeGame.sol";
+
+/**
+ * @title IFaultDisputeGame
+ * @notice The interface for a fault proof backed dispute game.
+ */
+interface IFaultDisputeGame is IDisputeGame {
+    /**
+     * @notice Emitted when a subclaim is disagreed upon by `claimant`
+     * @dev Disagreeing with a subclaim is akin to attacking it.
+     * @param claimHash The unique ClaimHash that is being disagreed upon
+     * @param pivot The claim for the following pivot (disagreement = go left)
+     * @param claimant The address of the claimant
+     */
+    event Attack(ClaimHash indexed claimHash, Claim indexed pivot, address indexed claimant);
+
+    /**
+     * @notice Emitted when a subclaim is agreed upon by `claimant`
+     * @dev Agreeing with a subclaim is akin to defending it.
+     * @param claimHash The unique ClaimHash that is being agreed upon
+     * @param pivot The claim for the following pivot (agreement = go right)
+     * @param claimant The address of the claimant
+     */
+    event Defend(ClaimHash indexed claimHash, Claim indexed pivot, address indexed claimant);
+
+    /**
+     * @notice State variable of the starting timestamp of the game, set on deployment.
+     * @return The starting timestamp of the game
+     */
+    function gameStart() external view returns (Timestamp);
+
+    /**
+     * @notice Maps a unique ClaimHash to a Claim.
+     * @param claimHash The unique ClaimHash
+     * @return claim The Claim associated with the ClaimHash
+     */
+    function claims(ClaimHash claimHash) external view returns (Claim claim);
+
+    /**
+     * @notice Maps a unique ClaimHash to its parent.
+     * @param claimHash The unique ClaimHash
+     * @return parent The parent ClaimHash of the passed ClaimHash
+     */
+    function parents(ClaimHash claimHash) external view returns (ClaimHash parent);
+
+    /**
+     * @notice Maps a unique ClaimHash to its Position.
+     * @param claimHash The unique ClaimHash
+     * @return position The Position associated with the ClaimHash
+     */
+    function positions(ClaimHash claimHash) external view returns (Position position);
+
+    /**
+     * @notice Maps a unique ClaimHash to a Bond.
+     * @param claimHash The unique ClaimHash
+     * @return bond The Bond associated with the ClaimHash
+     */
+    function bonds(ClaimHash claimHash) external view returns (Bond bond);
+
+    /**
+     * @notice Maps a unique ClaimHash its chess clock.
+     * @param claimHash The unique ClaimHash
+     * @return clock The chess clock associated with the ClaimHash
+     */
+    function clocks(ClaimHash claimHash) external view returns (Clock clock);
+
+    /**
+     * @notice Maps a unique ClaimHash to its reference counter.
+     * @param claimHash The unique ClaimHash
+     * @return _rc The reference counter associated with the ClaimHash
+     */
+    function rc(ClaimHash claimHash) external view returns (uint64 _rc);
+
+    /**
+     * @notice Maps a unique ClaimHash to a boolean indicating whether or not it has been countered.
+     * @param claimHash The unique claimHash
+     * @return _countered Whether or not `claimHash` has been countered
+     */
+    function countered(ClaimHash claimHash) external view returns (bool _countered);
+
+    /**
+     * @notice Disagree with a subclaim
+     * @param disagreement The ClaimHash of the disagreement
+     * @param pivot The claimed pivot
+     */
+    function attack(ClaimHash disagreement, Claim pivot) external;
+
+    /**
+     * @notice Agree with a subclaim
+     * @param agreement The ClaimHash of the agreement
+     * @param pivot The claimed pivot
+     */
+    function defend(ClaimHash agreement, Claim pivot) external;
+
+    /**
+     * @notice Perform the final step via an on-chain fault proof processor
+     * @dev This function should point to a fault proof processor in order to execute
+     *      a step in the fault proof program on-chain. The interface of the fault proof
+     *      processor contract should be generic enough such that we can use different
+     *      fault proof VMs (MIPS, RiscV5, etc.)
+     * @param disagreement The ClaimHash of the disagreement
+     */
+    function step(ClaimHash disagreement) external;
+}

packages/contracts-bedrock/contracts/dispute/IInitializable.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.15;
+
+/**
+ * @title IInitializable
+ * @notice An interface for initializable contracts.
+ */
+interface IInitializable {
+    /**
+     * @notice Initializes the contract.
+     * @dev This function may only be called once.
+     */
+    function initialize() external;
+}

packages/contracts-bedrock/contracts/dispute/IVersioned.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.15;
+
+/**
+ * @title IVersioned
+ * @notice An interface for semantically versioned contracts.
+ */
+interface IVersioned {
+    /**
+     * @notice Returns the semantic version of the contract
+     * @return _version The semantic version of the contract
+     */
+    function version() external pure returns (string memory _version);
+}

packages/contracts-bedrock/contracts/libraries/DisputeErrors.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.15;
+
+import "./DisputeTypes.sol";
+
+////////////////////////////////////////////////////////////////
+//                `DisputeGameFactory` Errors                 //
+////////////////////////////////////////////////////////////////
+
+/**
+ * @notice Thrown when a dispute game is attempted to be created with an unsupported game type.
+ * @param gameType The unsupported game type.
+ */
+error NoImplementation(GameType gameType);
+
+/**
+ * @notice Thrown when a dispute game that already exists is attempted to be created.
+ * @param uuid The UUID of the dispute game that already exists.
+ */
+error GameAlreadyExists(Hash uuid);
+
+////////////////////////////////////////////////////////////////
+//               `DisputeGame_Fault.sol` Errors               //
+////////////////////////////////////////////////////////////////
+
+/**
+ * @notice Thrown when a supplied bond is too low to cover the
+ *         cost of the next possible counter claim.
+ */
+error BondTooLow();
+
+/**
+ * @notice Thrown when a defense against the root claim is attempted.
+ */
+error CannotDefendRootClaim();
+
+/**
+ * @notice Thrown when a claim is attempting to be made that already exists.
+ */
+error ClaimAlreadyExists();
+
+////////////////////////////////////////////////////////////////
+//              `AttestationDisputeGame` Errors               //
+////////////////////////////////////////////////////////////////
+
+/**
+ * @notice Thrown when an invalid signature is submitted to `challenge`.
+ */
+error InvalidSignature();
+
+/**
+ * @notice Thrown when a signature that has already been used to support the
+ *         `rootClaim` is submitted to `challenge`.
+ */
+error AlreadyChallenged();
+
+////////////////////////////////////////////////////////////////
+//                      `Ownable` Errors                      //
+////////////////////////////////////////////////////////////////
+
+/**
+ * @notice Thrown when a function that is protected by the `onlyOwner` modifier
+ *          is called from an account other than the owner.
+ */
+error NotOwner();

packages/contracts-bedrock/contracts/libraries/DisputeTypes.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.15;
+
+/**
+ * @notice A custom type for a generic hash.
+ */
+type Hash is bytes32;
+
+/**
+ * @notice A claim represents an MPT root representing the state of the fault proof program.
+ */
+type Claim is bytes32;
+
+/**
+ * @notice A claim hash represents a hash of a claim and a position within the game tree.
+ * @dev Keccak hash of abi.encodePacked(Claim, Position);
+ */
+type ClaimHash is bytes32;
+
+/**
+ * @notice A bond represents the amount of collateral that a user has locked up in a claim.
+ */
+type Bond is uint256;
+
+/**
+ * @notice A dedicated timestamp type.
+ */
+type Timestamp is uint64;
+
+/**
+ * @notice A dedicated duration type.
+ * @dev Unit: seconds
+ */
+type Duration is uint64;
+
+/**
+ * @notice A `Clock` represents a packed `Duration` and `Timestamp`
+ * @dev The packed layout of this type is as follows:
+ * ┌────────────┬────────────────┐
+ * │    Bits    │     Value      │
+ * ├────────────┼────────────────┤
+ * │ [0, 128)   │ Duration       │
+ * │ [128, 256) │ Timestamp      │
+ * └────────────┴────────────────┘
+ */
+type Clock is uint256;
+
+/**
+ * @notice A `Position` represents a position of a claim within the game tree.
+ * @dev The packed layout of this type is as follows:
+ * ┌────────────┬────────────────┐
+ * │    Bits    │     Value      │
+ * ├────────────┼────────────────┤
+ * │ [0, 128)   │ Depth          │
+ * │ [128, 256) │ Index at depth │
+ * └────────────┴────────────────┘
+ */
+type Position is uint256;
+
+/**
+ * @notice The current status of the dispute game.
+ */
+enum GameStatus {
+    // The game is currently in progress, and has not been resolved.
+    IN_PROGRESS,
+    // The game has concluded, and the `rootClaim` was challenged successfully.
+    CHALLENGER_WINS,
+    // The game has concluded, and the `rootClaim` could not be contested.
+    DEFENDER_WINS
+}
+
+/**
+ * @notice The type of proof system being used.
+ */
+enum GameType {
+    // The game will use a `IDisputeGame` implementation that utilizes fault proofs.
+    FAULT,
+    // The game will use a `IDisputeGame` implementation that utilizes validity proofs.
+    VALIDITY,
+    // The game will use a `IDisputeGame` implementation that utilizes attestation proofs.
+    ATTESTATION
+}

packages/contracts-bedrock/contracts/test/DisputeGameFactory.t.sol

+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.15;
+
+import "../libraries/DisputeTypes.sol";
+import "../libraries/DisputeErrors.sol";
+
+import { Test } from "forge-std/Test.sol";
+import { DisputeGameFactory } from "../dispute/DisputeGameFactory.sol";
+import { IDisputeGame } from "../dispute/IDisputeGame.sol";
+
+contract DisputeGameFactory_Test is Test {
+    DisputeGameFactory factory;
+    FakeClone fakeClone;
+
+    event DisputeGameCreated(
+        address indexed disputeProxy,
+        GameType indexed gameType,
+        Claim indexed rootClaim
+    );
+
+    function setUp() public {
+        factory = new DisputeGameFactory(address(this));
+        fakeClone = new FakeClone();
+    }
+
+    /**
+     * @dev Tests that the `create` function succeeds when creating a new dispute game
+     *      with a `GameType` that has an implementation set.
+     */
+    function testFuzz_create_succeeds(
+        uint8 gameType,
+        Claim rootClaim,
+        bytes calldata extraData
+    ) public {
+        // Ensure that the `gameType` is within the bounds of the `GameType` enum's possible values.
+        GameType gt = GameType(uint8(bound(gameType, 0, 2)));
+
+        // Set all three implementations to the same `FakeClone` contract.
+        for (uint8 i; i < 3; i++) {
+            factory.setImplementation(GameType(i), IDisputeGame(address(fakeClone)));
+        }
+
+        vm.expectEmit(false, true, true, false);
+        emit DisputeGameCreated(address(0), gt, rootClaim);
+        IDisputeGame proxy = factory.create(gt, rootClaim, extraData);
+
+        // Ensure that the dispute game was assigned to the `disputeGames` mapping.
+        assertEq(address(factory.games(gt, rootClaim, extraData)), address(proxy));
+    }
+
+    /**
+     * @dev Tests that the `create` function reverts when there is no implementation
+     *      set for the given `GameType`.
+     */
+    function testFuzz_create_noImpl_reverts(
+        uint8 gameType,
+        Claim rootClaim,
+        bytes calldata extraData
+    ) public {
+        // Ensure that the `gameType` is within the bounds of the `GameType` enum's possible values.
+        GameType gt = GameType(uint8(bound(gameType, 0, 2)));
+
+        vm.expectRevert(abi.encodeWithSelector(NoImplementation.selector, gt));
+        factory.create(gt, rootClaim, extraData);
+    }
+
+    /**
+     * @dev Tests that the `create` function reverts when there exists a dispute game with the same UUID.
+     */
+    function testFuzz_create_sameUUID_reverts(
+        uint8 gameType,
+        Claim rootClaim,
+        bytes calldata extraData
+    ) public {
+        // Ensure that the `gameType` is within the bounds of the `GameType` enum's possible values.
+        GameType gt = GameType(uint8(bound(gameType, 0, 2)));
+
+        // Set all three implementations to the same `FakeClone` contract.
+        for (uint8 i; i < 3; i++) {
+            factory.setImplementation(GameType(i), IDisputeGame(address(fakeClone)));
+        }
+
+        // Create our first dispute game - this should succeed.
+        vm.expectEmit(false, true, true, false);
+        emit DisputeGameCreated(address(0), gt, rootClaim);
+        IDisputeGame proxy = factory.create(gt, rootClaim, extraData);
+
+        // Ensure that the dispute game was assigned to the `disputeGames` mapping.
+        assertEq(address(factory.games(gt, rootClaim, extraData)), address(proxy));
+
+        // Ensure that the `create` function reverts when called with parameters that would result in the same UUID.
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                GameAlreadyExists.selector,
+                factory.getGameUUID(gt, rootClaim, extraData)
+            )
+        );
+        factory.create(gt, rootClaim, extraData);
+    }
+
+    /**
+     * @dev Tests that the `setImplementation` function properly sets the implementation for a given `GameType`.
+     */
+    function test_setImplementation_succeeds() public {
+        // There should be no implementation for the `GameType.FAULT` enum value, it has not been set.
+        assertEq(address(factory.gameImpls(GameType.FAULT)), address(0));
+
+        // Set the implementation for the `GameType.FAULT` enum value.
+        factory.setImplementation(GameType.FAULT, IDisputeGame(address(1)));
+
+        // Ensure that the implementation for the `GameType.FAULT` enum value is set.
+        assertEq(address(factory.gameImpls(GameType.FAULT)), address(1));
+    }
+
+    /**
+     * @dev Tests that the `setImplementation` function reverts when called by a non-owner.
+     */
+    function test_setImplementation_notOwner_reverts() public {
+        // Ensure that the `setImplementation` function reverts when called by a non-owner.
+        vm.prank(address(0));
+        vm.expectRevert("Ownable: caller is not the owner");
+        factory.setImplementation(GameType.FAULT, IDisputeGame(address(1)));
+    }
+
+    /**
+     * @dev Tests that the `getGameUUID` function returns the correct hash when comparing
+     *      against the keccak256 hash of the abi-encoded parameters.
+     */
+    function testDiff_getGameUUID_succeeds(
+        uint8 gameType,
+        Claim rootClaim,
+        bytes calldata extraData
+    ) public {
+        // Ensure that the `gameType` is within the bounds of the `GameType` enum's possible values.
+        GameType gt = GameType(uint8(bound(gameType, 0, 2)));
+
+        assertEq(
+            Hash.unwrap(factory.getGameUUID(gt, rootClaim, extraData)),
+            keccak256(abi.encode(gt, rootClaim, extraData))
+        );
+    }
+
+    /**
+     * @dev Tests that the `owner` function returns the correct address after deployment.
+     */
+    function test_owner_succeeds() public {
+        assertEq(factory.owner(), address(this));
+    }
+
+    /**
+     * @dev Tests that the `transferOwnership` function succeeds when called by the owner.
+     */
+    function test_transferOwnership_succeeds() public {
+        factory.transferOwnership(address(1));
+        assertEq(factory.owner(), address(1));
+    }
+
+    /**
+     * @dev Tests that the `transferOwnership` function reverts when called by a non-owner.
+     */
+    function test_transferOwnership_notOwner_reverts() public {
+        vm.prank(address(0));
+        vm.expectRevert("Ownable: caller is not the owner");
+        factory.transferOwnership(address(1));
+    }
+}
+
+/**
+ * @dev A fake clone used for testing the `DisputeGameFactory` contract's `create` function.
+ */
+contract FakeClone {
+    function initialize() external {
+        // noop
+    }
+}

packages/contracts-bedrock/deploy/019-SystemDictatorInit.ts

@@ -181,9 +181,7 @@ const deployFn: DeployFunction = async (hre) => {
     console.log('Transferring ownership of the SystemDictator proxy...')
 
     // Transfer ownership to the controller address.
-    await SystemDictatorProxyWithSigner.transferOwnership(
-      hre.deployConfig.controller
-    )
+    await SystemDictatorProxyWithSigner.changeAdmin(hre.deployConfig.controller)
 
     // Wait for the transaction to execute properly.
     await awaitCondition(

packages/contracts-bedrock/deployments/final-migration-rehearsal/.chainId

-5
\ No newline at end of file

packages/contracts-bedrock/foundry.toml

@@ -8,6 +8,7 @@ remappings = [
   '@openzeppelin/contracts-upgradeable/=node_modules/@openzeppelin/contracts-upgradeable/',
   '@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/',
   '@rari-capital/solmate/=node_modules/@rari-capital/solmate',
+  "@cwia/=node_modules/clones-with-immutable-args/src",
   'forge-std/=node_modules/forge-std/src',
   'ds-test/=node_modules/ds-test/src'
 ]

packages/contracts-bedrock/package.json

@@ -70,6 +70,7 @@
     "@nomiclabs/hardhat-ethers": "^2.0.0",
     "@nomiclabs/hardhat-waffle": "^2.0.0",
     "@rari-capital/solmate": "https://github.com/rari-capital/solmate.git#8f9b23f8838670afda0fd8983f2c41e8037ae6bc",
+    "clones-with-immutable-args": "https://github.com/Saw-mon-and-Natalie/clones-with-immutable-args.git#105efee1b9127ed7f6fedf139e1fc796ce8791f2",
     "@typechain/ethers-v5": "^10.1.0",
     "@typescript-eslint/eslint-plugin": "^5.45.1",
     "@typescript-eslint/parser": "^5.45.1",

packages/sdk/src/cross-chain-messenger.ts

@@ -144,6 +144,12 @@ export class CrossChainMessenger {
     bedrock?: boolean
   }) {
     this.bedrock = opts.bedrock ?? false
+
+    if (!this.bedrock) {
+      console.warn(
+        'Bedrock compatibility is disabled in CrossChainMessenger.  Please enable it if you are using Bedrock.'
+      )
+    }
     this.l1SignerOrProvider = toSignerOrProvider(opts.l1SignerOrProvider)
     this.l2SignerOrProvider = toSignerOrProvider(opts.l2SignerOrProvider)
 

packages/sdk/src/interfaces/types.ts

@@ -29,6 +29,7 @@ export enum L2ChainID {
   OPTIMISM_HARDHAT_DEVNET = 17,
   OPTIMISM_BEDROCK_LOCAL_DEVNET = 901,
   OPTIMISM_BEDROCK_ALPHA_TESTNET = 28528,
+  BASE_GOERLI = 84531,
 }
 
 /**

proxyd/example.config.toml

@@ -72,6 +72,9 @@ ca_file = ""
 client_cert_file = ""
 # Path to a custom client key file.
 client_key_file = ""
+# Allows backends to skip peer count checking, default false
+# consensus_skip_peer_count = true
+
 
 [backends.alchemy]
 rpc_url = ""