Merge branch 'develop' into sc/optimist-goerli-deployments

.changeset/clever-jokes-notice.md

----
-'@eth-optimism/contracts-bedrock': patch
----
-
-Reduce the time that the system dictator deploy scripts wait before checking the chain state.

.changeset/cuddly-turkeys-burn.md

----
-'@eth-optimism/sdk': patch
----
-
-Have SDK automatically create Standard and ETH bridges when L1StandardBridge is provided.

.changeset/fresh-pots-move.md

----
-'@eth-optimism/batch-submitter-service': patch
----
-
-Allow deposit only batches

.changeset/good-clocks-relax.md

----
-'@eth-optimism/data-transport-layer': patch
----
-
-Add better logging to DTL about shutoff block

.changeset/ninety-schools-work.md

----
-'@eth-optimism/chain-mon': minor
----
-
-Introduces the balance-mon service to chain-mon.

.changeset/olive-students-love.md

----
-'@eth-optimism/contracts-bedrock': patch
----
-
-Makes the Proxy contract inheritable by making functions (public virtual).

.changeset/pink-chicken-hear.md

----
-'@eth-optimism/contracts-bedrock': patch
----
-
-Added a contsructor to the System Dictator

.changeset/poor-carrots-walk.md

----
-'@eth-optimism/hardhat-deploy-config': patch
----
-
-Add getter for other network's deploy config

.changeset/sharp-islands-attend.md

----
-'@eth-optimism/batch-submitter-service': patch
----
-
-fix flag name for MaxStateRootElements in batch-submitter
-fix log package for proposer

.changeset/tricky-donkeys-lick.md

----
-'@eth-optimism/chain-mon': patch
-'@eth-optimism/data-transport-layer': patch
-'@eth-optimism/fault-detector': patch
-'@eth-optimism/message-relayer': patch
-'@eth-optimism/replica-healthcheck': patch
----
-
-Empty patch release to re-release packages that failed to be released by a bug in the release process.

batch-submitter/CHANGELOG.md

 # @eth-optimism/batch-submitter-service
 
+## 0.1.16
+
+### Patch Changes
+
+- 32bd79ec9: Allow deposit only batches
+- da79ef441: fix flag name for MaxStateRootElements in batch-submitter
+  fix log package for proposer
+
 ## 0.1.15
 
 ### Patch Changes

batch-submitter/package.json

 {
 	"name": "@eth-optimism/batch-submitter-service",
-	"version": "0.1.15",
+	"version": "0.1.16",
 	"private": true,
 	"devDependencies": {}
 }

integration-tests/package.json

@@ -30,10 +30,10 @@
   "devDependencies": {
     "@babel/eslint-parser": "^7.5.4",
     "@eth-optimism/contracts": "^0.5.40",
-    "@eth-optimism/contracts-bedrock": "0.13.1",
+    "@eth-optimism/contracts-bedrock": "0.13.2",
     "@eth-optimism/contracts-periphery": "^1.0.7",
     "@eth-optimism/core-utils": "0.12.0",
-    "@eth-optimism/sdk": "2.0.1",
+    "@eth-optimism/sdk": "2.0.2",
     "@ethersproject/abstract-provider": "^5.7.0",
     "@ethersproject/providers": "^5.7.0",
     "@ethersproject/transactions": "^5.7.0",

op-e2e/actions/l2_engine.go

@@ -4,7 +4,7 @@ import (
 	"errors"
 
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils"
-	"github.com/ethereum-optimism/optimism/op-program/l2/engineapi"
+	"github.com/ethereum-optimism/optimism/op-program/client/l2/engineapi"
 	"github.com/stretchr/testify/require"
 
 	"github.com/ethereum/go-ethereum/common"

op-e2e/actions/l2_engine_test.go

@@ -4,8 +4,8 @@ import (
 	"math/big"
 	"testing"
 
-	"github.com/ethereum-optimism/optimism/op-program/l2/engineapi"
-	"github.com/ethereum-optimism/optimism/op-program/l2/engineapi/test"
+	"github.com/ethereum-optimism/optimism/op-program/client/l2/engineapi"
+	"github.com/ethereum-optimism/optimism/op-program/client/l2/engineapi/test"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/consensus/beacon"
 	"github.com/ethereum/go-ethereum/consensus/ethash"

op-e2e/setup.go

@@ -68,7 +68,7 @@ func DefaultSystemConfig(t *testing.T) SystemConfig {
 	deployConfig := &genesis.DeployConfig{
 		L1ChainID:   900,
 		L2ChainID:   901,
-		L2BlockTime: 2,
+		L2BlockTime: 1,
 
 		FinalizationPeriodSeconds: 60 * 60 * 24,
 		MaxSequencerDrift:         10,

op-node/metrics/metrics.go

@@ -64,6 +64,7 @@ type Metricer interface {
 	RecordSequencerBuildingDiffTime(duration time.Duration)
 	RecordSequencerSealingTime(duration time.Duration)
 	Document() []metrics.DocumentedMetric
+	RecordChannelInputBytes(num int)
 	// P2P Metrics
 	SetPeerScores(scores map[string]float64)
 	ClientPayloadByNumberEvent(num uint64, resultCode byte, duration time.Duration)
@@ -131,6 +132,8 @@ type Metrics struct {
 	GossipEventsTotal *prometheus.CounterVec
 	BandwidthTotal    *prometheus.GaugeVec
 
+	ChannelInputBytes prometheus.Counter
+
 	registry *prometheus.Registry
 	factory  metrics.Factory
 }
@@ -331,6 +334,12 @@ func NewMetrics(procName string) *Metrics {
 			"direction",
 		}),
 
+		ChannelInputBytes: factory.NewCounter(prometheus.CounterOpts{
+			Namespace: ns,
+			Name:      "channel_input_bytes",
+			Help:      "Number of compressed bytes added to the channel",
+		}),
+
 		P2PReqDurationSeconds: factory.NewHistogramVec(prometheus.HistogramOpts{
 			Namespace: ns,
 			Subsystem: "p2p",
@@ -635,6 +644,10 @@ func (m *Metrics) PayloadsQuarantineSize(n int) {
 	m.PayloadsQuarantineTotal.Set(float64(n))
 }
 
+func (m *Metrics) RecordChannelInputBytes(inputCompressedBytes int) {
+	m.ChannelInputBytes.Add(float64(inputCompressedBytes))
+}
+
 type noopMetricer struct{}
 
 var NoopMetrics Metricer = new(noopMetricer)
@@ -737,3 +750,6 @@ func (n *noopMetricer) ServerPayloadByNumberEvent(num uint64, resultCode byte, d
 
 func (n *noopMetricer) PayloadsQuarantineSize(int) {
 }
+
+func (n *noopMetricer) RecordChannelInputBytes(int) {
+}

op-node/rollup/derive/channel_bank.go

@@ -124,6 +124,7 @@ func (cb *ChannelBank) Read() (data []byte, err error) {
 	if !ch.IsReady() {
 		return nil, io.EOF
 	}
+	cb.log.Info("Reading channel", "channel", first, "frames", len(ch.inputs))
 
 	delete(cb.channels, first)
 	cb.channelQueue = cb.channelQueue[1:]

op-node/rollup/derive/channel_in_reader.go

@@ -21,15 +21,18 @@ type ChannelInReader struct {
 	nextBatchFn func() (BatchWithL1InclusionBlock, error)
 
 	prev *ChannelBank
+
+	metrics Metrics
 }
 
 var _ ResetableStage = (*ChannelInReader)(nil)
 
 // NewChannelInReader creates a ChannelInReader, which should be Reset(origin) before use.
-func NewChannelInReader(log log.Logger, prev *ChannelBank) *ChannelInReader {
+func NewChannelInReader(log log.Logger, prev *ChannelBank, metrics Metrics) *ChannelInReader {
 	return &ChannelInReader{
-		log:  log,
-		prev: prev,
+		log:     log,
+		prev:    prev,
+		metrics: metrics,
 	}
 }
 
@@ -41,6 +44,7 @@ func (cr *ChannelInReader) Origin() eth.L1BlockRef {
 func (cr *ChannelInReader) WriteChannel(data []byte) error {
 	if f, err := BatchReader(bytes.NewBuffer(data), cr.Origin()); err == nil {
 		cr.nextBatchFn = f
+		cr.metrics.RecordChannelInputBytes(len(data))
 		return nil
 	} else {
 		cr.log.Error("Error creating batch reader from channel data", "err", err)

op-node/rollup/derive/pipeline.go

@@ -15,6 +15,7 @@ type Metrics interface {
 	RecordL1Ref(name string, ref eth.L1BlockRef)
 	RecordL2Ref(name string, ref eth.L2BlockRef)
 	RecordUnsafePayloadsBuffer(length uint64, memSize uint64, next eth.BlockID)
+	RecordChannelInputBytes(inputCompresedBytes int)
 }
 
 type L1Fetcher interface {
@@ -82,7 +83,7 @@ func NewDerivationPipeline(log log.Logger, cfg *rollup.Config, l1Fetcher L1Fetch
 	l1Src := NewL1Retrieval(log, dataSrc, l1Traversal)
 	frameQueue := NewFrameQueue(log, l1Src)
 	bank := NewChannelBank(log, cfg, frameQueue, l1Fetcher)
-	chInReader := NewChannelInReader(log, bank)
+	chInReader := NewChannelInReader(log, bank, metrics)
 	batchQueue := NewBatchQueue(log, cfg, chInReader)
 	attrBuilder := NewFetchingAttributesBuilder(cfg, l1Fetcher, engine)
 	attributesQueue := NewAttributesQueue(log, cfg, attrBuilder, batchQueue)

op-node/rollup/driver/driver.go

@@ -21,6 +21,7 @@ type Metrics interface {
 
 	RecordL1Ref(name string, ref eth.L1BlockRef)
 	RecordL2Ref(name string, ref eth.L2BlockRef)
+	RecordChannelInputBytes(inputCompresedBytes int)
 
 	RecordUnsafePayloadsBuffer(length uint64, memSize uint64, next eth.BlockID)
 

op-node/testutils/metrics.go

 package testutils
 
-import "github.com/ethereum-optimism/optimism/op-node/eth"
+import (
+	"github.com/ethereum-optimism/optimism/op-node/eth"
+)
 
 // TestDerivationMetrics implements the metrics used in the derivation pipeline as no-op operations.
 // Optionally a test may hook into the metrics
 type TestDerivationMetrics struct {
-	FnRecordL1ReorgDepth   func(d uint64)
-	FnRecordL1Ref          func(name string, ref eth.L1BlockRef)
-	FnRecordL2Ref          func(name string, ref eth.L2BlockRef)
-	FnRecordUnsafePayloads func(length uint64, memSize uint64, next eth.BlockID)
+	FnRecordL1ReorgDepth      func(d uint64)
+	FnRecordL1Ref             func(name string, ref eth.L1BlockRef)
+	FnRecordL2Ref             func(name string, ref eth.L2BlockRef)
+	FnRecordUnsafePayloads    func(length uint64, memSize uint64, next eth.BlockID)
+	FnRecordChannelInputBytes func(inputCompresedBytes int)
 }
 
 func (t *TestDerivationMetrics) RecordL1ReorgDepth(d uint64) {
@@ -35,6 +38,12 @@ func (t *TestDerivationMetrics) RecordUnsafePayloadsBuffer(length uint64, memSiz
 	}
 }
 
+func (t *TestDerivationMetrics) RecordChannelInputBytes(inputCompresedBytes int) {
+	if t.FnRecordChannelInputBytes != nil {
+		t.FnRecordChannelInputBytes(inputCompresedBytes)
+	}
+}
+
 type TestRPCMetrics struct{}
 
 func (n *TestRPCMetrics) RecordRPCServerRequest(method string) func() {

op-program/client/driver/driver.go

+package driver
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+
+	"github.com/ethereum-optimism/optimism/op-node/eth"
+	"github.com/ethereum-optimism/optimism/op-node/metrics"
+	"github.com/ethereum-optimism/optimism/op-node/rollup"
+	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
+	"github.com/ethereum/go-ethereum/log"
+)
+
+type Derivation interface {
+	Step(ctx context.Context) error
+	SafeL2Head() eth.L2BlockRef
+}
+
+type Driver struct {
+	logger   log.Logger
+	pipeline Derivation
+}
+
+func NewDriver(logger log.Logger, cfg *rollup.Config, l1Source derive.L1Fetcher, l2Source derive.Engine) *Driver {
+	pipeline := derive.NewDerivationPipeline(logger, cfg, l1Source, l2Source, metrics.NoopMetrics)
+	pipeline.Reset()
+	return &Driver{
+		logger:   logger,
+		pipeline: pipeline,
+	}
+}
+
+// Step runs the next step of the derivation pipeline.
+// Returns nil if there are further steps to be performed
+// Returns io.EOF if the derivation completed successfully
+// Returns a non-EOF error if the derivation failed
+func (d *Driver) Step(ctx context.Context) error {
+	if err := d.pipeline.Step(ctx); errors.Is(err, io.EOF) {
+		return io.EOF
+	} else if errors.Is(err, derive.NotEnoughData) {
+		d.logger.Debug("Data is lacking")
+		return nil
+	} else if err != nil {
+		return fmt.Errorf("pipeline err: %w", err)
+	}
+	return nil
+}
+
+func (d *Driver) SafeHead() eth.L2BlockRef {
+	return d.pipeline.SafeL2Head()
+}

op-program/client/driver/driver_test.go

+package driver
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"testing"
+
+	"github.com/ethereum-optimism/optimism/op-node/eth"
+	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
+	"github.com/ethereum-optimism/optimism/op-node/testlog"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/stretchr/testify/require"
+)
+
+func TestDerivationComplete(t *testing.T) {
+	driver := createDriver(t, fmt.Errorf("derivation complete: %w", io.EOF))
+	err := driver.Step(context.Background())
+	require.ErrorIs(t, err, io.EOF)
+}
+
+func TestTemporaryError(t *testing.T) {
+	driver := createDriver(t, fmt.Errorf("whoopsie: %w", derive.ErrTemporary))
+	err := driver.Step(context.Background())
+	require.ErrorIs(t, err, derive.ErrTemporary)
+}
+
+func TestNotEnoughDataError(t *testing.T) {
+	driver := createDriver(t, fmt.Errorf("idk: %w", derive.NotEnoughData))
+	err := driver.Step(context.Background())
+	require.NoError(t, err)
+}
+
+func TestGenericError(t *testing.T) {
+	expected := errors.New("boom")
+	driver := createDriver(t, expected)
+	err := driver.Step(context.Background())
+	require.ErrorIs(t, err, expected)
+}
+
+func TestNoError(t *testing.T) {
+	driver := createDriver(t, nil)
+	err := driver.Step(context.Background())
+	require.NoError(t, err)
+}
+
+func createDriver(t *testing.T, derivationResult error) *Driver {
+	derivation := &stubDerivation{nextErr: derivationResult}
+	return &Driver{
+		logger:   testlog.Logger(t, log.LvlDebug),
+		pipeline: derivation,
+	}
+}
+
+type stubDerivation struct {
+	nextErr error
+}
+
+func (s stubDerivation) Step(ctx context.Context) error {
+	return s.nextErr
+}
+
+func (s stubDerivation) SafeL2Head() eth.L2BlockRef {
+	return eth.L2BlockRef{}
+}

op-program/l2/engine.go → op-program/client/l2/engine.go

@@ -8,7 +8,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-node/eth"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
-	"github.com/ethereum-optimism/optimism/op-program/l2/engineapi"
+	"github.com/ethereum-optimism/optimism/op-program/client/l2/engineapi"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/log"

op-program/l2/engine_backend.go → op-program/client/l2/engine_backend.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"math/big"
 
-	"github.com/ethereum-optimism/optimism/op-program/l2/engineapi"
+	"github.com/ethereum-optimism/optimism/op-program/client/l2/engineapi"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/consensus"
 	"github.com/ethereum/go-ethereum/consensus/beacon"

op-program/l2/engine_backend_test.go → op-program/client/l2/engine_backend_test.go

@@ -6,8 +6,8 @@ import (
 
 	"github.com/ethereum-optimism/optimism/op-chain-ops/genesis"
 	"github.com/ethereum-optimism/optimism/op-node/testlog"
-	"github.com/ethereum-optimism/optimism/op-program/l2/engineapi"
-	"github.com/ethereum-optimism/optimism/op-program/l2/engineapi/test"
+	"github.com/ethereum-optimism/optimism/op-program/client/l2/engineapi"
+	"github.com/ethereum-optimism/optimism/op-program/client/l2/engineapi/test"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/consensus/beacon"
 	"github.com/ethereum/go-ethereum/core"

op-program/l2/engineapi/test/l2_engine_api_tests.go → op-program/client/l2/engineapi/test/l2_engine_api_tests.go

@@ -7,7 +7,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-node/eth"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
 	"github.com/ethereum-optimism/optimism/op-node/testlog"
-	"github.com/ethereum-optimism/optimism/op-program/l2/engineapi"
+	"github.com/ethereum-optimism/optimism/op-program/client/l2/engineapi"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/log"

op-program/cmd/main.go → op-program/host/cmd/main.go

@@ -4,13 +4,18 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"io"
 	"os"
+	"time"
 
 	"github.com/ethereum-optimism/optimism/op-node/chaincfg"
-	"github.com/ethereum-optimism/optimism/op-program/config"
-	"github.com/ethereum-optimism/optimism/op-program/flags"
-	"github.com/ethereum-optimism/optimism/op-program/l2"
-	"github.com/ethereum-optimism/optimism/op-program/version"
+	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
+	cldr "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/l1"
+	"github.com/ethereum-optimism/optimism/op-program/host/l2"
+	"github.com/ethereum-optimism/optimism/op-program/host/version"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/urfave/cli"
@@ -94,10 +99,31 @@ func FaultProofProgram(logger log.Logger, cfg *config.Config) error {
 	}
 
 	ctx := context.Background()
+	logger.Info("Connecting to L1 node", "l1", cfg.L1URL)
+	l1Source, err := l1.NewFetchingL1(ctx, logger, cfg)
+	if err != nil {
+		return fmt.Errorf("connect l1 oracle: %w", err)
+	}
+
 	logger.Info("Connecting to L2 node", "l2", cfg.L2URL)
-	_, err := l2.NewFetchingEngine(ctx, logger, cfg)
+	l2Source, err := l2.NewFetchingEngine(ctx, logger, cfg)
 	if err != nil {
 		return fmt.Errorf("connect l2 oracle: %w", err)
 	}
+
+	d := cldr.NewDriver(logger, cfg.Rollup, l1Source, l2Source)
+	for {
+		if err = d.Step(ctx); errors.Is(err, io.EOF) {
+			break
+		} else if cfg.FetchingEnabled() && errors.Is(err, derive.ErrTemporary) {
+			// When in fetching mode, recover from temporary errors to allow us to keep fetching data
+			// TODO(CLI-3780) Ideally the retry would happen in the fetcher so this is not needed
+			logger.Warn("Temporary error in pipeline", "err", err)
+			time.Sleep(5 * time.Second)
+		} else if err != nil {
+			return err
+		}
+	}
+	logger.Info("Derivation complete", "head", d.SafeHead())
 	return nil
 }

op-program/cmd/main_test.go → op-program/host/cmd/main_test.go

@@ -6,7 +6,8 @@ import (
 	"testing"
 
 	"github.com/ethereum-optimism/optimism/op-node/chaincfg"
-	"github.com/ethereum-optimism/optimism/op-program/config"
+	"github.com/ethereum-optimism/optimism/op-node/sources"
+	"github.com/ethereum-optimism/optimism/op-program/host/config"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/stretchr/testify/require"
@@ -101,6 +102,50 @@ func TestL2Head(t *testing.T) {
 	})
 }
 
+func TestL1(t *testing.T) {
+	expected := "https://example.com:8545"
+	cfg := configForArgs(t, addRequiredArgs("--l1", expected))
+	require.Equal(t, expected, cfg.L1URL)
+}
+
+func TestL1TrustRPC(t *testing.T) {
+	t.Run("DefaultFalse", func(t *testing.T) {
+		cfg := configForArgs(t, addRequiredArgs())
+		require.False(t, cfg.L1TrustRPC)
+	})
+	t.Run("Enabled", func(t *testing.T) {
+		cfg := configForArgs(t, addRequiredArgs("--l1.trustrpc"))
+		require.True(t, cfg.L1TrustRPC)
+	})
+	t.Run("EnabledWithArg", func(t *testing.T) {
+		cfg := configForArgs(t, addRequiredArgs("--l1.trustrpc=true"))
+		require.True(t, cfg.L1TrustRPC)
+	})
+	t.Run("Disabled", func(t *testing.T) {
+		cfg := configForArgs(t, addRequiredArgs("--l1.trustrpc=false"))
+		require.False(t, cfg.L1TrustRPC)
+	})
+}
+
+func TestL1RPCKind(t *testing.T) {
+	t.Run("DefaultBasic", func(t *testing.T) {
+		cfg := configForArgs(t, addRequiredArgs())
+		require.Equal(t, sources.RPCKindBasic, cfg.L1RPCKind)
+	})
+	for _, kind := range sources.RPCProviderKinds {
+		t.Run(kind.String(), func(t *testing.T) {
+			cfg := configForArgs(t, addRequiredArgs("--l1.rpckind", kind.String()))
+			require.Equal(t, kind, cfg.L1RPCKind)
+		})
+	}
+	t.Run("RequireLowercase", func(t *testing.T) {
+		verifyArgsInvalid(t, "rpc kind", addRequiredArgs("--l1.rpckind", "AlChemY"))
+	})
+	t.Run("UnknownKind", func(t *testing.T) {
+		verifyArgsInvalid(t, "\"foo\"", addRequiredArgs("--l1.rpckind", "foo"))
+	})
+}
+
 // Offline support will be added later, but for now it just bails out with an error
 func TestOfflineModeNotSupported(t *testing.T) {
 	logger := log.New()

op-program/config/config.go → op-program/host/config/config.go

@@ -5,7 +5,8 @@ import (
 
 	opnode "github.com/ethereum-optimism/optimism/op-node"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
-	"github.com/ethereum-optimism/optimism/op-program/flags"
+	"github.com/ethereum-optimism/optimism/op-node/sources"
+	"github.com/ethereum-optimism/optimism/op-program/host/flags"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/urfave/cli"
 )
@@ -14,6 +15,7 @@ var (
 	ErrMissingRollupConfig = errors.New("missing rollup config")
 	ErrMissingL2Genesis    = errors.New("missing l2 genesis")
 	ErrInvalidL2Head       = errors.New("invalid l2 head")
+	ErrL1AndL2Inconsistent = errors.New("l1 and l2 options must be specified together or both omitted")
 )
 
 type Config struct {
@@ -21,6 +23,9 @@ type Config struct {
 	L2URL         string
 	L2GenesisPath string
 	L2Head        common.Hash
+	L1URL         string
+	L1TrustRPC    bool
+	L1RPCKind     sources.RPCProviderKind
 }
 
 func (c *Config) Check() error {
@@ -36,11 +41,14 @@ func (c *Config) Check() error {
 	if c.L2Head == (common.Hash{}) {
 		return ErrInvalidL2Head
 	}
+	if (c.L1URL != "") != (c.L2URL != "") {
+		return ErrL1AndL2Inconsistent
+	}
 	return nil
 }
 
 func (c *Config) FetchingEnabled() bool {
-	return c.L2URL != ""
+	return c.L1URL != "" && c.L2URL != ""
 }
 
 // NewConfig creates a Config with all optional values set to the CLI default value
@@ -49,6 +57,7 @@ func NewConfig(rollupCfg *rollup.Config, l2GenesisPath string, l2Head common.Has
 		Rollup:        rollupCfg,
 		L2GenesisPath: l2GenesisPath,
 		L2Head:        l2Head,
+		L1RPCKind:     sources.RPCKindBasic,
 	}
 }
 
@@ -69,5 +78,8 @@ func NewConfigFromCLI(ctx *cli.Context) (*Config, error) {
 		L2URL:         ctx.GlobalString(flags.L2NodeAddr.Name),
 		L2GenesisPath: ctx.GlobalString(flags.L2GenesisPath.Name),
 		L2Head:        l2Head,
+		L1URL:         ctx.GlobalString(flags.L1NodeAddr.Name),
+		L1TrustRPC:    ctx.GlobalBool(flags.L1TrustRPC.Name),
+		L1RPCKind:     sources.RPCProviderKind(ctx.GlobalString(flags.L1RPCProviderKind.Name)),
 	}, nil
 }

op-program/config/config_test.go → op-program/host/config/config_test.go

@@ -54,6 +54,29 @@ func TestL2Head(t *testing.T) {
 	})
 }
 
+func TestFetchingArgConsistency(t *testing.T) {
+	t.Run("RequireL2WhenL1Set", func(t *testing.T) {
+		cfg := NewConfig(&chaincfg.Beta1, validL2GenesisPath, validL2Head)
+		cfg.L1URL = "https://example.com:1234"
+		require.ErrorIs(t, cfg.Check(), ErrL1AndL2Inconsistent)
+	})
+	t.Run("RequireL1WhenL2Set", func(t *testing.T) {
+		cfg := NewConfig(&chaincfg.Beta1, validL2GenesisPath, validL2Head)
+		cfg.L2URL = "https://example.com:1234"
+		require.ErrorIs(t, cfg.Check(), ErrL1AndL2Inconsistent)
+	})
+	t.Run("AllowNeitherSet", func(t *testing.T) {
+		cfg := NewConfig(&chaincfg.Beta1, validL2GenesisPath, validL2Head)
+		require.NoError(t, cfg.Check())
+	})
+	t.Run("AllowBothSet", func(t *testing.T) {
+		cfg := NewConfig(&chaincfg.Beta1, validL2GenesisPath, validL2Head)
+		cfg.L1URL = "https://example.com:1234"
+		cfg.L2URL = "https://example.com:4678"
+		require.NoError(t, cfg.Check())
+	})
+}
+
 func TestFetchingEnabled(t *testing.T) {
 	t.Run("FetchingNotEnabledWhenNoFetcherUrlsSpecified", func(t *testing.T) {
 		cfg := NewConfig(&chaincfg.Beta1, validL2GenesisPath, validL2Head)
@@ -63,6 +86,25 @@ func TestFetchingEnabled(t *testing.T) {
 	t.Run("FetchingEnabledWhenFetcherUrlsSpecified", func(t *testing.T) {
 		cfg := NewConfig(&chaincfg.Beta1, validL2GenesisPath, validL2Head)
 		cfg.L2URL = "https://example.com:1234"
+		require.False(t, cfg.FetchingEnabled(), "Should not enable fetching when node URL not supplied")
+	})
+
+	t.Run("FetchingNotEnabledWhenNoL1UrlSpecified", func(t *testing.T) {
+		cfg := NewConfig(&chaincfg.Beta1, validL2GenesisPath, validL2Head)
+		cfg.L2URL = "https://example.com:1234"
+		require.False(t, cfg.FetchingEnabled(), "Should not enable L1 fetching when L1 node URL not supplied")
+	})
+
+	t.Run("FetchingNotEnabledWhenNoL2UrlSpecified", func(t *testing.T) {
+		cfg := NewConfig(&chaincfg.Beta1, validL2GenesisPath, validL2Head)
+		cfg.L1URL = "https://example.com:1234"
+		require.False(t, cfg.FetchingEnabled(), "Should not enable L2 fetching when L2 node URL not supplied")
+	})
+
+	t.Run("FetchingEnabledWhenBothFetcherUrlsSpecified", func(t *testing.T) {
+		cfg := NewConfig(&chaincfg.Beta1, validL2GenesisPath, validL2Head)
+		cfg.L1URL = "https://example.com:1234"
+		cfg.L2URL = "https://example.com:5678"
 		require.True(t, cfg.FetchingEnabled(), "Should enable fetching when node URL supplied")
 	})
 }

op-program/flags/flags.go → op-program/host/flags/flags.go

@@ -4,10 +4,13 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/urfave/cli"
+
 	"github.com/ethereum-optimism/optimism/op-node/chaincfg"
+	nodeflags "github.com/ethereum-optimism/optimism/op-node/flags"
+	"github.com/ethereum-optimism/optimism/op-node/sources"
 	service "github.com/ethereum-optimism/optimism/op-service"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
-	"github.com/urfave/cli"
 )
 
 const envVarPrefix = "OP_PROGRAM"
@@ -38,6 +41,26 @@ var (
 		Usage:  "Hash of the agreed L2 block to start derivation from",
 		EnvVar: service.PrefixEnvVar(envVarPrefix, "L2_HEAD"),
 	}
+	L1NodeAddr = cli.StringFlag{
+		Name:   "l1",
+		Usage:  "Address of L1 JSON-RPC endpoint to use (eth namespace required)",
+		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"),
+	}
+	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"),
+		Value: func() *sources.RPCProviderKind {
+			out := sources.RPCKindBasic
+			return &out
+		}(),
+	}
 )
 
 // Flags contains the list of configuration options available to the binary.
@@ -49,6 +72,9 @@ var programFlags = []cli.Flag{
 	L2NodeAddr,
 	L2GenesisPath,
 	L2Head,
+	L1NodeAddr,
+	L1TrustRPC,
+	L1RPCProviderKind,
 }
 
 func init() {

op-program/flags/flags_test.go → op-program/host/flags/flags_test.go

@@ -4,6 +4,8 @@ import (
 	"reflect"
 	"strings"
 	"testing"
+
+	"github.com/urfave/cli"
 )
 
 // TestUniqueFlags asserts that all flag names are unique, to avoid accidental conflicts between the many flags.
@@ -19,15 +21,25 @@ func TestUniqueFlags(t *testing.T) {
 	}
 }
 
+// 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 {
-		values := reflect.ValueOf(flag)
-		envVarValue := values.FieldByName("EnvVar")
-		if envVarValue == (reflect.Value{}) {
+		envVar := envVarForFlag(flag)
+		if envVar == "" {
 			t.Errorf("Failed to find EnvVar for flag %v", flag.GetName())
-			continue
 		}
-		envVar := envVarValue.String()
 		if envVar[:len("OP_PROGRAM_")] != "OP_PROGRAM_" {
 			t.Errorf("Flag %v env var (%v) does not start with OP_PROGRAM_", flag.GetName(), envVar)
 		}
@@ -36,3 +48,12 @@ func TestCorrectEnvVarPrefix(t *testing.T) {
 		}
 	}
 }
+
+func envVarForFlag(flag cli.Flag) string {
+	values := reflect.ValueOf(flag)
+	envVarValue := values.FieldByName("EnvVar")
+	if envVarValue == (reflect.Value{}) {
+		return ""
+	}
+	return envVarValue.String()
+}

op-program/host/l1/l1.go

+package l1
+
+import (
+	"context"
+
+	"github.com/ethereum-optimism/optimism/op-node/client"
+	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
+	"github.com/ethereum-optimism/optimism/op-node/sources"
+	"github.com/ethereum-optimism/optimism/op-program/host/config"
+	"github.com/ethereum/go-ethereum/log"
+)
+
+func NewFetchingL1(ctx context.Context, logger log.Logger, cfg *config.Config) (derive.L1Fetcher, error) {
+	rpc, err := client.NewRPC(ctx, logger, cfg.L1URL)
+	if err != nil {
+		return nil, err
+	}
+
+	return sources.NewL1Client(rpc, logger, nil, sources.L1ClientDefaultConfig(cfg.Rollup, cfg.L1TrustRPC, cfg.L1RPCKind))
+}

op-program/l2/fetcher_test.go → op-program/host/l2/fetcher_test.go

@@ -10,6 +10,8 @@ import (
 	"testing"
 
 	"github.com/ethereum-optimism/optimism/op-node/testutils"
+	cll2 "github.com/ethereum-optimism/optimism/op-program/client/l2"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/rawdb"
@@ -19,7 +21,7 @@ import (
 )
 
 // Require the fetching oracle to implement StateOracle
-var _ StateOracle = (*FetchingL2Oracle)(nil)
+var _ cll2.StateOracle = (*FetchingL2Oracle)(nil)
 
 type callContextRequest struct {
 	ctx    context.Context

op-program/l2/l2.go → op-program/host/l2/l2.go

@@ -7,7 +7,8 @@ import (
 	"os"
 
 	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
-	"github.com/ethereum-optimism/optimism/op-program/config"
+	cll2 "github.com/ethereum-optimism/optimism/op-program/client/l2"
+	"github.com/ethereum-optimism/optimism/op-program/host/config"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/ethereum/go-ethereum/params"
@@ -23,11 +24,11 @@ func NewFetchingEngine(ctx context.Context, logger log.Logger, cfg *config.Confi
 		return nil, fmt.Errorf("connect l2 oracle: %w", err)
 	}
 
-	engineBackend, err := NewOracleBackedL2Chain(logger, oracle, genesis, cfg.L2Head)
+	engineBackend, err := cll2.NewOracleBackedL2Chain(logger, oracle, genesis, cfg.L2Head)
 	if err != nil {
 		return nil, fmt.Errorf("create l2 chain: %w", err)
 	}
-	return NewOracleEngine(cfg.Rollup, logger, engineBackend), nil
+	return cll2.NewOracleEngine(cfg.Rollup, logger, engineBackend), nil
 }
 
 func loadL2Genesis(cfg *config.Config) (*params.ChainConfig, error) {

op-service/txmgr/metrics/tx_metrics.go

@@ -19,7 +19,9 @@ type TxMetricer interface {
 
 type TxMetrics struct {
 	TxL1GasFee         prometheus.Gauge
+	txFees             prometheus.Counter
 	TxGasBump          prometheus.Gauge
+	txFeeHistogram     prometheus.Histogram
 	LatencyConfirmedTx prometheus.Gauge
 	currentNonce       prometheus.Gauge
 	txPublishError     *prometheus.CounterVec
@@ -49,6 +51,19 @@ func MakeTxMetrics(ns string, factory metrics.Factory) TxMetrics {
 			Help:      "L1 gas fee for transactions in GWEI",
 			Subsystem: "txmgr",
 		}),
+		txFees: factory.NewCounter(prometheus.CounterOpts{
+			Namespace: ns,
+			Name:      "tx_fee_gwei_total",
+			Help:      "Sum of fees spent for all transactions in GWEI",
+			Subsystem: "txmgr",
+		}),
+		txFeeHistogram: factory.NewHistogram(prometheus.HistogramOpts{
+			Namespace: ns,
+			Name:      "tx_fee_histogram_gwei",
+			Help:      "Tx Fee in GWEI",
+			Subsystem: "txmgr",
+			Buckets:   []float64{0.5, 1, 2, 5, 10, 20, 40, 60, 80, 100, 200, 400, 800, 1600},
+		}),
 		TxGasBump: factory.NewGauge(prometheus.GaugeOpts{
 			Namespace: ns,
 			Name:      "tx_gas_bump",
@@ -90,8 +105,12 @@ func (t *TxMetrics) RecordNonce(nonce uint64) {
 
 // TxConfirmed records lots of information about the confirmed transaction
 func (t *TxMetrics) TxConfirmed(receipt *types.Receipt) {
+	fee := float64(receipt.EffectiveGasPrice.Uint64() * receipt.GasUsed / params.GWei)
 	t.confirmEvent.Record(receiptStatusString(receipt))
-	t.TxL1GasFee.Set(float64(receipt.EffectiveGasPrice.Uint64() * receipt.GasUsed / params.GWei))
+	t.TxL1GasFee.Set(fee)
+	t.txFees.Add(fee)
+	t.txFeeHistogram.Observe(fee)
+
 }
 
 func (t *TxMetrics) RecordGasBumpCount(times int) {

packages/actor-tests/CHANGELOG.md

 # @eth-optimism/actor-tests
 
+## 0.0.24
+
+### Patch Changes
+
+- Updated dependencies [b16067a9f]
+- Updated dependencies [be3315689]
+- Updated dependencies [9a02079eb]
+- Updated dependencies [98fbe9d22]
+  - @eth-optimism/contracts-bedrock@0.13.2
+  - @eth-optimism/sdk@2.0.2
+
 ## 0.0.23
 
 ### Patch Changes

packages/actor-tests/package.json

 {
   "name": "@eth-optimism/actor-tests",
-  "version": "0.0.23",
+  "version": "0.0.24",
   "description": "A library and suite of tests to stress test Optimism Bedrock.",
   "license": "MIT",
   "author": "",
@@ -18,9 +18,9 @@
     "test:coverage": "yarn test"
   },
   "dependencies": {
-    "@eth-optimism/contracts-bedrock": "0.13.1",
+    "@eth-optimism/contracts-bedrock": "0.13.2",
     "@eth-optimism/core-utils": "^0.12.0",
-    "@eth-optimism/sdk": "^2.0.1",
+    "@eth-optimism/sdk": "^2.0.2",
     "@types/chai": "^4.2.18",
     "@types/chai-as-promised": "^7.1.4",
     "async-mutex": "^0.3.2",

packages/chain-mon/CHANGELOG.md

 # @eth-optimism/drippie-mon
 
+## 0.3.0
+
+### Minor Changes
+
+- 1e7897c81: Introduces the balance-mon service to chain-mon.
+
+### Patch Changes
+
+- dbe5eb308: Empty patch release to re-release packages that failed to be released by a bug in the release process.
+- Updated dependencies [be3315689]
+  - @eth-optimism/sdk@2.0.2
+
 ## 0.2.1
 
 ### Patch Changes

packages/chain-mon/package.json

 {
   "private": true,
   "name": "@eth-optimism/chain-mon",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "[Optimism] Chain monitoring services",
   "main": "dist/index",
   "types": "dist/index",
@@ -36,7 +36,7 @@
     "@eth-optimism/common-ts": "0.8.1",
     "@eth-optimism/contracts-periphery": "1.0.7",
     "@eth-optimism/core-utils": "0.12.0",
-    "@eth-optimism/sdk": "2.0.1",
+    "@eth-optimism/sdk": "2.0.2",
     "ethers": "^5.7.0",
     "@types/dateformat": "^5.0.0",
     "chai-as-promised": "^7.1.1",

packages/contracts-bedrock/CHANGELOG.md

 # @eth-optimism/contracts-bedrock
 
+## 0.13.2
+
+### Patch Changes
+
+- b16067a9f: Reduce the time that the system dictator deploy scripts wait before checking the chain state.
+- 9a02079eb: Makes the Proxy contract inheritable by making functions (public virtual).
+- 98fbe9d22: Added a contsructor to the System Dictator
+
 ## 0.13.1
 
 ### Patch Changes

packages/contracts-bedrock/contracts/L1/OptimismPortal.sol

@@ -78,8 +78,7 @@ contract OptimismPortal is Initializable, ResourceMetering, Semver {
 
     /**
      * @notice Determines if cross domain messaging is paused. When set to true,
-     *         deposits and withdrawals are paused. This may be removed in the
-     *         future.
+     *         withdrawals are paused. This may be removed in the future.
      */
     bool public paused;
 
@@ -141,7 +140,7 @@ contract OptimismPortal is Initializable, ResourceMetering, Semver {
     }
 
     /**
-     * @custom:semver 1.3.0
+     * @custom:semver 1.3.1
      *
      * @param _l2Oracle                  Address of the L2OutputOracle contract.
      * @param _guardian                  Address that can pause deposits and withdrawals.
@@ -153,7 +152,7 @@ contract OptimismPortal is Initializable, ResourceMetering, Semver {
         address _guardian,
         bool _paused,
         SystemConfig _config
-    ) Semver(1, 3, 0) {
+    ) Semver(1, 3, 1) {
         L2_ORACLE = _l2Oracle;
         GUARDIAN = _guardian;
         SYSTEM_CONFIG = _config;

packages/contracts-bedrock/deploy-config/local.ts

+import { DeployConfig } from '../src/deploy-config'
+
+const config: DeployConfig = {
+  finalSystemOwner: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+  controller: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+  portalGuardian: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+  proxyAdminOwner: '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266',
+
+  l1StartingBlockTag:
+    '0x126e52a0cc0ae18948f567ee9443f4a8f0db67c437706e35baee424eb314a0d0',
+  l1ChainID: 1,
+  l2ChainID: 10,
+  l2BlockTime: 2,
+
+  maxSequencerDrift: 600,
+  sequencerWindowSize: 3600,
+  channelTimeout: 300,
+
+  p2pSequencerAddress: '0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65',
+  batchInboxAddress: '0xff00000000000000000000000000000000000010',
+  batchSenderAddress: '0x70997970C51812dc3A010C7d01b50e0d17dc79C8',
+  l2OutputOracleSubmissionInterval: 20,
+  l2OutputOracleStartingTimestamp: 1679069195,
+  l2OutputOracleStartingBlockNumber: 79149704,
+  l2OutputOracleProposer: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+  l2OutputOracleChallenger: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
+  finalizationPeriodSeconds: 2,
+
+  baseFeeVaultRecipient: '0x90F79bf6EB2c4f870365E785982E1f101E93b906',
+  l1FeeVaultRecipient: '0x90F79bf6EB2c4f870365E785982E1f101E93b906',
+  sequencerFeeVaultRecipient: '0x90F79bf6EB2c4f870365E785982E1f101E93b906',
+
+  governanceTokenName: 'Optimism',
+  governanceTokenSymbol: 'OP',
+  governanceTokenOwner: '0x90F79bf6EB2c4f870365E785982E1f101E93b906',
+
+  l2GenesisBlockGasLimit: '0x17D7840',
+  l2GenesisBlockCoinbase: '0x4200000000000000000000000000000000000011',
+  l2GenesisBlockBaseFeePerGas: '0x3b9aca00',
+
+  gasPriceOracleOverhead: 2100,
+  gasPriceOracleScalar: 1000000,
+  eip1559Denominator: 50,
+  eip1559Elasticity: 10,
+
+  l2GenesisRegolithTimeOffset: '0x0',
+}
+
+export default config

packages/contracts-bedrock/deploy-config/mainnet.ts

@@ -7,6 +7,7 @@ const config: DeployConfig = {
   finalSystemOwner: '0x9BA6e03D8B90dE867373Db8cF1A58d2F7F006b3A',
   controller: '0x78339d822c23d943e4a2d4c3dd5408f66e6d662d',
   portalGuardian: '0x78339d822c23d943e4a2d4c3dd5408f66e6d662d',
+  proxyAdminOwner: '0x90F79bf6EB2c4f870365E785982E1f101E93b906',
 
   l1StartingBlockTag:
     '0x126e52a0cc0ae18948f567ee9443f4a8f0db67c437706e35baee424eb314a0d0',
@@ -28,7 +29,6 @@ const config: DeployConfig = {
   l2OutputOracleChallenger: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
   finalizationPeriodSeconds: 2,
 
-  proxyAdminOwner: '0x90F79bf6EB2c4f870365E785982E1f101E93b906',
   baseFeeVaultRecipient: '0x90F79bf6EB2c4f870365E785982E1f101E93b906',
   l1FeeVaultRecipient: '0x90F79bf6EB2c4f870365E785982E1f101E93b906',
   sequencerFeeVaultRecipient: '0x90F79bf6EB2c4f870365E785982E1f101E93b906',

packages/contracts-bedrock/deploy/020-SystemDictatorSteps-1.ts

@@ -13,6 +13,7 @@ import {
   getDeploymentAddress,
   doOwnershipTransfer,
   doPhase,
+  liveDeployer,
 } from '../src/deploy-utils'
 
 const uint128Max = ethers.BigNumber.from('0xffffffffffffffffffffffffffffffff')
@@ -66,8 +67,12 @@ const deployFn: DeployFunction = async (hre) => {
   ])
 
   // If we have the key for the controller then we don't need to wait for external txns.
-  const isLiveDeployer =
-    deployer.toLowerCase() === hre.deployConfig.controller.toLowerCase()
+  // Set the DISABLE_LIVE_DEPLOYER=true in the env to ensure the script will pause to simulate scenarios
+  // where the controller is not the deployer.
+  const isLiveDeployer = await liveDeployer({
+    hre,
+    disabled: process.env.DISABLE_LIVE_DEPLOYER,
+  })
 
   // Transfer ownership of the ProxyAdmin to the SystemDictator.
   if ((await ProxyAdmin.owner()) !== SystemDictator.address) {

packages/contracts-bedrock/deploy/021-SystemDictatorSteps-2.ts

@@ -15,6 +15,7 @@ import {
   doStep,
   printTenderlySimulationLink,
   printCastCommand,
+  liveDeployer,
 } from '../src/deploy-utils'
 
 const deployFn: DeployFunction = async (hre) => {
@@ -82,8 +83,12 @@ const deployFn: DeployFunction = async (hre) => {
   ])
 
   // If we have the key for the controller then we don't need to wait for external txns.
-  const isLiveDeployer =
-    deployer.toLowerCase() === hre.deployConfig.controller.toLowerCase()
+  // Set the DISABLE_LIVE_DEPLOYER=true in the env to ensure the script will pause to simulate scenarios
+  // where the controller is not the deployer.
+  const isLiveDeployer = await liveDeployer({
+    hre,
+    disabled: process.env.DISABLE_LIVE_DEPLOYER,
+  })
 
   // Step 3 clears out some state from the AddressManager.
   await doStep({

packages/contracts-bedrock/hardhat.config.ts

@@ -22,6 +22,14 @@ const config: HardhatUserConfig = {
     hardhat: {
       live: false,
     },
+    local: {
+      live: false,
+      url: 'http://localhost:8545',
+      saveDeployments: false,
+      accounts: [
+        'ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80',
+      ],
+    },
     // NOTE: The 'mainnet' network is currently being used for mainnet rehearsals.
     mainnet: {
       url: process.env.L1_RPC || 'https://mainnet-l1-rehearsal.optimism.io',

packages/contracts-bedrock/package.json

 {
   "name": "@eth-optimism/contracts-bedrock",
-  "version": "0.13.1",
+  "version": "0.13.2",
   "description": "Contracts for Optimism Specs",
   "main": "dist/index",
   "types": "dist/index",
@@ -59,7 +59,7 @@
     "hardhat": "^2.9.6"
   },
   "devDependencies": {
-    "@eth-optimism/hardhat-deploy-config": "^0.2.5",
+    "@eth-optimism/hardhat-deploy-config": "^0.2.6",
     "@ethersproject/abstract-provider": "^5.7.0",
     "@ethersproject/abstract-signer": "^5.7.0",
     "ethereumjs-wallet": "^1.0.2",

packages/contracts-bedrock/scripts/upgrades/PostSherlock.s.sol

@@ -77,7 +77,7 @@ contract PostSherlock is Script {
     string constant internal L1StandardBridge_Version = "1.1.0";
     string constant internal L2OutputOracle_Version = "1.2.0";
     string constant internal OptimismMintableERC20Factory_Version = "1.1.0";
-    string constant internal OptimismPortal_Version = "1.3.0";
+    string constant internal OptimismPortal_Version = "1.3.1";
     string constant internal SystemConfig_Version = "1.2.0";
     string constant internal L1ERC721Bridge_Version = "1.1.0";
 

packages/contracts-bedrock/slither.config.json

 {
-  "detectors_to_exclude": "assembly-usage,block-timestamp,naming-convention,solc-version,low-level-calls",
+  "detectors_to_exclude": "assembly-usage,block-timestamp,naming-convention,solc-version,low-level-calls,boolean-equality",
   "exclude_informational": true,
   "exclude_low": true,
   "exclude_medium": true,

packages/contracts-bedrock/src/deploy-utils.ts

@@ -355,6 +355,28 @@ export const doOwnershipTransfer = async (opts: {
   }
 }
 
+/**
+ * Check if the script should submit the transaction or wait for the deployer to do it manually.
+ *
+ * @param hre HardhatRuntimeEnvironment.
+ * @param ovveride Allow m
+ * @returns True if the current step is the target step.
+ */
+export const liveDeployer = async (opts: {
+  hre: HardhatRuntimeEnvironment
+  disabled: string | undefined
+}): Promise<boolean> => {
+  let ret: boolean
+  if (!!opts.disabled) {
+    ret = false
+  }
+  const { deployer } = await opts.hre.getNamedAccounts()
+  ret =
+    deployer.toLowerCase() === opts.hre.deployConfig.controller.toLowerCase()
+  console.log('Setting live deployer to', ret)
+  return ret
+}
+
 /**
  * Mini helper for checking if the current step is a target step.
  *

packages/contracts-periphery/package.json

@@ -53,9 +53,9 @@
     "url": "https://github.com/ethereum-optimism/optimism.git"
   },
   "devDependencies": {
-    "@eth-optimism/contracts-bedrock": "0.13.1",
+    "@eth-optimism/contracts-bedrock": "0.13.2",
     "@eth-optimism/core-utils": "^0.12.0",
-    "@eth-optimism/hardhat-deploy-config": "^0.2.5",
+    "@eth-optimism/hardhat-deploy-config": "^0.2.6",
     "@ethersproject/hardware-wallets": "^5.7.0",
     "@nomiclabs/hardhat-ethers": "^2.0.2",
     "@nomiclabs/hardhat-etherscan": "^3.0.3",

packages/core-utils/package.json

@@ -15,8 +15,8 @@
     "lint:check": "eslint . --max-warnings=0",
     "lint:fix": "yarn lint:check --fix",
     "pre-commit": "lint-staged",
-    "test": "ts-mocha test/*.spec.ts",
-    "test:coverage": "nyc ts-mocha test/*.spec.ts && nyc merge .nyc_output coverage.json"
+    "test": "ts-mocha test/**/*.spec.ts",
+    "test:coverage": "nyc ts-mocha test/**/*.spec.ts && nyc merge .nyc_output coverage.json"
   },
   "keywords": [
     "optimism",

packages/core-utils/test/hex-utils.spec.ts → packages/core-utils/test/common/hex-strings.spec.ts

 import { BigNumber } from '@ethersproject/bignumber'
 
 /* Imports: Internal */
-import { expect } from './setup'
+import { expect } from '../setup'
 import {
   toRpcHexString,
   remove0x,
@@ -12,7 +12,7 @@ import {
   encodeHex,
   hexStringEquals,
   bytes32ify,
-} from '../src'
+} from '../../src'
 
 describe('remove0x', () => {
   it('should return undefined', () => {
@@ -62,6 +62,7 @@ describe('toHexString', () => {
       'The first argument must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object. Received null'
     )
   })
+
   it('should return with a hex string', () => {
     const cases = [
       { input: 0, output: '0x00' },
@@ -104,6 +105,7 @@ describe('padHexString', () => {
     expect(padHexString('abcd', 1)).to.deep.equal('abcd')
     expect(padHexString('abcdefgh', 3).length).to.deep.equal(8)
   })
+
   it('should return a string padded with 0x and zeros', () => {
     expect(padHexString('0xabcd', 3)).to.deep.equal('0x00abcd')
   })

packages/core-utils/test/misc.spec.ts → packages/core-utils/test/common/misc.spec.ts

 /* Imports: Internal */
-import { expect } from './setup'
-import { sleep, clone, reqenv, getenv } from '../src'
+import { expect } from '../setup'
+import { sleep, clone, reqenv, getenv } from '../../src'
 
 describe('sleep', async () => {
   it('should return wait input amount of ms', async () => {
@@ -21,7 +21,7 @@ describe('clone', async () => {
 })
 
 describe('reqenv', async () => {
-  let cachedEnvironment
+  let cachedEnvironment: NodeJS.ProcessEnv
   const temporaryEnvironmentKey = 'testVariable'
   const temporaryEnvironment = {
     [temporaryEnvironmentKey]: 'This is an environment variable',
@@ -51,7 +51,7 @@ describe('reqenv', async () => {
 })
 
 describe('getenv', async () => {
-  let cachedEnvironment
+  let cachedEnvironment: NodeJS.ProcessEnv
   const temporaryEnvironmentKey = 'testVariable'
   const temporaryEnvironment = {
     [temporaryEnvironmentKey]: 'This is an environment variable',

packages/core-utils/test/test-utils.spec.ts → packages/core-utils/test/common/test-utils.spec.ts

 import { assert } from 'chai'
 
 /* Imports: Internal */
-import { expect } from './setup'
-import { expectApprox, awaitCondition } from '../src'
+import { expect } from '../setup'
+import { expectApprox, awaitCondition } from '../../src'
 
 describe('awaitCondition', () => {
   it('should try the condition fn until it returns true', async () => {
@@ -42,6 +42,7 @@ describe('expectApprox', () => {
       absoluteLowerDeviation: 20,
     })
   })
+
   it('should pass when the actual number is lower, but within the expected range of the target', async () => {
     expectApprox(81, 100, {
       percentUpperDeviation: 20,
@@ -50,6 +51,7 @@ describe('expectApprox', () => {
       absoluteLowerDeviation: 20,
     })
   })
+
   it('should throw an error when no deviation values are given', async () => {
     try {
       expectApprox(101, 100, {})
@@ -75,6 +77,7 @@ describe('expectApprox', () => {
           )
         }
       })
+
       it('... and absoluteUpperDeviation sets the upper bound', async () => {
         try {
           expectApprox(121, 100, {
@@ -88,6 +91,7 @@ describe('expectApprox', () => {
         }
       })
     })
+
     describe('... when both values are defined', () => {
       it('... and percentUpperDeviation sets the upper bound', async () => {
         try {
@@ -102,6 +106,7 @@ describe('expectApprox', () => {
           )
         }
       })
+
       it('... and absoluteUpperDeviation sets the upper bound', async () => {
         try {
           expectApprox(121, 100, {

packages/core-utils/test/alias.spec.ts → packages/core-utils/test/optimism/alias.spec.ts

-import { expect } from './setup'
-import { applyL1ToL2Alias, undoL1ToL2Alias } from '../src'
+import { expect } from '../setup'
+import { applyL1ToL2Alias, undoL1ToL2Alias } from '../../src'
 
 describe('address aliasing utils', () => {
   describe('applyL1ToL2Alias', () => {

packages/core-utils/test/batch-encoder.spec.ts → packages/core-utils/test/optimism/batch-encoding.spec.ts

-import './setup'
+import '../setup'
 
 /* Internal Imports */
 import { expect } from 'chai'
@@ -9,13 +9,13 @@ import {
   sequencerBatch,
   BatchType,
   SequencerBatch,
-} from '../src'
+} from '../../src'
 
 describe('BatchEncoder', function () {
   this.timeout(10_000)
 
   // eslint-disable-next-line @typescript-eslint/no-var-requires
-  const data = require('./fixtures/calldata.json')
+  const data = require('../fixtures/calldata.json')
 
   describe('appendSequencerBatch', () => {
     it('legacy: should work with the simple case', () => {
@@ -112,6 +112,7 @@ describe('BatchEncoder', function () {
         ],
         transactions: ['0x454234000000112', '0x45423400000012'],
       }
+
       expect(() => encodeAppendSequencerBatch(batch)).to.throw(
         'Unexpected uneven hex string value!'
       )

packages/core-utils/test/fees.spec.ts → packages/core-utils/test/optimism/fees.spec.ts

-import './setup'
+import '../setup'
 
 import { BigNumber } from '@ethersproject/bignumber'
 
-import { zeroesAndOnes, calldataCost } from '../src'
+import { zeroesAndOnes, calldataCost } from '../../src'
 
 describe('Fees', () => {
   it('should count zeros and ones', () => {

packages/data-transport-layer/CHANGELOG.md

 # data transport layer
 
+## 0.5.55
+
+### Patch Changes
+
+- b33208a8f: Add better logging to DTL about shutoff block
+- dbe5eb308: Empty patch release to re-release packages that failed to be released by a bug in the release process.
+
 ## 0.5.54
 
 ### Patch Changes

packages/data-transport-layer/package.json

 {
   "private": true,
   "name": "@eth-optimism/data-transport-layer",
-  "version": "0.5.54",
+  "version": "0.5.55",
   "description": "[Optimism] Service for shuttling data from L1 into L2",
   "main": "dist/index",
   "types": "dist/index",

packages/fault-detector/CHANGELOG.md

 # @eth-optimism/fault-detector
 
+## 0.6.3
+
+### Patch Changes
+
+- dbe5eb308: Empty patch release to re-release packages that failed to be released by a bug in the release process.
+- Updated dependencies [be3315689]
+  - @eth-optimism/sdk@2.0.2
+
 ## 0.6.2
 
 ### Patch Changes

packages/fault-detector/package.json

 {
   "private": true,
   "name": "@eth-optimism/fault-detector",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "[Optimism] Service for detecting faulty L2 output proposals",
   "main": "dist/index",
   "types": "dist/index",
@@ -50,7 +50,7 @@
     "@eth-optimism/common-ts": "^0.8.1",
     "@eth-optimism/contracts": "^0.5.40",
     "@eth-optimism/core-utils": "^0.12.0",
-    "@eth-optimism/sdk": "^2.0.1",
+    "@eth-optimism/sdk": "^2.0.2",
     "@ethersproject/abstract-provider": "^5.7.0"
   }
 }

packages/hardhat-deploy-config/CHANGELOG.md

 # @eth-optimism/hardhat-deploy-config
 
+## 0.2.6
+
+### Patch Changes
+
+- 5cf646bab: Add getter for other network's deploy config
+
 ## 0.2.5
 
 ### Patch Changes

packages/hardhat-deploy-config/package.json

 {
   "name": "@eth-optimism/hardhat-deploy-config",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "[Optimism] Hardhat deploy configuration plugin",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",

packages/message-relayer/CHANGELOG.md

 # @eth-optimism/message-relayer
 
+## 0.5.33
+
+### Patch Changes
+
+- dbe5eb308: Empty patch release to re-release packages that failed to be released by a bug in the release process.
+- Updated dependencies [be3315689]
+  - @eth-optimism/sdk@2.0.2
+
 ## 0.5.32
 
 ### Patch Changes

packages/message-relayer/package.json

 {
   "private": true,
   "name": "@eth-optimism/message-relayer",
-  "version": "0.5.32",
+  "version": "0.5.33",
   "description": "[Optimism] Service for automatically relaying L2 to L1 transactions",
   "main": "dist/index",
   "types": "dist/index",
@@ -33,7 +33,7 @@
   "dependencies": {
     "@eth-optimism/common-ts": "0.8.1",
     "@eth-optimism/core-utils": "0.12.0",
-    "@eth-optimism/sdk": "2.0.1",
+    "@eth-optimism/sdk": "2.0.2",
     "ethers": "^5.7.0"
   },
   "devDependencies": {

packages/replica-healthcheck/CHANGELOG.md

 # @eth-optimism/replica-healthcheck
 
+## 1.2.4
+
+### Patch Changes
+
+- dbe5eb308: Empty patch release to re-release packages that failed to be released by a bug in the release process.
+
 ## 1.2.3
 
 ### Patch Changes

packages/replica-healthcheck/package.json

 {
   "private": true,
   "name": "@eth-optimism/replica-healthcheck",
-  "version": "1.2.3",
+  "version": "1.2.4",
   "description": "[Optimism] Service for monitoring the health of replica nodes",
   "main": "dist/index",
   "types": "dist/index",

packages/sdk/CHANGELOG.md

 # @eth-optimism/sdk
 
+## 2.0.2
+
+### Patch Changes
+
+- be3315689: Have SDK automatically create Standard and ETH bridges when L1StandardBridge is provided.
+- Updated dependencies [b16067a9f]
+- Updated dependencies [9a02079eb]
+- Updated dependencies [98fbe9d22]
+  - @eth-optimism/contracts-bedrock@0.13.2
+
 ## 2.0.1
 
 ### Patch Changes

packages/sdk/package.json

 {
   "name": "@eth-optimism/sdk",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "[Optimism] Tools for working with Optimism",
   "main": "dist/index",
   "types": "dist/index",
@@ -50,7 +50,7 @@
   "dependencies": {
     "@eth-optimism/contracts": "0.5.40",
     "@eth-optimism/core-utils": "0.12.0",
-    "@eth-optimism/contracts-bedrock": "0.13.1",
+    "@eth-optimism/contracts-bedrock": "0.13.2",
     "lodash": "^4.17.21",
     "merkletreejs": "^0.2.27",
     "rlp": "^2.2.7"

specs/challenger.md

@@ -43,7 +43,7 @@ The Challenger agent is expected to be able to listen for and respond to several
 on the data availability layer. These events and responses are parameterized depending on the type
 of dispute game being played, and the Challenger listens to different events and responds uniquely
 to each of the different game types. For specification of dispute game types, see the
-[Dispute Game Interfaces specification](./dispute-game-interfaces.md) and
+[Dispute Game Interfaces specification](./dispute-game-interface.md) and
 [Dispute Game specification](./dispute-game.md).
 
 ### `GameType.FAULT`

specs/deposits.md

@@ -118,8 +118,9 @@ Although we define only one new transaction type, we can distinguish between two
 transactions, based on their positioning in the L2 block:
 
 1. The first transaction MUST be a [L1 attributes deposited transaction][l1-attr-deposit], followed by
-2. an array of zero-or-more [user-deposited transactions][user-deposited] submitted to the deposit
-   feed contract on L1. User-deposited transactions are only present in the first block of a L2 epoch.
+2. an array of zero-or-more [user-deposited transactions][user-deposited]
+   submitted to the deposit feed contract on L1 (called `OptimismPortal`).
+   User-deposited transactions are only present in the first block of a L2 epoch.
 
 We only define a single new transaction type in order to minimize modifications to L1 client
 software, and complexity in general.
@@ -288,8 +289,8 @@ The predeploy stores the following values:
   and reset to 0 at the start of a new epoch.
 - System configurables tied to the L1 block, see [System configuration specification](./system_config.md):
   - `batcherHash` (`bytes32`): A versioned commitment to the batch-submitter(s) currently operating.
-  - `l1FeeOverhead` (`uint256`): The L1 fee overhead to apply to L1 cost computation of transactions in this L2 block.
-  - `l1FeeScalar` (`uint256`): The L1 fee scalar to apply to L1 cost computation of transactions in this L2 block.
+  - `overhead` (`uint256`): The L1 fee overhead to apply to L1 cost computation of transactions in this L2 block.
+  - `scalar` (`uint256`): The L1 fee scalar to apply to L1 cost computation of transactions in this L2 block.
 
 The contract implements an authorization scheme, such that it only accepts state-changing calls from
 the [depositor account][depositor-account].
@@ -320,8 +321,8 @@ generated by the [L2 Chain Derivation][g-derivation] process. The content of eac
 transaction are determined by the corresponding `TransactionDeposited` event emitted by the
 [deposit contract][deposit-contract] on L1.
 
-1. `from` is unchanged from the emitted value (though it may have been transformed to an alias in
-   the deposit feed contract).
+1. `from` is unchanged from the emitted value (though it may
+   have been transformed to an alias in `OptimismPortal`, the deposit feed contract).
 2. `to` is any 20-byte address (including the zero address)
     - In case of a contract creation (cf. `isCreation`), this address is set to `null`.
 3. `mint` is set to the emitted value.

specs/guaranteed-gas-market.md

@@ -93,7 +93,7 @@ def clamp(v: i256, min: u128, max: u128) -> u128:
 if prev_num == now_num:
     now_basefee = prev_basefee
     now_bought_gas = prev_bought_gas + requested_gas
-elif prev_num != now_num :
+elif prev_num != now_num:
     # Width extension and conversion to signed integer math
     gas_used_delta = int128(prev_bought_gas) - int128(TARGET_RESOURCE_LIMIT)
     # Use truncating (round to 0) division - solidity's default.
@@ -101,18 +101,18 @@ elif prev_num != now_num :
     base_fee_per_gas_delta = prev_basefee * gas_used_delta / TARGET_RESOURCE_LIMIT / BASE_FEE_MAX_CHANGE_DENOMINATOR
     now_basefee_wide = prev_basefee + base_fee_per_gas_delta
 
-    now_basefee = clamp(now_basefee_wide, min=MINIMUM_BASEFEE, max=UINT_64_MAX_VALUE)
+    now_basefee = clamp(now_basefee_wide, min=MINIMUM_BASEFEE, max=UINT_128_MAX_VALUE)
     now_bought_gas =  requested_gas
 
-# If we skipped multiple blocks between the previous block and now update the basefee again.
-# This is not exactly the same as iterating the above function, but quite close for reasonable
-# gas target values. It is also constant time wrt the number of missed blocks which is important
-# for keeping gas usage stable.
-if prev_num + 1 < now_num:
-    n = now_num - prev_num - 1
-    # Apply 7/8 reduction to prev_basefee for the n empty blocks in a row.
-    now_basefee_wide = prev_basefee * pow(1-(1/BASE_FEE_MAX_CHANGE_DENOMINATOR), n)
-    now_basefee = clamp(now_basefee_wide, min=MINIMUM_BASEFEE, max=UINT_64_MAX_VALUE)
+    # If we skipped multiple blocks between the previous block and now update the basefee again.
+    # This is not exactly the same as iterating the above function, but quite close for reasonable
+    # gas target values. It is also constant time wrt the number of missed blocks which is important
+    # for keeping gas usage stable.
+    if prev_num + 1 < now_num:
+        n = now_num - prev_num - 1
+        # Apply 7/8 reduction to prev_basefee for the n empty blocks in a row.
+        now_basefee_wide = now_basefee * pow(1-(1/BASE_FEE_MAX_CHANGE_DENOMINATOR), n)
+        now_basefee = clamp(now_basefee_wide, min=MINIMUM_BASEFEE, max=type(uint128).max)
 
 require(now_bought_gas < MAX_RESOURCE_LIMIT)
 

specs/system_config.md

@@ -6,7 +6,7 @@
 
 - [System config contents (version 0)](#system-config-contents-version-0)
   - [`batcherHash` (`bytes32`)](#batcherhash-bytes32)
-  - [`l1FeeOverhead` and `l1FeeScalar` (`uint256,uint256`)](#l1feeoverhead-and-l1feescalar-uint256uint256)
+  - [`overhead` and `scalar` (`uint256,uint256`)](#overhead-and-scalar-uint256uint256)
   - [`gasLimit` (`uint64`)](#gaslimit-uint64)
   - [`unsafeBlockSigner` (`address`)](#unsafeblocksigner-address)
 - [Writing the system config](#writing-the-system-config)
@@ -31,7 +31,7 @@ Version `0` embeds the current batch submitter ethereum address (`bytes20`) in t
 In the future this versioned hash may become a commitment to a more extensive configuration,
 to enable more extensive redundancy and/or rotation configurations.
 
-### `l1FeeOverhead` and `l1FeeScalar` (`uint256,uint256`)
+### `overhead` and `scalar` (`uint256,uint256`)
 
 The L1 fee parameters, also known as Gas Price Oracle (GPO) parameters,
 are updated in conjunction and apply new L1 costs to the L2 transactions.
@@ -70,7 +70,7 @@ A rollup node initializes its derivation process by finding a starting point bas
 - When started from L2 genesis, the initial system configuration is retrieved from the rollup chain configuration.
 - When started from an existing L2 chain, a previously included L1 block is determined as derivation starting point,
   and the system config can thus be retrieved from the last L2 block that referenced the L1 block as L1 origin:
-  - `batcherHash`, `l1FeeOverhead` and `l1FeeScalar` are retrieved from the L1 block info transaction.
+  - `batcherHash`, `overhead` and `scalar` are retrieved from the L1 block info transaction.
   - `gasLimit` is retrieved from the L2 block header.
   - other future variables may also be retrieved from other contents of the L2 block, such as the header.
 
@@ -86,8 +86,9 @@ The contained log events are filtered and processed as follows:
 - the remaining event data is opaque, encoded as ABI bytes (i.e. includes offset and length data),
   and encodes the configuration update. In version `0` the following types are supported:
   - type `0`: `batcherHash` overwrite, as `bytes32` payload.
-  - type `1`: `l1FeeOverhead` and `l1FeeScalar` overwrite, as two packed `uint256` entries.
+  - type `1`: `overhead` and `scalar` overwrite, as two packed `uint256` entries.
   - type `2`: `gasLimit` overwrite, as `uint64` payload.
+  - type `3`: `unsafeBlockSigner` overwrite, as `address` payload.
 
 Note that individual derivation stages may be processing different L1 blocks,
 and should thus maintain individual system configuration copies,