Merge branch 'develop' into sequencer-stop-start

.changeset/tough-avocados-dance.md

+---
+'@eth-optimism/contracts-bedrock': patch
+---
+
+Added a test for large deposit gaps

.github/CODEOWNERS

@@ -26,6 +26,7 @@
 /op-chain-ops   @ethereum-optimism/go-reviewers
 /op-e2e         @ethereum-optimism/go-reviewers
 /op-node        @ethereum-optimism/go-reviewers
+/op-node/rollup @protolambda @trianglesphere
 /op-proposer    @ethereum-optimism/go-reviewers
 /op-service     @ethereum-optimism/go-reviewers
 

CONTRIBUTING.md

@@ -8,7 +8,7 @@ There are plenty of ways to contribute, in particular we appreciate support in t
 - Fixing and responding to existing issues. You can start off with those tagged ["good first issue"](https://github.com/ethereum-optimism/optimism/contribute) which are meant as introductory issues for external contributors.
 - Improving the [community site](https://community.optimism.io/), [documentation](https://github.com/ethereum-optimism/community-hub) and [tutorials](https://github.com/ethereum-optimism/optimism-tutorial).
 - Become an "Optimizer" and answer questions in the [Optimism Discord](https://discord.optimism.io).
-- Get involved in the protocol design process by proposing changes or new features or write parts of the spec yourself in the [optimistic-specs repo](https://github.com/ethereum-optimism/optimistic-specs).
+- Get involved in the protocol design process by proposing changes or new features or write parts of the spec yourself in the [specs subdirectory](./specs/).
 
 Note that we have a [Code of Conduct](https://github.com/ethereum-optimism/.github/blob/master/CODE_OF_CONDUCT.md), please follow it in all your interactions with the project.
 

op-batcher/batcher/driver.go

@@ -163,7 +163,7 @@ func NewBatchSubmitterWithSigner(cfg Config, addr common.Address, signer SignerF
 		done:  make(chan struct{}),
 		log:   l,
 		state: NewChannelManager(l, cfg.ChannelTimeout),
-		// TODO: this context only exists because the even loop doesn't reach done
+		// TODO: this context only exists because the event loop doesn't reach done
 		// if the tx manager is blocking forever due to e.g. insufficient balance.
 		ctx:    ctx,
 		cancel: cancel,

op-chain-ops/crossdomain/message.go

@@ -14,12 +14,12 @@ import (
 // version 1 messages have a value and the most significant
 // byte of the nonce is a 1
 type CrossDomainMessage struct {
-	Nonce    *big.Int
-	Sender   *common.Address
-	Target   *common.Address
-	Value    *big.Int
-	GasLimit *big.Int
-	Data     []byte
+	Nonce    *big.Int        `json:"nonce"`
+	Sender   *common.Address `json:"sender"`
+	Target   *common.Address `json:"target"`
+	Value    *big.Int        `json:"value"`
+	GasLimit *big.Int        `json:"gasLimit"`
+	Data     []byte          `json:"data"`
 }
 
 // NewCrossDomainMessage creates a CrossDomainMessage.

op-chain-ops/crossdomain/migrate.go

@@ -76,7 +76,7 @@ func MigrateWithdrawal(withdrawal *LegacyWithdrawal, l1CrossDomainMessenger *com
 		withdrawal.Target,
 		value,
 		new(big.Int),
-		withdrawal.Data,
+		[]byte(withdrawal.Data),
 	)
 	if err != nil {
 		return nil, fmt.Errorf("cannot abi encode relayMessage: %w", err)

op-chain-ops/crossdomain/withdrawal.go

@@ -2,11 +2,13 @@ package crossdomain
 
 import (
 	"errors"
+	"fmt"
 	"math/big"
 
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/crypto"
 )
 
@@ -28,7 +30,7 @@ type Withdrawal struct {
 	Target   *common.Address `json:"target"`
 	Value    *big.Int        `json:"value"`
 	GasLimit *big.Int        `json:"gasLimit"`
-	Data     []byte          `json:"data"`
+	Data     hexutil.Bytes   `json:"data"`
 }
 
 // NewWithdrawal will create a Withdrawal
@@ -44,7 +46,7 @@ func NewWithdrawal(
 		Target:   target,
 		Value:    value,
 		GasLimit: gasLimit,
-		Data:     data,
+		Data:     hexutil.Bytes(data),
 	}
 }
 
@@ -58,9 +60,9 @@ func (w *Withdrawal) Encode() ([]byte, error) {
 		{Name: "gasLimit", Type: Uint256Type},
 		{Name: "data", Type: BytesType},
 	}
-	enc, err := args.Pack(w.Nonce, w.Sender, w.Target, w.Value, w.GasLimit, w.Data)
+	enc, err := args.Pack(w.Nonce, w.Sender, w.Target, w.Value, w.GasLimit, []byte(w.Data))
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("cannot encode withdrawal: %w", err)
 	}
 	return enc, nil
 }
@@ -110,7 +112,7 @@ func (w *Withdrawal) Decode(data []byte) error {
 	w.Target = &target
 	w.Value = value
 	w.GasLimit = gasLimit
-	w.Data = msgData
+	w.Data = hexutil.Bytes(msgData)
 	return nil
 }
 
@@ -150,6 +152,6 @@ func (w *Withdrawal) WithdrawalTransaction() bindings.TypesWithdrawalTransaction
 		Target:   *w.Target,
 		Value:    w.Value,
 		GasLimit: w.GasLimit,
-		Data:     w.Data,
+		Data:     []byte(w.Data),
 	}
 }

op-e2e/actions/l2_sequencer.go

@@ -26,9 +26,10 @@ type L2Sequencer struct {
 
 func NewL2Sequencer(t Testing, log log.Logger, l1 derive.L1Fetcher, eng L2API, cfg *rollup.Config, seqConfDepth uint64) *L2Sequencer {
 	ver := NewL2Verifier(t, log, l1, eng, cfg)
+	attrBuilder := derive.NewFetchingAttributesBuilder(cfg, l1, eng)
 	return &L2Sequencer{
 		L2Verifier:              *ver,
-		sequencer:               driver.NewSequencer(log, cfg, l1, eng, ver.derivation, metrics.NoopMetrics),
+		sequencer:               driver.NewSequencer(log, cfg, eng, ver.derivation, attrBuilder, metrics.NoopMetrics),
 		l1OriginSelector:        driver.NewL1OriginSelector(log, cfg, l1, seqConfDepth),
 		seqOldOrigin:            false,
 		failL2GossipUnsafeBlock: nil,

op-node/cmd/doc/cmd.go

+package doc
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/ethereum-optimism/optimism/op-node/metrics"
+	"github.com/olekukonko/tablewriter"
+	"github.com/urfave/cli"
+)
+
+var Subcommands = cli.Commands{
+	{
+		Name:  "metrics",
+		Usage: "Dumps a list of supported metrics to stdout",
+		Flags: []cli.Flag{
+			cli.StringFlag{
+				Name:  "format",
+				Value: "markdown",
+				Usage: "Output format (json|markdown)",
+			},
+		},
+		Action: func(ctx *cli.Context) error {
+			m := metrics.NewMetrics("default")
+			supportedMetrics := m.Document()
+			format := ctx.String("format")
+
+			if format != "markdown" && format != "json" {
+				return fmt.Errorf("invalid format: %s", format)
+			}
+
+			if format == "json" {
+				enc := json.NewEncoder(os.Stdout)
+				return enc.Encode(supportedMetrics)
+			}
+
+			table := tablewriter.NewWriter(os.Stdout)
+			table.SetBorders(tablewriter.Border{Left: true, Top: false, Right: true, Bottom: false})
+			table.SetCenterSeparator("|")
+			table.SetAutoWrapText(false)
+			table.SetHeader([]string{"Metric", "Description", "Labels", "Type"})
+			var data [][]string
+			for _, metric := range supportedMetrics {
+				labels := strings.Join(metric.Labels, ",")
+				data = append(data, []string{metric.Name, metric.Help, labels, metric.Type})
+			}
+			table.AppendBulk(data)
+			table.Render()
+			return nil
+		},
+	},
+}

op-node/cmd/main.go

@@ -9,6 +9,8 @@ import (
 	"syscall"
 	"time"
 
+	"github.com/ethereum-optimism/optimism/op-node/cmd/doc"
+
 	"github.com/urfave/cli"
 
 	opnode "github.com/ethereum-optimism/optimism/op-node"
@@ -68,6 +70,10 @@ func main() {
 			Name:        "genesis",
 			Subcommands: genesis.Subcommands,
 		},
+		{
+			Name:        "doc",
+			Subcommands: doc.Subcommands,
+		},
 	}
 
 	err := app.Run(os.Args)

op-node/go.mod

@@ -23,6 +23,7 @@ require (
 	github.com/libp2p/go-libp2p-testing v0.12.0
 	github.com/multiformats/go-multiaddr v0.7.0
 	github.com/multiformats/go-multiaddr-dns v0.3.1
+	github.com/olekukonko/tablewriter v0.0.5
 	github.com/prometheus/client_golang v1.13.0
 	github.com/stretchr/testify v1.8.1
 	github.com/urfave/cli v1.22.9
@@ -115,7 +116,6 @@ require (
 	github.com/multiformats/go-multistream v0.3.3 // indirect
 	github.com/multiformats/go-varint v0.0.6 // indirect
 	github.com/nxadm/tail v1.4.8 // indirect
-	github.com/olekukonko/tablewriter v0.0.5 // indirect
 	github.com/onsi/ginkgo v1.16.5 // indirect
 	github.com/opencontainers/runtime-spec v1.0.2 // indirect
 	github.com/opentracing/opentracing-go v1.2.0 // indirect

op-node/metrics/caching.go

 package metrics
 
 import (
+	"github.com/ethereum-optimism/optimism/op-service/metrics"
 	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promauto"
 )
 
 // CacheMetrics implements the Metrics interface in the caching package,
@@ -34,16 +34,16 @@ func (m *CacheMetrics) CacheGet(typeLabel string, hit bool) {
 	}
 }
 
-func NewCacheMetrics(registry prometheus.Registerer, ns string, name string, displayName string) *CacheMetrics {
+func NewCacheMetrics(factory metrics.Factory, ns string, name string, displayName string) *CacheMetrics {
 	return &CacheMetrics{
-		SizeVec: promauto.With(registry).NewGaugeVec(prometheus.GaugeOpts{
+		SizeVec: factory.NewGaugeVec(prometheus.GaugeOpts{
 			Namespace: ns,
 			Name:      name + "_size",
 			Help:      displayName + " cache size",
 		}, []string{
 			"type",
 		}),
-		GetVec: promauto.With(registry).NewCounterVec(prometheus.CounterOpts{
+		GetVec: factory.NewCounterVec(prometheus.CounterOpts{
 			Namespace: ns,
 			Name:      name + "_get",
 			Help:      displayName + " lookups, hitting or not",
@@ -51,7 +51,7 @@ func NewCacheMetrics(registry prometheus.Registerer, ns string, name string, dis
 			"type",
 			"hit",
 		}),
-		AddVec: promauto.With(registry).NewCounterVec(prometheus.CounterOpts{
+		AddVec: factory.NewCounterVec(prometheus.CounterOpts{
 			Namespace: ns,
 			Name:      name + "_add",
 			Help:      displayName + " additions, evicting previous values or not",

op-node/metrics/events.go

@@ -4,8 +4,9 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/ethereum-optimism/optimism/op-service/metrics"
+
 	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promauto"
 )
 
 type EventMetrics struct {
@@ -18,14 +19,14 @@ func (e *EventMetrics) RecordEvent() {
 	e.LastTime.Set(float64(time.Now().Unix()))
 }
 
-func NewEventMetrics(registry prometheus.Registerer, ns string, name string, displayName string) *EventMetrics {
+func NewEventMetrics(factory metrics.Factory, ns string, name string, displayName string) *EventMetrics {
 	return &EventMetrics{
-		Total: promauto.With(registry).NewCounter(prometheus.CounterOpts{
+		Total: factory.NewCounter(prometheus.CounterOpts{
 			Namespace: ns,
 			Name:      fmt.Sprintf("%s_total", name),
 			Help:      fmt.Sprintf("Count of %s events", displayName),
 		}),
-		LastTime: promauto.With(registry).NewGauge(prometheus.GaugeOpts{
+		LastTime: factory.NewGauge(prometheus.GaugeOpts{
 			Namespace: ns,
 			Name:      fmt.Sprintf("last_%s_unix", name),
 			Help:      fmt.Sprintf("Timestamp of last %s event", displayName),

op-node/metrics/metrics.go

@@ -10,11 +10,12 @@ import (
 	"strconv"
 	"time"
 
+	"github.com/ethereum-optimism/optimism/op-service/metrics"
+
 	pb "github.com/libp2p/go-libp2p-pubsub/pb"
 	libp2pmetrics "github.com/libp2p/go-libp2p/core/metrics"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/collectors"
-	"github.com/prometheus/client_golang/prometheus/promauto"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 
 	"github.com/ethereum/go-ethereum"
@@ -59,6 +60,7 @@ type Metricer interface {
 	RecordBandwidth(ctx context.Context, bwc *libp2pmetrics.BandwidthCounter)
 	RecordSequencerBuildingDiffTime(duration time.Duration)
 	RecordSequencerSealingTime(duration time.Duration)
+	Document() []metrics.DocumentedMetric
 }
 
 type Metrics struct {
@@ -111,6 +113,7 @@ type Metrics struct {
 	BandwidthTotal    *prometheus.GaugeVec
 
 	registry *prometheus.Registry
+	factory  metrics.Factory
 }
 
 var _ Metricer = (*Metrics)(nil)
@@ -124,21 +127,22 @@ func NewMetrics(procName string) *Metrics {
 	registry := prometheus.NewRegistry()
 	registry.MustRegister(collectors.NewProcessCollector(collectors.ProcessCollectorOpts{}))
 	registry.MustRegister(collectors.NewGoCollector())
+	factory := metrics.With(registry)
 	return &Metrics{
-		Info: promauto.With(registry).NewGaugeVec(prometheus.GaugeOpts{
+		Info: factory.NewGaugeVec(prometheus.GaugeOpts{
 			Namespace: ns,
 			Name:      "info",
 			Help:      "Pseudo-metric tracking version and config info",
 		}, []string{
 			"version",
 		}),
-		Up: promauto.With(registry).NewGauge(prometheus.GaugeOpts{
+		Up: factory.NewGauge(prometheus.GaugeOpts{
 			Namespace: ns,
 			Name:      "up",
 			Help:      "1 if the op node has finished starting up",
 		}),
 
-		RPCServerRequestsTotal: promauto.With(registry).NewCounterVec(prometheus.CounterOpts{
+		RPCServerRequestsTotal: factory.NewCounterVec(prometheus.CounterOpts{
 			Namespace: ns,
 			Subsystem: RPCServerSubsystem,
 			Name:      "requests_total",
@@ -146,7 +150,7 @@ func NewMetrics(procName string) *Metrics {
 		}, []string{
 			"method",
 		}),
-		RPCServerRequestDurationSeconds: promauto.With(registry).NewHistogramVec(prometheus.HistogramOpts{
+		RPCServerRequestDurationSeconds: factory.NewHistogramVec(prometheus.HistogramOpts{
 			Namespace: ns,
 			Subsystem: RPCServerSubsystem,
 			Name:      "request_duration_seconds",
@@ -155,7 +159,7 @@ func NewMetrics(procName string) *Metrics {
 		}, []string{
 			"method",
 		}),
-		RPCClientRequestsTotal: promauto.With(registry).NewCounterVec(prometheus.CounterOpts{
+		RPCClientRequestsTotal: factory.NewCounterVec(prometheus.CounterOpts{
 			Namespace: ns,
 			Subsystem: RPCClientSubsystem,
 			Name:      "requests_total",
@@ -163,7 +167,7 @@ func NewMetrics(procName string) *Metrics {
 		}, []string{
 			"method",
 		}),
-		RPCClientRequestDurationSeconds: promauto.With(registry).NewHistogramVec(prometheus.HistogramOpts{
+		RPCClientRequestDurationSeconds: factory.NewHistogramVec(prometheus.HistogramOpts{
 			Namespace: ns,
 			Subsystem: RPCClientSubsystem,
 			Name:      "request_duration_seconds",
@@ -172,7 +176,7 @@ func NewMetrics(procName string) *Metrics {
 		}, []string{
 			"method",
 		}),
-		RPCClientResponsesTotal: promauto.With(registry).NewCounterVec(prometheus.CounterOpts{
+		RPCClientResponsesTotal: factory.NewCounterVec(prometheus.CounterOpts{
 			Namespace: ns,
 			Subsystem: RPCClientSubsystem,
 			Name:      "responses_total",
@@ -182,33 +186,33 @@ func NewMetrics(procName string) *Metrics {
 			"error",
 		}),
 
-		L1SourceCache: NewCacheMetrics(registry, ns, "l1_source_cache", "L1 Source cache"),
-		L2SourceCache: NewCacheMetrics(registry, ns, "l2_source_cache", "L2 Source cache"),
+		L1SourceCache: NewCacheMetrics(factory, ns, "l1_source_cache", "L1 Source cache"),
+		L2SourceCache: NewCacheMetrics(factory, ns, "l2_source_cache", "L2 Source cache"),
 
-		DerivationIdle: promauto.With(registry).NewGauge(prometheus.GaugeOpts{
+		DerivationIdle: factory.NewGauge(prometheus.GaugeOpts{
 			Namespace: ns,
 			Name:      "derivation_idle",
 			Help:      "1 if the derivation pipeline is idle",
 		}),
 
-		PipelineResets:   NewEventMetrics(registry, ns, "pipeline_resets", "derivation pipeline resets"),
-		UnsafePayloads:   NewEventMetrics(registry, ns, "unsafe_payloads", "unsafe payloads"),
-		DerivationErrors: NewEventMetrics(registry, ns, "derivation_errors", "derivation errors"),
-		SequencingErrors: NewEventMetrics(registry, ns, "sequencing_errors", "sequencing errors"),
-		PublishingErrors: NewEventMetrics(registry, ns, "publishing_errors", "p2p publishing errors"),
+		PipelineResets:   NewEventMetrics(factory, ns, "pipeline_resets", "derivation pipeline resets"),
+		UnsafePayloads:   NewEventMetrics(factory, ns, "unsafe_payloads", "unsafe payloads"),
+		DerivationErrors: NewEventMetrics(factory, ns, "derivation_errors", "derivation errors"),
+		SequencingErrors: NewEventMetrics(factory, ns, "sequencing_errors", "sequencing errors"),
+		PublishingErrors: NewEventMetrics(factory, ns, "publishing_errors", "p2p publishing errors"),
 
-		UnsafePayloadsBufferLen: promauto.With(registry).NewGauge(prometheus.GaugeOpts{
+		UnsafePayloadsBufferLen: factory.NewGauge(prometheus.GaugeOpts{
 			Namespace: ns,
 			Name:      "unsafe_payloads_buffer_len",
 			Help:      "Number of buffered L2 unsafe payloads",
 		}),
-		UnsafePayloadsBufferMemSize: promauto.With(registry).NewGauge(prometheus.GaugeOpts{
+		UnsafePayloadsBufferMemSize: factory.NewGauge(prometheus.GaugeOpts{
 			Namespace: ns,
 			Name:      "unsafe_payloads_buffer_mem_size",
 			Help:      "Total estimated memory size of buffered L2 unsafe payloads",
 		}),
 
-		RefsNumber: promauto.With(registry).NewGaugeVec(prometheus.GaugeOpts{
+		RefsNumber: factory.NewGaugeVec(prometheus.GaugeOpts{
 			Namespace: ns,
 			Name:      "refs_number",
 			Help:      "Gauge representing the different L1/L2 reference block numbers",
@@ -216,7 +220,7 @@ func NewMetrics(procName string) *Metrics {
 			"layer",
 			"type",
 		}),
-		RefsTime: promauto.With(registry).NewGaugeVec(prometheus.GaugeOpts{
+		RefsTime: factory.NewGaugeVec(prometheus.GaugeOpts{
 			Namespace: ns,
 			Name:      "refs_time",
 			Help:      "Gauge representing the different L1/L2 reference block timestamps",
@@ -224,7 +228,7 @@ func NewMetrics(procName string) *Metrics {
 			"layer",
 			"type",
 		}),
-		RefsHash: promauto.With(registry).NewGaugeVec(prometheus.GaugeOpts{
+		RefsHash: factory.NewGaugeVec(prometheus.GaugeOpts{
 			Namespace: ns,
 			Name:      "refs_hash",
 			Help:      "Gauge representing the different L1/L2 reference block hashes truncated to float values",
@@ -232,14 +236,14 @@ func NewMetrics(procName string) *Metrics {
 			"layer",
 			"type",
 		}),
-		RefsSeqNr: promauto.With(registry).NewGaugeVec(prometheus.GaugeOpts{
+		RefsSeqNr: factory.NewGaugeVec(prometheus.GaugeOpts{
 			Namespace: ns,
 			Name:      "refs_seqnr",
 			Help:      "Gauge representing the different L2 reference sequence numbers",
 		}, []string{
 			"type",
 		}),
-		RefsLatency: promauto.With(registry).NewGaugeVec(prometheus.GaugeOpts{
+		RefsLatency: factory.NewGaugeVec(prometheus.GaugeOpts{
 			Namespace: ns,
 			Name:      "refs_latency",
 			Help:      "Gauge representing the different L1/L2 reference block timestamps minus current time, in seconds",
@@ -249,32 +253,32 @@ func NewMetrics(procName string) *Metrics {
 		}),
 		LatencySeen: make(map[string]common.Hash),
 
-		L1ReorgDepth: promauto.With(registry).NewHistogram(prometheus.HistogramOpts{
+		L1ReorgDepth: factory.NewHistogram(prometheus.HistogramOpts{
 			Namespace: ns,
 			Name:      "l1_reorg_depth",
 			Buckets:   []float64{0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5, 10.5, 20.5, 50.5, 100.5},
 			Help:      "Histogram of L1 Reorg Depths",
 		}),
 
-		TransactionsSequencedTotal: promauto.With(registry).NewGauge(prometheus.GaugeOpts{
+		TransactionsSequencedTotal: factory.NewGauge(prometheus.GaugeOpts{
 			Namespace: ns,
 			Name:      "transactions_sequenced_total",
 			Help:      "Count of total transactions sequenced",
 		}),
 
-		PeerCount: promauto.With(registry).NewGauge(prometheus.GaugeOpts{
+		PeerCount: factory.NewGauge(prometheus.GaugeOpts{
 			Namespace: ns,
 			Subsystem: "p2p",
 			Name:      "peer_count",
 			Help:      "Count of currently connected p2p peers",
 		}),
-		StreamCount: promauto.With(registry).NewGauge(prometheus.GaugeOpts{
+		StreamCount: factory.NewGauge(prometheus.GaugeOpts{
 			Namespace: ns,
 			Subsystem: "p2p",
 			Name:      "stream_count",
 			Help:      "Count of currently connected p2p streams",
 		}),
-		GossipEventsTotal: promauto.With(registry).NewCounterVec(prometheus.CounterOpts{
+		GossipEventsTotal: factory.NewCounterVec(prometheus.CounterOpts{
 			Namespace: ns,
 			Subsystem: "p2p",
 			Name:      "gossip_events_total",
@@ -282,7 +286,7 @@ func NewMetrics(procName string) *Metrics {
 		}, []string{
 			"type",
 		}),
-		BandwidthTotal: promauto.With(registry).NewGaugeVec(prometheus.GaugeOpts{
+		BandwidthTotal: factory.NewGaugeVec(prometheus.GaugeOpts{
 			Namespace: ns,
 			Subsystem: "p2p",
 			Name:      "bandwidth_bytes_total",
@@ -291,7 +295,7 @@ func NewMetrics(procName string) *Metrics {
 			"direction",
 		}),
 
-		SequencerBuildingDiffDurationSeconds: promauto.With(registry).NewHistogram(prometheus.HistogramOpts{
+		SequencerBuildingDiffDurationSeconds: factory.NewHistogram(prometheus.HistogramOpts{
 			Namespace: ns,
 			Name:      "sequencer_building_diff_seconds",
 			Buckets: []float64{
@@ -299,24 +303,25 @@ func NewMetrics(procName string) *Metrics {
 				.005, .01, .025, .05, .1, .25, .5, 1, 2.5, 5, 10},
 			Help: "Histogram of Sequencer building time, minus block time",
 		}),
-		SequencerBuildingDiffTotal: promauto.With(registry).NewCounter(prometheus.CounterOpts{
+		SequencerBuildingDiffTotal: factory.NewCounter(prometheus.CounterOpts{
 			Namespace: ns,
 			Name:      "sequencer_building_diff_total",
 			Help:      "Number of sequencer block building jobs",
 		}),
-		SequencerSealingDurationSeconds: promauto.With(registry).NewHistogram(prometheus.HistogramOpts{
+		SequencerSealingDurationSeconds: factory.NewHistogram(prometheus.HistogramOpts{
 			Namespace: ns,
 			Name:      "sequencer_sealing_seconds",
 			Buckets:   []float64{.005, .01, .025, .05, .1, .25, .5, 1, 2.5, 5, 10},
 			Help:      "Histogram of Sequencer block sealing time",
 		}),
-		SequencerSealingTotal: promauto.With(registry).NewCounter(prometheus.CounterOpts{
+		SequencerSealingTotal: factory.NewCounter(prometheus.CounterOpts{
 			Namespace: ns,
 			Name:      "sequencer_sealing_total",
 			Help:      "Number of sequencer block sealing jobs",
 		}),
 
 		registry: registry,
+		factory:  factory,
 	}
 }
 
@@ -515,6 +520,10 @@ func (m *Metrics) Serve(ctx context.Context, hostname string, port int) error {
 	return server.ListenAndServe()
 }
 
+func (m *Metrics) Document() []metrics.DocumentedMetric {
+	return m.factory.Document()
+}
+
 type noopMetricer struct{}
 
 var NoopMetrics Metricer = new(noopMetricer)
@@ -595,3 +604,7 @@ func (n *noopMetricer) RecordSequencerBuildingDiffTime(duration time.Duration) {
 
 func (n *noopMetricer) RecordSequencerSealingTime(duration time.Duration) {
 }
+
+func (n *noopMetricer) Document() []metrics.DocumentedMetric {
+	return nil
+}

op-node/node/runtime_config.go

@@ -15,7 +15,7 @@ import (
 
 var (
 	// UnsafeBlockSignerAddressSystemConfigStorageSlot is the storage slot identifier of the unsafeBlockSigner
-	// `address` storage value in the SystemConfig L1 contract.
+	// `address` storage value in the SystemConfig L1 contract. Computed as `keccak256("systemconfig.unsafeblocksigner")`
 	UnsafeBlockSignerAddressSystemConfigStorageSlot = common.HexToHash("0x65a7ed542fb37fe237fdfbdd70b31598523fe5b32879e307bae27a0bd9581c08")
 )
 

op-node/rollup/derive/attributes.go

@@ -23,17 +23,32 @@ type SystemConfigL2Fetcher interface {
 	SystemConfigByL2Hash(ctx context.Context, hash common.Hash) (eth.SystemConfig, error)
 }
 
+// FetchingAttributesBuilder fetches inputs for the building of L2 payload attributes on the fly.
+type FetchingAttributesBuilder struct {
+	cfg *rollup.Config
+	l1  L1ReceiptsFetcher
+	l2  SystemConfigL2Fetcher
+}
+
+func NewFetchingAttributesBuilder(cfg *rollup.Config, l1 L1ReceiptsFetcher, l2 SystemConfigL2Fetcher) *FetchingAttributesBuilder {
+	return &FetchingAttributesBuilder{
+		cfg: cfg,
+		l1:  l1,
+		l2:  l2,
+	}
+}
+
 // PreparePayloadAttributes prepares a PayloadAttributes template that is ready to build a L2 block with deposits only, on top of the given l2Parent, with the given epoch as L1 origin.
 // The template defaults to NoTxPool=true, and no sequencer transactions: the caller has to modify the template to add transactions,
 // by setting NoTxPool=false as sequencer, or by appending batch transactions as verifier.
 // The severity of the error is returned; a crit=false error means there was a temporary issue, like a failed RPC or time-out.
 // A crit=true error means the input arguments are inconsistent or invalid.
-func PreparePayloadAttributes(ctx context.Context, cfg *rollup.Config, dl L1ReceiptsFetcher, l2 SystemConfigL2Fetcher, l2Parent eth.L2BlockRef, timestamp uint64, epoch eth.BlockID) (attrs *eth.PayloadAttributes, err error) {
+func (ba *FetchingAttributesBuilder) PreparePayloadAttributes(ctx context.Context, l2Parent eth.L2BlockRef, epoch eth.BlockID) (attrs *eth.PayloadAttributes, err error) {
 	var l1Info eth.BlockInfo
 	var depositTxs []hexutil.Bytes
 	var seqNumber uint64
 
-	sysConfig, err := l2.SystemConfigByL2Hash(ctx, l2Parent.Hash)
+	sysConfig, err := ba.l2.SystemConfigByL2Hash(ctx, l2Parent.Hash)
 	if err != nil {
 		return nil, NewTemporaryError(fmt.Errorf("failed to retrieve L2 parent block: %w", err))
 	}
@@ -42,7 +57,7 @@ func PreparePayloadAttributes(ctx context.Context, cfg *rollup.Config, dl L1Rece
 	// case we need to fetch all transaction receipts from the L1 origin block so we can scan for
 	// user deposits.
 	if l2Parent.L1Origin.Number != epoch.Number {
-		info, receipts, err := dl.FetchReceipts(ctx, epoch.Hash)
+		info, receipts, err := ba.l1.FetchReceipts(ctx, epoch.Hash)
 		if err != nil {
 			return nil, NewTemporaryError(fmt.Errorf("failed to fetch L1 block info and receipts: %w", err))
 		}
@@ -52,13 +67,13 @@ func PreparePayloadAttributes(ctx context.Context, cfg *rollup.Config, dl L1Rece
 					epoch, info.ParentHash(), l2Parent.L1Origin))
 		}
 
-		deposits, err := DeriveDeposits(receipts, cfg.DepositContractAddress)
+		deposits, err := DeriveDeposits(receipts, ba.cfg.DepositContractAddress)
 		if err != nil {
 			// deposits may never be ignored. Failing to process them is a critical error.
 			return nil, NewCriticalError(fmt.Errorf("failed to derive some deposits: %w", err))
 		}
 		// apply sysCfg changes
-		if err := UpdateSystemConfigWithL1Receipts(&sysConfig, receipts, cfg); err != nil {
+		if err := UpdateSystemConfigWithL1Receipts(&sysConfig, receipts, ba.cfg); err != nil {
 			return nil, NewCriticalError(fmt.Errorf("failed to apply derived L1 sysCfg updates: %w", err))
 		}
 
@@ -69,7 +84,7 @@ func PreparePayloadAttributes(ctx context.Context, cfg *rollup.Config, dl L1Rece
 		if l2Parent.L1Origin.Hash != epoch.Hash {
 			return nil, NewResetError(fmt.Errorf("cannot create new block with L1 origin %s in conflict with L1 origin %s", epoch, l2Parent.L1Origin))
 		}
-		info, err := dl.InfoByHash(ctx, epoch.Hash)
+		info, err := ba.l1.InfoByHash(ctx, epoch.Hash)
 		if err != nil {
 			return nil, NewTemporaryError(fmt.Errorf("failed to fetch L1 block info: %w", err))
 		}
@@ -78,6 +93,13 @@ func PreparePayloadAttributes(ctx context.Context, cfg *rollup.Config, dl L1Rece
 		seqNumber = l2Parent.SequenceNumber + 1
 	}
 
+	// Sanity check the L1 origin was correctly selected to maintain the time invariant between L1 and L2
+	nextL2Time := l2Parent.Time + ba.cfg.BlockTime
+	if nextL2Time < l1Info.Time() {
+		return nil, NewResetError(fmt.Errorf("cannot build L2 block on top %s for time %d before L1 origin %s at time %d",
+			l2Parent, nextL2Time, eth.ToBlockID(l1Info), l1Info.Time()))
+	}
+
 	l1InfoTx, err := L1InfoDepositBytes(seqNumber, l1Info, sysConfig)
 	if err != nil {
 		return nil, NewCriticalError(fmt.Errorf("failed to create l1InfoTx: %w", err))
@@ -88,7 +110,7 @@ func PreparePayloadAttributes(ctx context.Context, cfg *rollup.Config, dl L1Rece
 	txs = append(txs, depositTxs...)
 
 	return &eth.PayloadAttributes{
-		Timestamp:             hexutil.Uint64(timestamp),
+		Timestamp:             hexutil.Uint64(nextL2Time),
 		PrevRandao:            eth.Bytes32(l1Info.MixDigest()),
 		SuggestedFeeRecipient: predeploys.SequencerFeeVaultAddr,
 		Transactions:          txs,

op-node/rollup/derive/attributes_queue.go

@@ -23,22 +23,24 @@ import (
 // This stage can be reset by clearing it's batch buffer.
 // This stage does not need to retain any references to L1 blocks.
 
+type AttributesBuilder interface {
+	PreparePayloadAttributes(ctx context.Context, l2Parent eth.L2BlockRef, epoch eth.BlockID) (attrs *eth.PayloadAttributes, err error)
+}
+
 type AttributesQueue struct {
-	log    log.Logger
-	config *rollup.Config
-	dl     L1ReceiptsFetcher
-	eng    SystemConfigL2Fetcher
-	prev   *BatchQueue
-	batch  *BatchData
+	log     log.Logger
+	config  *rollup.Config
+	builder AttributesBuilder
+	prev    *BatchQueue
+	batch   *BatchData
 }
 
-func NewAttributesQueue(log log.Logger, cfg *rollup.Config, l1Fetcher L1ReceiptsFetcher, eng SystemConfigL2Fetcher, prev *BatchQueue) *AttributesQueue {
+func NewAttributesQueue(log log.Logger, cfg *rollup.Config, builder AttributesBuilder, prev *BatchQueue) *AttributesQueue {
 	return &AttributesQueue{
-		log:    log,
-		config: cfg,
-		dl:     l1Fetcher,
-		eng:    eng,
-		prev:   prev,
+		log:     log,
+		config:  cfg,
+		builder: builder,
+		prev:    prev,
 	}
 }
 
@@ -74,9 +76,13 @@ func (aq *AttributesQueue) createNextAttributes(ctx context.Context, batch *Batc
 	if batch.ParentHash != l2SafeHead.Hash {
 		return nil, NewResetError(fmt.Errorf("valid batch has bad parent hash %s, expected %s", batch.ParentHash, l2SafeHead.Hash))
 	}
+	// sanity check timestamp
+	if expected := l2SafeHead.Time + aq.config.BlockTime; expected != batch.Timestamp {
+		return nil, NewResetError(fmt.Errorf("valid batch has bad timestamp %d, expected %d", batch.Timestamp, expected))
+	}
 	fetchCtx, cancel := context.WithTimeout(ctx, 20*time.Second)
 	defer cancel()
-	attrs, err := PreparePayloadAttributes(fetchCtx, aq.config, aq.dl, aq.eng, l2SafeHead, batch.Timestamp, batch.Epoch())
+	attrs, err := aq.builder.PreparePayloadAttributes(fetchCtx, l2SafeHead, batch.Epoch())
 	if err != nil {
 		return nil, err
 	}

op-node/rollup/derive/attributes_queue_test.go

@@ -40,6 +40,7 @@ func TestAttributesQueue(t *testing.T) {
 
 	safeHead := testutils.RandomL2BlockRef(rng)
 	safeHead.L1Origin = l1Info.ID()
+	safeHead.Time = l1Info.InfoTime
 
 	batch := &BatchData{BatchV1{
 		ParentHash:   safeHead.Hash,
@@ -75,11 +76,12 @@ func TestAttributesQueue(t *testing.T) {
 		NoTxPool:              true,
 		GasLimit:              (*eth.Uint64Quantity)(&expectedL1Cfg.GasLimit),
 	}
+	attrBuilder := NewFetchingAttributesBuilder(cfg, l1Fetcher, l2Fetcher)
 
-	aq := NewAttributesQueue(testlog.Logger(t, log.LvlError), cfg, l1Fetcher, l2Fetcher, nil)
+	aq := NewAttributesQueue(testlog.Logger(t, log.LvlError), cfg, attrBuilder, nil)
 
 	actual, err := aq.createNextAttributes(context.Background(), batch, safeHead)
 
-	require.Nil(t, err)
+	require.NoError(t, err)
 	require.Equal(t, attrs, *actual)
 }

op-node/rollup/derive/attributes_test.go

@@ -43,12 +43,12 @@ func TestPreparePayloadAttributes(t *testing.T) {
 		l1CfgFetcher := &testutils.MockL2Client{}
 		l1CfgFetcher.ExpectSystemConfigByL2Hash(l2Parent.Hash, testSysCfg, nil)
 		defer l1CfgFetcher.AssertExpectations(t)
-		l2Time := l2Parent.Time + cfg.BlockTime
 		l1Info := testutils.RandomBlockInfo(rng)
 		l1Info.InfoNum = l2Parent.L1Origin.Number + 1
 		epoch := l1Info.ID()
 		l1Fetcher.ExpectFetchReceipts(epoch.Hash, l1Info, nil, nil)
-		_, err := PreparePayloadAttributes(context.Background(), cfg, l1Fetcher, l1CfgFetcher, l2Parent, l2Time, epoch)
+		attrBuilder := NewFetchingAttributesBuilder(cfg, l1Fetcher, l1CfgFetcher)
+		_, err := attrBuilder.PreparePayloadAttributes(context.Background(), l2Parent, epoch)
 		require.NotNil(t, err, "inconsistent L1 origin error expected")
 		require.ErrorIs(t, err, ErrReset, "inconsistent L1 origin transition must be handled like a critical error with reorg")
 	})
@@ -60,11 +60,11 @@ func TestPreparePayloadAttributes(t *testing.T) {
 		l1CfgFetcher := &testutils.MockL2Client{}
 		l1CfgFetcher.ExpectSystemConfigByL2Hash(l2Parent.Hash, testSysCfg, nil)
 		defer l1CfgFetcher.AssertExpectations(t)
-		l2Time := l2Parent.Time + cfg.BlockTime
 		l1Info := testutils.RandomBlockInfo(rng)
 		l1Info.InfoNum = l2Parent.L1Origin.Number
 		epoch := l1Info.ID()
-		_, err := PreparePayloadAttributes(context.Background(), cfg, l1Fetcher, l1CfgFetcher, l2Parent, l2Time, epoch)
+		attrBuilder := NewFetchingAttributesBuilder(cfg, l1Fetcher, l1CfgFetcher)
+		_, err := attrBuilder.PreparePayloadAttributes(context.Background(), l2Parent, epoch)
 		require.NotNil(t, err, "inconsistent L1 origin error expected")
 		require.ErrorIs(t, err, ErrReset, "inconsistent L1 origin transition must be handled like a critical error with reorg")
 	})
@@ -76,12 +76,12 @@ func TestPreparePayloadAttributes(t *testing.T) {
 		l1CfgFetcher := &testutils.MockL2Client{}
 		l1CfgFetcher.ExpectSystemConfigByL2Hash(l2Parent.Hash, testSysCfg, nil)
 		defer l1CfgFetcher.AssertExpectations(t)
-		l2Time := l2Parent.Time + cfg.BlockTime
 		epoch := l2Parent.L1Origin
 		epoch.Number += 1
 		mockRPCErr := errors.New("mock rpc error")
 		l1Fetcher.ExpectFetchReceipts(epoch.Hash, nil, nil, mockRPCErr)
-		_, err := PreparePayloadAttributes(context.Background(), cfg, l1Fetcher, l1CfgFetcher, l2Parent, l2Time, epoch)
+		attrBuilder := NewFetchingAttributesBuilder(cfg, l1Fetcher, l1CfgFetcher)
+		_, err := attrBuilder.PreparePayloadAttributes(context.Background(), l2Parent, epoch)
 		require.ErrorIs(t, err, mockRPCErr, "mock rpc error expected")
 		require.ErrorIs(t, err, ErrTemporary, "rpc errors should not be critical, it is not necessary to reorg")
 	})
@@ -93,11 +93,11 @@ func TestPreparePayloadAttributes(t *testing.T) {
 		l1CfgFetcher := &testutils.MockL2Client{}
 		l1CfgFetcher.ExpectSystemConfigByL2Hash(l2Parent.Hash, testSysCfg, nil)
 		defer l1CfgFetcher.AssertExpectations(t)
-		l2Time := l2Parent.Time + cfg.BlockTime
 		epoch := l2Parent.L1Origin
 		mockRPCErr := errors.New("mock rpc error")
 		l1Fetcher.ExpectInfoByHash(epoch.Hash, nil, mockRPCErr)
-		_, err := PreparePayloadAttributes(context.Background(), cfg, l1Fetcher, l1CfgFetcher, l2Parent, l2Time, epoch)
+		attrBuilder := NewFetchingAttributesBuilder(cfg, l1Fetcher, l1CfgFetcher)
+		_, err := attrBuilder.PreparePayloadAttributes(context.Background(), l2Parent, epoch)
 		require.ErrorIs(t, err, mockRPCErr, "mock rpc error expected")
 		require.ErrorIs(t, err, ErrTemporary, "rpc errors should not be critical, it is not necessary to reorg")
 	})
@@ -109,7 +109,6 @@ func TestPreparePayloadAttributes(t *testing.T) {
 		l1CfgFetcher := &testutils.MockL2Client{}
 		l1CfgFetcher.ExpectSystemConfigByL2Hash(l2Parent.Hash, testSysCfg, nil)
 		defer l1CfgFetcher.AssertExpectations(t)
-		l2Time := l2Parent.Time + cfg.BlockTime
 		l1Info := testutils.RandomBlockInfo(rng)
 		l1Info.InfoParentHash = l2Parent.L1Origin.Hash
 		l1Info.InfoNum = l2Parent.L1Origin.Number + 1
@@ -117,7 +116,8 @@ func TestPreparePayloadAttributes(t *testing.T) {
 		l1InfoTx, err := L1InfoDepositBytes(0, l1Info, testSysCfg)
 		require.NoError(t, err)
 		l1Fetcher.ExpectFetchReceipts(epoch.Hash, l1Info, nil, nil)
-		attrs, err := PreparePayloadAttributes(context.Background(), cfg, l1Fetcher, l1CfgFetcher, l2Parent, l2Time, epoch)
+		attrBuilder := NewFetchingAttributesBuilder(cfg, l1Fetcher, l1CfgFetcher)
+		attrs, err := attrBuilder.PreparePayloadAttributes(context.Background(), l2Parent, epoch)
 		require.NoError(t, err)
 		require.NotNil(t, attrs)
 		require.Equal(t, l2Parent.Time+cfg.BlockTime, uint64(attrs.Timestamp))
@@ -135,7 +135,6 @@ func TestPreparePayloadAttributes(t *testing.T) {
 		l1CfgFetcher := &testutils.MockL2Client{}
 		l1CfgFetcher.ExpectSystemConfigByL2Hash(l2Parent.Hash, testSysCfg, nil)
 		defer l1CfgFetcher.AssertExpectations(t)
-		l2Time := l2Parent.Time + cfg.BlockTime
 		l1Info := testutils.RandomBlockInfo(rng)
 		l1Info.InfoParentHash = l2Parent.L1Origin.Hash
 		l1Info.InfoNum = l2Parent.L1Origin.Number + 1
@@ -157,7 +156,8 @@ func TestPreparePayloadAttributes(t *testing.T) {
 		l2Txs := append(append(make([]eth.Data, 0), l1InfoTx), usedDepositTxs...)
 
 		l1Fetcher.ExpectFetchReceipts(epoch.Hash, l1Info, receipts, nil)
-		attrs, err := PreparePayloadAttributes(context.Background(), cfg, l1Fetcher, l1CfgFetcher, l2Parent, l2Time, epoch)
+		attrBuilder := NewFetchingAttributesBuilder(cfg, l1Fetcher, l1CfgFetcher)
+		attrs, err := attrBuilder.PreparePayloadAttributes(context.Background(), l2Parent, epoch)
 		require.NoError(t, err)
 		require.NotNil(t, attrs)
 		require.Equal(t, l2Parent.Time+cfg.BlockTime, uint64(attrs.Timestamp))
@@ -175,7 +175,6 @@ func TestPreparePayloadAttributes(t *testing.T) {
 		l1CfgFetcher := &testutils.MockL2Client{}
 		l1CfgFetcher.ExpectSystemConfigByL2Hash(l2Parent.Hash, testSysCfg, nil)
 		defer l1CfgFetcher.AssertExpectations(t)
-		l2Time := l2Parent.Time + cfg.BlockTime
 		l1Info := testutils.RandomBlockInfo(rng)
 		l1Info.InfoHash = l2Parent.L1Origin.Hash
 		l1Info.InfoNum = l2Parent.L1Origin.Number
@@ -185,7 +184,8 @@ func TestPreparePayloadAttributes(t *testing.T) {
 		require.NoError(t, err)
 
 		l1Fetcher.ExpectInfoByHash(epoch.Hash, l1Info, nil)
-		attrs, err := PreparePayloadAttributes(context.Background(), cfg, l1Fetcher, l1CfgFetcher, l2Parent, l2Time, epoch)
+		attrBuilder := NewFetchingAttributesBuilder(cfg, l1Fetcher, l1CfgFetcher)
+		attrs, err := attrBuilder.PreparePayloadAttributes(context.Background(), l2Parent, epoch)
 		require.NoError(t, err)
 		require.NotNil(t, attrs)
 		require.Equal(t, l2Parent.Time+cfg.BlockTime, uint64(attrs.Timestamp))

op-node/rollup/derive/pipeline.go

@@ -74,7 +74,8 @@ func NewDerivationPipeline(log log.Logger, cfg *rollup.Config, l1Fetcher L1Fetch
 	bank := NewChannelBank(log, cfg, frameQueue, l1Fetcher)
 	chInReader := NewChannelInReader(log, bank)
 	batchQueue := NewBatchQueue(log, cfg, chInReader)
-	attributesQueue := NewAttributesQueue(log, cfg, l1Fetcher, engine, batchQueue)
+	attrBuilder := NewFetchingAttributesBuilder(cfg, l1Fetcher, engine)
+	attributesQueue := NewAttributesQueue(log, cfg, attrBuilder, batchQueue)
 
 	// Step stages
 	eng := NewEngineQueue(log, cfg, engine, metrics, attributesQueue, l1Fetcher)

op-node/rollup/derive/system_config.go

@@ -27,6 +27,17 @@ var (
 	ConfigUpdateEventVersion0 = common.Hash{}
 )
 
+var (
+	// A left-padded uint256 equal to 32.
+	oneWordUint = common.Hash{31: 32}
+	// A left-padded uint256 equal to 64.
+	twoWordUint = common.Hash{31: 64}
+	// 24 zero bytes (the padding for a uint64 in a 32 byte word)
+	uint64Padding = make([]byte, 24)
+	// 12 zero bytes (the padding for an Ethereum address in a 32 byte word)
+	addressPadding = make([]byte, 12)
+)
+
 // UpdateSystemConfigWithL1Receipts filters all L1 receipts to find config updates and applies the config updates to the given sysCfg
 func UpdateSystemConfigWithL1Receipts(sysCfg *eth.SystemConfig, receipts []*types.Receipt, cfg *rollup.Config) error {
 	var result error
@@ -69,50 +80,94 @@ func ProcessSystemConfigUpdateLogEvent(destSysCfg *eth.SystemConfig, ev *types.L
 	}
 	// indexed 1
 	updateType := ev.Topics[2]
-	// unindexed data
+
+	// Create a reader of the unindexed data
+	reader := bytes.NewReader(ev.Data)
+
+	// Counter for the number of bytes read from `reader` via `readWord`
+	countReadBytes := 0
+
+	// Helper function to read a word from the log data reader
+	readWord := func() (b [32]byte) {
+		if _, err := reader.Read(b[:]); err != nil {
+			// If there is an error reading the next 32 bytes from the reader, return an empty
+			// 32 byte array. We always check that the number of bytes read (`countReadBytes`)
+			// is equal to the expected amount at the end of each switch case.
+			return b
+		}
+		countReadBytes += 32
+		return b
+	}
+
+	// Attempt to read unindexed data
 	switch updateType {
 	case SystemConfigUpdateBatcher:
-		if len(ev.Data) != 32*3 {
-			return fmt.Errorf("expected 32*3 bytes in batcher hash update, but got %d bytes", len(ev.Data))
+		// Read the pointer, it should always equal 32.
+		if word := readWord(); word != oneWordUint {
+			return fmt.Errorf("expected offset to point to length location, but got %s", word)
 		}
-		if x := common.BytesToHash(ev.Data[:32]); x != (common.Hash{31: 32}) {
-			return fmt.Errorf("expected offset to point to length location, but got %s", x)
+
+		// Read the length, it should also always equal 32.
+		if word := readWord(); word != oneWordUint {
+			return fmt.Errorf("expected length to be 32 bytes, but got %s", word)
 		}
-		if x := common.BytesToHash(ev.Data[32:64]); x != (common.Hash{31: 32}) {
-			return fmt.Errorf("expected length of 1 bytes32, but got %s", x)
+
+		// Indexing `word` directly is always safe here, it is guaranteed to be 32 bytes in length.
+		// Check that the batcher address is correctly zero-padded.
+		word := readWord()
+		if !bytes.Equal(word[:12], addressPadding) {
+			return fmt.Errorf("expected version 0 batcher hash with zero padding, but got %x", word)
 		}
-		if !bytes.Equal(ev.Data[64:64+12], make([]byte, 12)) {
-			return fmt.Errorf("expected version 0 batcher hash with zero padding, but got %x", ev.Data)
+		destSysCfg.BatcherAddr.SetBytes(word[12:])
+
+		if countReadBytes != 32*3 {
+			return NewCriticalError(fmt.Errorf("expected 32*3 bytes in batcher hash update, but got %d bytes", len(ev.Data)))
 		}
-		destSysCfg.BatcherAddr.SetBytes(ev.Data[64+12:])
+
 		return nil
-	case SystemConfigUpdateGasConfig: // left padded uint8
-		if len(ev.Data) != 32*4 {
-			return fmt.Errorf("expected 32*4 bytes in GPO params update data, but got %d", len(ev.Data))
+	case SystemConfigUpdateGasConfig:
+		// Read the pointer, it should always equal 32.
+		if word := readWord(); word != oneWordUint {
+			return fmt.Errorf("expected offset to point to length location, but got %s", word)
 		}
-		if x := common.BytesToHash(ev.Data[:32]); x != (common.Hash{31: 32}) {
-			return fmt.Errorf("expected offset to point to length location, but got %s", x)
+
+		// Read the length, it should always equal 64.
+		if word := readWord(); word != twoWordUint {
+			return fmt.Errorf("expected length to be 64 bytes, but got %s", word)
 		}
-		if x := common.BytesToHash(ev.Data[32:64]); x != (common.Hash{31: 64}) {
-			return fmt.Errorf("expected length of 2 bytes32, but got %s", x)
+
+		// Set the system config's overhead and scalar values to the values read from the log
+		destSysCfg.Overhead = readWord()
+		destSysCfg.Scalar = readWord()
+
+		if countReadBytes != 32*4 {
+			return NewCriticalError(fmt.Errorf("expected 32*4 bytes in GPO params update data, but got %d", len(ev.Data)))
 		}
-		copy(destSysCfg.Overhead[:], ev.Data[64:96])
-		copy(destSysCfg.Scalar[:], ev.Data[96:128])
+
 		return nil
 	case SystemConfigUpdateGasLimit:
-		if len(ev.Data) != 32*3 {
-			return fmt.Errorf("expected 32*3 bytes in gas limit update, but got %d bytes", len(ev.Data))
+		// Read the pointer, it should always equal 32.
+		if word := readWord(); word != oneWordUint {
+			return fmt.Errorf("expected offset to point to length location, but got %s", word)
 		}
-		if x := common.BytesToHash(ev.Data[:32]); x != (common.Hash{31: 32}) {
-			return fmt.Errorf("expected offset to point to length location, but got %s", x)
+
+		// Read the length, it should also always equal 32.
+		if word := readWord(); word != oneWordUint {
+			return fmt.Errorf("expected length to be 32 bytes, but got %s", word)
 		}
-		if x := common.BytesToHash(ev.Data[32:64]); x != (common.Hash{31: 32}) {
-			return fmt.Errorf("expected length of 1 bytes32, but got %s", x)
+
+		// Indexing `word` directly is always safe here, it is guaranteed to be 32 bytes in length.
+		// Check that the gas limit is correctly zero-padded.
+		word := readWord()
+		if !bytes.Equal(word[:24], uint64Padding) {
+			return fmt.Errorf("expected zero padding for gaslimit, but got %x", word)
 		}
-		if !bytes.Equal(ev.Data[64:64+24], make([]byte, 24)) {
-			return fmt.Errorf("expected zero padding for gaslimit, but got %x", ev.Data)
+		destSysCfg.GasLimit = binary.BigEndian.Uint64(word[24:])
+
+		if countReadBytes != 32*3 {
+			return NewCriticalError(fmt.Errorf("expected 32*3 bytes in gas limit update, but got %d bytes", len(ev.Data)))
 		}
-		destSysCfg.GasLimit = binary.BigEndian.Uint64(ev.Data[64+24:])
+
 		return nil
 	case SystemConfigUpdateUnsafeBlockSigner:
 		// Ignored in derivation. This configurable applies to runtime configuration outside of the derivation.

op-node/rollup/driver/driver.go

@@ -89,8 +89,8 @@ func NewDriver(driverCfg *Config, cfg *rollup.Config, l2 L2Chain, l1 L1Chain, ne
 	findL1Origin := NewL1OriginSelector(log, cfg, l1, driverCfg.SequencerConfDepth)
 	verifConfDepth := NewConfDepth(driverCfg.VerifierConfDepth, l1State.L1Head, l1)
 	derivationPipeline := derive.NewDerivationPipeline(log, cfg, verifConfDepth, l2, metrics)
-	sequencer := NewSequencer(log, cfg, l1, l2, derivationPipeline, metrics)
-
+	attrBuilder := derive.NewFetchingAttributesBuilder(cfg, l1, l2)
+	sequencer := NewSequencer(log, cfg, l2, derivationPipeline, attrBuilder, metrics)
 	return &Driver{
 		l1State:          l1State,
 		derivation:       derivationPipeline,

op-node/rollup/driver/sequencer.go

@@ -37,10 +37,10 @@ type Sequencer struct {
 	log    log.Logger
 	config *rollup.Config
 
-	l1          Downloader
 	l2          derive.Engine
 	engineState EngineState
 
+	attrBuilder       derive.AttributesBuilder
 	buildingOnto      eth.L2BlockRef
 	buildingID        eth.PayloadID
 	buildingStartTime time.Time
@@ -48,14 +48,14 @@ type Sequencer struct {
 	metrics SequencerMetrics
 }
 
-func NewSequencer(log log.Logger, cfg *rollup.Config, l1 Downloader, l2 derive.Engine, engineState EngineState, metrics SequencerMetrics) *Sequencer {
+func NewSequencer(log log.Logger, cfg *rollup.Config, l2 derive.Engine, engineState EngineState, attributesBuilder derive.AttributesBuilder, metrics SequencerMetrics) *Sequencer {
 	return &Sequencer{
 		log:         log,
 		config:      cfg,
-		l1:          l1,
 		l2:          l2,
 		metrics:     metrics,
 		engineState: engineState,
+		attrBuilder: attributesBuilder,
 	}
 }
 
@@ -75,7 +75,7 @@ func (d *Sequencer) StartBuildingBlock(ctx context.Context, l1Origin eth.L1Block
 	fetchCtx, cancel := context.WithTimeout(ctx, time.Second*20)
 	defer cancel()
 
-	attrs, err := derive.PreparePayloadAttributes(fetchCtx, d.config, d.l1, d.l2, l2Head, l2Head.Time+d.config.BlockTime, l1Origin.ID())
+	attrs, err := d.attrBuilder.PreparePayloadAttributes(fetchCtx, l2Head, l1Origin.ID())
 	if err != nil {
 		return err
 	}

op-service/metrics/factory.go

+package metrics
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+)
+
+type Factory interface {
+	NewCounter(opts prometheus.CounterOpts) prometheus.Counter
+	NewCounterVec(opts prometheus.CounterOpts, labelNames []string) *prometheus.CounterVec
+	NewGauge(opts prometheus.GaugeOpts) prometheus.Gauge
+	NewGaugeVec(opts prometheus.GaugeOpts, labelNames []string) *prometheus.GaugeVec
+	NewHistogram(opts prometheus.HistogramOpts) prometheus.Histogram
+	NewHistogramVec(opts prometheus.HistogramOpts, labelNames []string) *prometheus.HistogramVec
+	NewSummary(opts prometheus.SummaryOpts) prometheus.Summary
+	NewSummaryVec(opts prometheus.SummaryOpts, labelNames []string) *prometheus.SummaryVec
+	Document() []DocumentedMetric
+}
+
+type DocumentedMetric struct {
+	Type   string   `json:"type"`
+	Name   string   `json:"name"`
+	Help   string   `json:"help"`
+	Labels []string `json:"labels"`
+}
+
+type documentor struct {
+	metrics []DocumentedMetric
+	factory promauto.Factory
+}
+
+func With(registry *prometheus.Registry) Factory {
+	return &documentor{
+		factory: promauto.With(registry),
+	}
+}
+
+func (d *documentor) NewCounter(opts prometheus.CounterOpts) prometheus.Counter {
+	d.metrics = append(d.metrics, DocumentedMetric{
+		Type: "counter",
+		Name: fullName(opts.Namespace, opts.Subsystem, opts.Name),
+		Help: opts.Help,
+	})
+	return d.factory.NewCounter(opts)
+}
+
+func (d *documentor) NewCounterVec(opts prometheus.CounterOpts, labelNames []string) *prometheus.CounterVec {
+	d.metrics = append(d.metrics, DocumentedMetric{
+		Type:   "counter",
+		Name:   fullName(opts.Namespace, opts.Subsystem, opts.Name),
+		Help:   opts.Help,
+		Labels: labelNames,
+	})
+	return d.factory.NewCounterVec(opts, labelNames)
+}
+
+func (d *documentor) NewGauge(opts prometheus.GaugeOpts) prometheus.Gauge {
+	d.metrics = append(d.metrics, DocumentedMetric{
+		Type: "gauge",
+		Name: fullName(opts.Namespace, opts.Subsystem, opts.Name),
+		Help: opts.Help,
+	})
+	return d.factory.NewGauge(opts)
+}
+
+func (d *documentor) NewGaugeVec(opts prometheus.GaugeOpts, labelNames []string) *prometheus.GaugeVec {
+	d.metrics = append(d.metrics, DocumentedMetric{
+		Type:   "gauge",
+		Name:   fullName(opts.Namespace, opts.Subsystem, opts.Name),
+		Help:   opts.Help,
+		Labels: labelNames,
+	})
+	return d.factory.NewGaugeVec(opts, labelNames)
+}
+
+func (d *documentor) NewHistogram(opts prometheus.HistogramOpts) prometheus.Histogram {
+	d.metrics = append(d.metrics, DocumentedMetric{
+		Type: "histogram",
+		Name: fullName(opts.Namespace, opts.Subsystem, opts.Name),
+		Help: opts.Help,
+	})
+	return d.factory.NewHistogram(opts)
+}
+
+func (d *documentor) NewHistogramVec(opts prometheus.HistogramOpts, labelNames []string) *prometheus.HistogramVec {
+	d.metrics = append(d.metrics, DocumentedMetric{
+		Type:   "histogram",
+		Name:   fullName(opts.Namespace, opts.Subsystem, opts.Name),
+		Help:   opts.Help,
+		Labels: labelNames,
+	})
+	return d.factory.NewHistogramVec(opts, labelNames)
+}
+
+func (d *documentor) NewSummary(opts prometheus.SummaryOpts) prometheus.Summary {
+	d.metrics = append(d.metrics, DocumentedMetric{
+		Type: "summary",
+		Name: fullName(opts.Namespace, opts.Subsystem, opts.Name),
+		Help: opts.Help,
+	})
+	return d.factory.NewSummary(opts)
+}
+
+func (d *documentor) NewSummaryVec(opts prometheus.SummaryOpts, labelNames []string) *prometheus.SummaryVec {
+	d.metrics = append(d.metrics, DocumentedMetric{
+		Type:   "summary",
+		Name:   fullName(opts.Namespace, opts.Subsystem, opts.Name),
+		Help:   opts.Help,
+		Labels: labelNames,
+	})
+	return d.factory.NewSummaryVec(opts, labelNames)
+}
+
+func (d *documentor) Document() []DocumentedMetric {
+	return d.metrics
+}
+
+func fullName(ns, subsystem, name string) string {
+	out := ns
+	if subsystem != "" {
+		out += "_" + subsystem
+	}
+	return out + "_" + name
+}

ops/docker/ci-builder/CHANGELOG.md

 # @eth-optimism/ci-builder
 
+## 0.4.0
+
+### Minor Changes
+
+- 05cc935b2: Bump foundry to 2ff99025abade470a795724c10648c800a41025e
+
 ## 0.3.8
 
 ### Patch Changes

ops/docker/ci-builder/Dockerfile

@@ -16,7 +16,7 @@ WORKDIR /opt/foundry
 # Only diff from upstream docker image is this clone instead
 # of COPY. We select a specific commit to use.
 RUN git clone https://github.com/foundry-rs/foundry.git . \
-    && git checkout c06b53287dc23c4e5b1b3e57c937a90114bbe166
+    && git checkout 2ff99025abade470a795724c10648c800a41025e
 
 RUN source $HOME/.profile && \
     cargo build --release && \

ops/docker/ci-builder/package.json

 {
   "name": "@eth-optimism/ci-builder",
-  "version": "0.3.8",
+  "version": "0.4.0",
   "scripts": {},
   "license": "MIT",
   "dependencies": {}

ops/docker/foundry/CHANGELOG.md

 # @eth-optimism/foundry
 
+## 0.2.0
+
+### Minor Changes
+
+- 05cc935b2: Bump foundry to 2ff99025abade470a795724c10648c800a41025e
+
 ## 0.1.3
 
 ### Patch Changes

ops/docker/foundry/Dockerfile

@@ -9,7 +9,7 @@ WORKDIR /opt/foundry
 # Only diff from upstream docker image is this clone instead
 # of COPY. We select a specific commit to use.
 RUN git clone https://github.com/foundry-rs/foundry.git . \
-    && git checkout f540aa9ebde88dce720140b332412089c2ee85b6
+    && git checkout 2ff99025abade470a795724c10648c800a41025e
 
 RUN source $HOME/.profile && cargo build --release \
     && strip /opt/foundry/target/release/forge \

ops/docker/foundry/package.json

 {
   "name": "@eth-optimism/foundry",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "scripts": {},
   "license": "MIT",
   "dependencies": {}

packages/contracts-bedrock/.gas-snapshot

@@ -17,7 +17,7 @@ Bytes_Test:test_toNibbles_expectedResult128Bytes_works() (gas: 129885)
 Bytes_Test:test_toNibbles_expectedResult5Bytes_works() (gas: 6132)
 Bytes_Test:test_toNibbles_zeroLengthInput_works() (gas: 966)
 CrossDomainMessenger_BaseGas_Test:test_baseGas_succeeds() (gas: 20120)
-CrossDomainOwnableThroughPortal_Test:test_depositTransaction_crossDomainOwner_succeeds() (gas: 61876)
+CrossDomainOwnableThroughPortal_Test:test_depositTransaction_crossDomainOwner_succeeds() (gas: 61882)
 CrossDomainOwnable_Test:test_onlyOwner_notOwner_reverts() (gas: 10530)
 CrossDomainOwnable_Test:test_onlyOwner_succeeds() (gas: 34861)
 CrossDomainOwnable2_Test:test_onlyOwner_notMessenger_reverts() (gas: 8416)
@@ -368,14 +368,14 @@ RLPWriter_Test:test_writeUint_smallint3_succeeds() (gas: 7311)
 RLPWriter_Test:test_writeUint_smallint4_succeeds() (gas: 7312)
 RLPWriter_Test:test_writeUint_smallint_succeeds() (gas: 7290)
 RLPWriter_Test:test_writeUint_zero_succeeds() (gas: 7802)
-ResourceMetering_Test:test_meter_initialResourceParams_succeeds() (gas: 8965)
-ResourceMetering_Test:test_meter_updateNoGasDelta_succeeds() (gas: 2008101)
-ResourceMetering_Test:test_meter_updateOneEmptyBlock_succeeds() (gas: 18152)
-ResourceMetering_Test:test_meter_updateParamsNoChange_succeeds() (gas: 13911)
-ResourceMetering_Test:test_meter_updateTenEmptyBlocks_succeeds() (gas: 20900)
-ResourceMetering_Test:test_meter_updateTwoEmptyBlocks_succeeds() (gas: 20923)
-ResourceMetering_Test:test_meter_useMax_succeeds() (gas: 8017204)
-ResourceMetering_Test:test_meter_useMoreThanMax_reverts() (gas: 16023)
+ResourceMetering_Test:test_meter_initialResourceParams_succeeds() (gas: 8983)
+ResourceMetering_Test:test_meter_updateNoGasDelta_succeeds() (gas: 2008119)
+ResourceMetering_Test:test_meter_updateOneEmptyBlock_succeeds() (gas: 18148)
+ResourceMetering_Test:test_meter_updateParamsNoChange_succeeds() (gas: 13859)
+ResourceMetering_Test:test_meter_updateTenEmptyBlocks_succeeds() (gas: 20918)
+ResourceMetering_Test:test_meter_updateTwoEmptyBlocks_succeeds() (gas: 20941)
+ResourceMetering_Test:test_meter_useMax_succeeds() (gas: 8017151)
+ResourceMetering_Test:test_meter_useMoreThanMax_reverts() (gas: 16045)
 Semver_Test:test_behindProxy_succeeds() (gas: 506725)
 Semver_Test:test_version_succeeds() (gas: 9396)
 SequencerFeeVault_Test:test_constructor_succeeds() (gas: 5504)

packages/contracts-bedrock/.storage-layout

@@ -6,366 +6,243 @@
 ➡ contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger
 =======================
 
-+--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------+
 | Name               | Type                     | Slot | Offset | Bytes | Contract                                                       |
-+========================================================================================================================================+
+|--------------------|--------------------------|------|--------|-------|----------------------------------------------------------------|
 | spacer_0_0_20      | address                  | 0    | 0      | 20    | contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | _initialized       | uint8                    | 0    | 20     | 1     | contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | _initializing      | bool                     | 0    | 21     | 1     | contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | __gap              | uint256[50]              | 1    | 0      | 1600  | contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | _owner             | address                  | 51   | 0      | 20    | contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | __gap              | uint256[49]              | 52   | 0      | 1568  | contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | _paused            | bool                     | 101  | 0      | 1     | contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | __gap              | uint256[49]              | 102  | 0      | 1568  | contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | _status            | uint256                  | 151  | 0      | 32    | contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | __gap              | uint256[49]              | 152  | 0      | 1568  | contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | spacer_201_0_32    | mapping(bytes32 => bool) | 201  | 0      | 32    | contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | spacer_202_0_32    | mapping(bytes32 => bool) | 202  | 0      | 32    | contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | successfulMessages | mapping(bytes32 => bool) | 203  | 0      | 32    | contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | xDomainMsgSender   | address                  | 204  | 0      | 20    | contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | msgNonce           | uint240                  | 205  | 0      | 30    | contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | failedMessages     | mapping(bytes32 => bool) | 206  | 0      | 32    | contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | __gap              | uint256[42]              | 207  | 0      | 1344  | contracts/L1/L1CrossDomainMessenger.sol:L1CrossDomainMessenger |
-+--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------+
 
 =======================
 ➡ contracts/L1/L1StandardBridge.sol:L1StandardBridge
 =======================
 
-+---------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------+
 | Name          | Type                                            | Slot | Offset | Bytes | Contract                                           |
-+==============================================================================================================================================+
+|---------------|-------------------------------------------------|------|--------|-------|----------------------------------------------------|
 | spacer_0_0_20 | address                                         | 0    | 0      | 20    | contracts/L1/L1StandardBridge.sol:L1StandardBridge |
-|---------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------|
 | spacer_1_0_20 | address                                         | 1    | 0      | 20    | contracts/L1/L1StandardBridge.sol:L1StandardBridge |
-|---------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------|
 | deposits      | mapping(address => mapping(address => uint256)) | 2    | 0      | 32    | contracts/L1/L1StandardBridge.sol:L1StandardBridge |
-|---------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------|
 | __gap         | uint256[47]                                     | 3    | 0      | 1504  | contracts/L1/L1StandardBridge.sol:L1StandardBridge |
-+---------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------+
 
 =======================
 ➡ contracts/L1/L2OutputOracle.sol:L2OutputOracle
 =======================
 
-+---------------------+-------------------------------+------+--------+-------+------------------------------------------------+
 | Name                | Type                          | Slot | Offset | Bytes | Contract                                       |
-+==============================================================================================================================+
+|---------------------|-------------------------------|------|--------|-------|------------------------------------------------|
 | _initialized        | uint8                         | 0    | 0      | 1     | contracts/L1/L2OutputOracle.sol:L2OutputOracle |
-|---------------------+-------------------------------+------+--------+-------+------------------------------------------------|
 | _initializing       | bool                          | 0    | 1      | 1     | contracts/L1/L2OutputOracle.sol:L2OutputOracle |
-|---------------------+-------------------------------+------+--------+-------+------------------------------------------------|
 | startingBlockNumber | uint256                       | 1    | 0      | 32    | contracts/L1/L2OutputOracle.sol:L2OutputOracle |
-|---------------------+-------------------------------+------+--------+-------+------------------------------------------------|
 | startingTimestamp   | uint256                       | 2    | 0      | 32    | contracts/L1/L2OutputOracle.sol:L2OutputOracle |
-|---------------------+-------------------------------+------+--------+-------+------------------------------------------------|
 | l2Outputs           | struct Types.OutputProposal[] | 3    | 0      | 32    | contracts/L1/L2OutputOracle.sol:L2OutputOracle |
-+---------------------+-------------------------------+------+--------+-------+------------------------------------------------+
 
 =======================
 ➡ contracts/L1/OptimismPortal.sol:OptimismPortal
 =======================
 
-+----------------------+------------------------------------------------------------+------+--------+-------+------------------------------------------------+
 | Name                 | Type                                                       | Slot | Offset | Bytes | Contract                                       |
-+============================================================================================================================================================+
+|----------------------|------------------------------------------------------------|------|--------|-------|------------------------------------------------|
 | _initialized         | uint8                                                      | 0    | 0      | 1     | contracts/L1/OptimismPortal.sol:OptimismPortal |
-|----------------------+------------------------------------------------------------+------+--------+-------+------------------------------------------------|
 | _initializing        | bool                                                       | 0    | 1      | 1     | contracts/L1/OptimismPortal.sol:OptimismPortal |
-|----------------------+------------------------------------------------------------+------+--------+-------+------------------------------------------------|
 | params               | struct ResourceMetering.ResourceParams                     | 1    | 0      | 32    | contracts/L1/OptimismPortal.sol:OptimismPortal |
-|----------------------+------------------------------------------------------------+------+--------+-------+------------------------------------------------|
 | __gap                | uint256[48]                                                | 2    | 0      | 1536  | contracts/L1/OptimismPortal.sol:OptimismPortal |
-|----------------------+------------------------------------------------------------+------+--------+-------+------------------------------------------------|
 | l2Sender             | address                                                    | 50   | 0      | 20    | contracts/L1/OptimismPortal.sol:OptimismPortal |
-|----------------------+------------------------------------------------------------+------+--------+-------+------------------------------------------------|
 | finalizedWithdrawals | mapping(bytes32 => bool)                                   | 51   | 0      | 32    | contracts/L1/OptimismPortal.sol:OptimismPortal |
-|----------------------+------------------------------------------------------------+------+--------+-------+------------------------------------------------|
 | provenWithdrawals    | mapping(bytes32 => struct OptimismPortal.ProvenWithdrawal) | 52   | 0      | 32    | contracts/L1/OptimismPortal.sol:OptimismPortal |
-+----------------------+------------------------------------------------------------+------+--------+-------+------------------------------------------------+
 
 =======================
 ➡ contracts/L1/SystemConfig.sol:SystemConfig
 =======================
 
-+---------------+-------------+------+--------+-------+--------------------------------------------+
 | Name          | Type        | Slot | Offset | Bytes | Contract                                   |
-+==================================================================================================+
+|---------------|-------------|------|--------|-------|--------------------------------------------|
 | _initialized  | uint8       | 0    | 0      | 1     | contracts/L1/SystemConfig.sol:SystemConfig |
-|---------------+-------------+------+--------+-------+--------------------------------------------|
 | _initializing | bool        | 0    | 1      | 1     | contracts/L1/SystemConfig.sol:SystemConfig |
-|---------------+-------------+------+--------+-------+--------------------------------------------|
 | __gap         | uint256[50] | 1    | 0      | 1600  | contracts/L1/SystemConfig.sol:SystemConfig |
-|---------------+-------------+------+--------+-------+--------------------------------------------|
 | _owner        | address     | 51   | 0      | 20    | contracts/L1/SystemConfig.sol:SystemConfig |
-|---------------+-------------+------+--------+-------+--------------------------------------------|
 | __gap         | uint256[49] | 52   | 0      | 1568  | contracts/L1/SystemConfig.sol:SystemConfig |
-|---------------+-------------+------+--------+-------+--------------------------------------------|
 | overhead      | uint256     | 101  | 0      | 32    | contracts/L1/SystemConfig.sol:SystemConfig |
-|---------------+-------------+------+--------+-------+--------------------------------------------|
 | scalar        | uint256     | 102  | 0      | 32    | contracts/L1/SystemConfig.sol:SystemConfig |
-|---------------+-------------+------+--------+-------+--------------------------------------------|
 | batcherHash   | bytes32     | 103  | 0      | 32    | contracts/L1/SystemConfig.sol:SystemConfig |
-|---------------+-------------+------+--------+-------+--------------------------------------------|
 | gasLimit      | uint64      | 104  | 0      | 8     | contracts/L1/SystemConfig.sol:SystemConfig |
-+---------------+-------------+------+--------+-------+--------------------------------------------+
 
 =======================
 ➡ contracts/legacy/DeployerWhitelist.sol:DeployerWhitelist
 =======================
 
-+-----------+--------------------------+------+--------+-------+----------------------------------------------------------+
 | Name      | Type                     | Slot | Offset | Bytes | Contract                                                 |
-+=========================================================================================================================+
+|-----------|--------------------------|------|--------|-------|----------------------------------------------------------|
 | owner     | address                  | 0    | 0      | 20    | contracts/legacy/DeployerWhitelist.sol:DeployerWhitelist |
-|-----------+--------------------------+------+--------+-------+----------------------------------------------------------|
 | whitelist | mapping(address => bool) | 1    | 0      | 32    | contracts/legacy/DeployerWhitelist.sol:DeployerWhitelist |
-+-----------+--------------------------+------+--------+-------+----------------------------------------------------------+
 
 =======================
 ➡ contracts/L2/L1Block.sol:L1Block
 =======================
 
-+----------------+---------+------+--------+-------+----------------------------------+
 | Name           | Type    | Slot | Offset | Bytes | Contract                         |
-+=====================================================================================+
+|----------------|---------|------|--------|-------|----------------------------------|
 | number         | uint64  | 0    | 0      | 8     | contracts/L2/L1Block.sol:L1Block |
-|----------------+---------+------+--------+-------+----------------------------------|
 | timestamp      | uint64  | 0    | 8      | 8     | contracts/L2/L1Block.sol:L1Block |
-|----------------+---------+------+--------+-------+----------------------------------|
 | basefee        | uint256 | 1    | 0      | 32    | contracts/L2/L1Block.sol:L1Block |
-|----------------+---------+------+--------+-------+----------------------------------|
 | hash           | bytes32 | 2    | 0      | 32    | contracts/L2/L1Block.sol:L1Block |
-|----------------+---------+------+--------+-------+----------------------------------|
 | sequenceNumber | uint64  | 3    | 0      | 8     | contracts/L2/L1Block.sol:L1Block |
-|----------------+---------+------+--------+-------+----------------------------------|
 | batcherHash    | bytes32 | 4    | 0      | 32    | contracts/L2/L1Block.sol:L1Block |
-|----------------+---------+------+--------+-------+----------------------------------|
 | l1FeeOverhead  | uint256 | 5    | 0      | 32    | contracts/L2/L1Block.sol:L1Block |
-|----------------+---------+------+--------+-------+----------------------------------|
 | l1FeeScalar    | uint256 | 6    | 0      | 32    | contracts/L2/L1Block.sol:L1Block |
-+----------------+---------+------+--------+-------+----------------------------------+
 
 =======================
 ➡ contracts/legacy/L1BlockNumber.sol:L1BlockNumber
 =======================
 
-+------+------+------+--------+-------+----------+
 | Name | Type | Slot | Offset | Bytes | Contract |
-+================================================+
-+------+------+------+--------+-------+----------+
+|------|------|------|--------|-------|----------|
 
 =======================
 ➡ contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger
 =======================
 
-+--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------+
 | Name               | Type                     | Slot | Offset | Bytes | Contract                                                       |
-+========================================================================================================================================+
+|--------------------|--------------------------|------|--------|-------|----------------------------------------------------------------|
 | spacer_0_0_20      | address                  | 0    | 0      | 20    | contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | _initialized       | uint8                    | 0    | 20     | 1     | contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | _initializing      | bool                     | 0    | 21     | 1     | contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | __gap              | uint256[50]              | 1    | 0      | 1600  | contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | _owner             | address                  | 51   | 0      | 20    | contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | __gap              | uint256[49]              | 52   | 0      | 1568  | contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | _paused            | bool                     | 101  | 0      | 1     | contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | __gap              | uint256[49]              | 102  | 0      | 1568  | contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | _status            | uint256                  | 151  | 0      | 32    | contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | __gap              | uint256[49]              | 152  | 0      | 1568  | contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | spacer_201_0_32    | mapping(bytes32 => bool) | 201  | 0      | 32    | contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | spacer_202_0_32    | mapping(bytes32 => bool) | 202  | 0      | 32    | contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | successfulMessages | mapping(bytes32 => bool) | 203  | 0      | 32    | contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | xDomainMsgSender   | address                  | 204  | 0      | 20    | contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | msgNonce           | uint240                  | 205  | 0      | 30    | contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | failedMessages     | mapping(bytes32 => bool) | 206  | 0      | 32    | contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger |
-|--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------|
 | __gap              | uint256[42]              | 207  | 0      | 1344  | contracts/L2/L2CrossDomainMessenger.sol:L2CrossDomainMessenger |
-+--------------------+--------------------------+------+--------+-------+----------------------------------------------------------------+
 
 =======================
 ➡ contracts/L2/L2StandardBridge.sol:L2StandardBridge
 =======================
 
-+---------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------+
 | Name          | Type                                            | Slot | Offset | Bytes | Contract                                           |
-+==============================================================================================================================================+
+|---------------|-------------------------------------------------|------|--------|-------|----------------------------------------------------|
 | spacer_0_0_20 | address                                         | 0    | 0      | 20    | contracts/L2/L2StandardBridge.sol:L2StandardBridge |
-|---------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------|
 | spacer_1_0_20 | address                                         | 1    | 0      | 20    | contracts/L2/L2StandardBridge.sol:L2StandardBridge |
-|---------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------|
 | deposits      | mapping(address => mapping(address => uint256)) | 2    | 0      | 32    | contracts/L2/L2StandardBridge.sol:L2StandardBridge |
-|---------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------|
 | __gap         | uint256[47]                                     | 3    | 0      | 1504  | contracts/L2/L2StandardBridge.sol:L2StandardBridge |
-+---------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------+
 
 =======================
 ➡ contracts/L2/L2ToL1MessagePasser.sol:L2ToL1MessagePasser
 =======================
 
-+--------------+--------------------------+------+--------+-------+----------------------------------------------------------+
 | Name         | Type                     | Slot | Offset | Bytes | Contract                                                 |
-+============================================================================================================================+
+|--------------|--------------------------|------|--------|-------|----------------------------------------------------------|
 | sentMessages | mapping(bytes32 => bool) | 0    | 0      | 32    | contracts/L2/L2ToL1MessagePasser.sol:L2ToL1MessagePasser |
-|--------------+--------------------------+------+--------+-------+----------------------------------------------------------|
 | msgNonce     | uint240                  | 1    | 0      | 30    | contracts/L2/L2ToL1MessagePasser.sol:L2ToL1MessagePasser |
-+--------------+--------------------------+------+--------+-------+----------------------------------------------------------+
 
 =======================
 ➡ contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH
 =======================
 
-+--------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------+
 | Name         | Type                                            | Slot | Offset | Bytes | Contract                                           |
-+=============================================================================================================================================+
+|--------------|-------------------------------------------------|------|--------|-------|----------------------------------------------------|
 | _balances    | mapping(address => uint256)                     | 0    | 0      | 32    | contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH |
-|--------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------|
 | _allowances  | mapping(address => mapping(address => uint256)) | 1    | 0      | 32    | contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH |
-|--------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------|
 | _totalSupply | uint256                                         | 2    | 0      | 32    | contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH |
-|--------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------|
 | _name        | string                                          | 3    | 0      | 32    | contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH |
-|--------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------|
 | _symbol      | string                                          | 4    | 0      | 32    | contracts/legacy/LegacyERC20ETH.sol:LegacyERC20ETH |
-+--------------+-------------------------------------------------+------+--------+-------+----------------------------------------------------+
 
 =======================
 ➡ contracts/L2/SequencerFeeVault.sol:SequencerFeeVault
 =======================
 
-+----------------+---------+------+--------+-------+------------------------------------------------------+
 | Name           | Type    | Slot | Offset | Bytes | Contract                                             |
-+=========================================================================================================+
+|----------------|---------|------|--------|-------|------------------------------------------------------|
 | totalProcessed | uint256 | 0    | 0      | 32    | contracts/L2/SequencerFeeVault.sol:SequencerFeeVault |
-+----------------+---------+------+--------+-------+------------------------------------------------------+
 
 =======================
 ➡ contracts/L2/BaseFeeVault.sol:BaseFeeVault
 =======================
 
-+----------------+---------+------+--------+-------+--------------------------------------------+
 | Name           | Type    | Slot | Offset | Bytes | Contract                                   |
-+===============================================================================================+
+|----------------|---------|------|--------|-------|--------------------------------------------|
 | totalProcessed | uint256 | 0    | 0      | 32    | contracts/L2/BaseFeeVault.sol:BaseFeeVault |
-+----------------+---------+------+--------+-------+--------------------------------------------+
 
 =======================
 ➡ contracts/L2/L1FeeVault.sol:L1FeeVault
 =======================
 
-+----------------+---------+------+--------+-------+----------------------------------------+
 | Name           | Type    | Slot | Offset | Bytes | Contract                               |
-+===========================================================================================+
+|----------------|---------|------|--------|-------|----------------------------------------|
 | totalProcessed | uint256 | 0    | 0      | 32    | contracts/L2/L1FeeVault.sol:L1FeeVault |
-+----------------+---------+------+--------+-------+----------------------------------------+
 
 =======================
 ➡ contracts/vendor/WETH9.sol:WETH9
 =======================
 
-+-----------+-------------------------------------------------+------+--------+-------+----------------------------------+
 | Name      | Type                                            | Slot | Offset | Bytes | Contract                         |
-+========================================================================================================================+
+|-----------|-------------------------------------------------|------|--------|-------|----------------------------------|
 | name      | string                                          | 0    | 0      | 32    | contracts/vendor/WETH9.sol:WETH9 |
-|-----------+-------------------------------------------------+------+--------+-------+----------------------------------|
 | symbol    | string                                          | 1    | 0      | 32    | contracts/vendor/WETH9.sol:WETH9 |
-|-----------+-------------------------------------------------+------+--------+-------+----------------------------------|
 | decimals  | uint8                                           | 2    | 0      | 1     | contracts/vendor/WETH9.sol:WETH9 |
-|-----------+-------------------------------------------------+------+--------+-------+----------------------------------|
 | balanceOf | mapping(address => uint256)                     | 3    | 0      | 32    | contracts/vendor/WETH9.sol:WETH9 |
-|-----------+-------------------------------------------------+------+--------+-------+----------------------------------|
 | allowance | mapping(address => mapping(address => uint256)) | 4    | 0      | 32    | contracts/vendor/WETH9.sol:WETH9 |
-+-----------+-------------------------------------------------+------+--------+-------+----------------------------------+
 
 =======================
 ➡ contracts/universal/ProxyAdmin.sol:ProxyAdmin
 =======================
 
-+--------------------+-----------------------------------------------+------+--------+-------+-----------------------------------------------+
 | Name               | Type                                          | Slot | Offset | Bytes | Contract                                      |
-+============================================================================================================================================+
+|--------------------|-----------------------------------------------|------|--------|-------|-----------------------------------------------|
 | _owner             | address                                       | 0    | 0      | 20    | contracts/universal/ProxyAdmin.sol:ProxyAdmin |
-|--------------------+-----------------------------------------------+------+--------+-------+-----------------------------------------------|
 | proxyType          | mapping(address => enum ProxyAdmin.ProxyType) | 1    | 0      | 32    | contracts/universal/ProxyAdmin.sol:ProxyAdmin |
-|--------------------+-----------------------------------------------+------+--------+-------+-----------------------------------------------|
 | implementationName | mapping(address => string)                    | 2    | 0      | 32    | contracts/universal/ProxyAdmin.sol:ProxyAdmin |
-|--------------------+-----------------------------------------------+------+--------+-------+-----------------------------------------------|
 | addressManager     | contract AddressManager                       | 3    | 0      | 20    | contracts/universal/ProxyAdmin.sol:ProxyAdmin |
-|--------------------+-----------------------------------------------+------+--------+-------+-----------------------------------------------|
 | upgrading          | bool                                          | 3    | 20     | 1     | contracts/universal/ProxyAdmin.sol:ProxyAdmin |
-+--------------------+-----------------------------------------------+------+--------+-------+-----------------------------------------------+
 
 =======================
 ➡ contracts/universal/Proxy.sol:Proxy
 =======================
 
-+------+------+------+--------+-------+----------+
 | Name | Type | Slot | Offset | Bytes | Contract |
-+================================================+
-+------+------+------+--------+-------+----------+
+|------|------|------|--------|-------|----------|
 
 =======================
 ➡ contracts/legacy/L1ChugSplashProxy.sol:L1ChugSplashProxy
 =======================
 
-+------+------+------+--------+-------+----------+
 | Name | Type | Slot | Offset | Bytes | Contract |
-+================================================+
-+------+------+------+--------+-------+----------+
+|------|------|------|--------|-------|----------|
 
 =======================
 ➡ contracts/universal/OptimismMintableERC20.sol:OptimismMintableERC20
 =======================
 
-+--------------+-------------------------------------------------+------+--------+-------+---------------------------------------------------------------------+
 | Name         | Type                                            | Slot | Offset | Bytes | Contract                                                            |
-+==============================================================================================================================================================+
+|--------------|-------------------------------------------------|------|--------|-------|---------------------------------------------------------------------|
 | _balances    | mapping(address => uint256)                     | 0    | 0      | 32    | contracts/universal/OptimismMintableERC20.sol:OptimismMintableERC20 |
-|--------------+-------------------------------------------------+------+--------+-------+---------------------------------------------------------------------|
 | _allowances  | mapping(address => mapping(address => uint256)) | 1    | 0      | 32    | contracts/universal/OptimismMintableERC20.sol:OptimismMintableERC20 |
-|--------------+-------------------------------------------------+------+--------+-------+---------------------------------------------------------------------|
 | _totalSupply | uint256                                         | 2    | 0      | 32    | contracts/universal/OptimismMintableERC20.sol:OptimismMintableERC20 |
-|--------------+-------------------------------------------------+------+--------+-------+---------------------------------------------------------------------|
 | _name        | string                                          | 3    | 0      | 32    | contracts/universal/OptimismMintableERC20.sol:OptimismMintableERC20 |
-|--------------+-------------------------------------------------+------+--------+-------+---------------------------------------------------------------------|
 | _symbol      | string                                          | 4    | 0      | 32    | contracts/universal/OptimismMintableERC20.sol:OptimismMintableERC20 |
-+--------------+-------------------------------------------------+------+--------+-------+---------------------------------------------------------------------+
 
 =======================
 ➡ contracts/universal/OptimismMintableERC20Factory.sol:OptimismMintableERC20Factory
 =======================
 
-+------+------+------+--------+-------+----------+
 | Name | Type | Slot | Offset | Bytes | Contract |
-+================================================+
-+------+------+------+--------+-------+----------+
+|------|------|------|--------|-------|----------|

packages/contracts-bedrock/README.md

@@ -57,7 +57,7 @@ We work on this repository with a combination of [Hardhat](https://hardhat.org)
 1. Install Foundry by following [the instructions located here](https://getfoundry.sh/).
    A specific version must be used.
    ```shell
-   foundryup -C c06b53287dc23c4e5b1b3e57c937a90114bbe166
+   foundryup -C 2ff99025abade470a795724c10648c800a41025e
    ```
 2. Install node modules with yarn (v1) and Node.js (16+):
 

packages/contracts-bedrock/contracts/deployment/SystemDictator.sol

@@ -188,6 +188,23 @@ contract SystemDictator is OwnableUpgradeable {
             config.proxyAddressConfig.l1StandardBridgeProxy,
             ProxyAdmin.ProxyType.CHUGSPLASH
         );
+
+        // Upgrade and initialize the SystemConfig so the Sequencer can start up.
+        config.globalConfig.proxyAdmin.upgradeAndCall(
+            payable(config.proxyAddressConfig.systemConfigProxy),
+            address(config.implementationAddressConfig.systemConfigImpl),
+            abi.encodeCall(
+                SystemConfig.initialize,
+                (
+                    config.systemConfigConfig.owner,
+                    config.systemConfigConfig.overhead,
+                    config.systemConfigConfig.scalar,
+                    config.systemConfigConfig.batcherHash,
+                    config.systemConfigConfig.gasLimit,
+                    config.systemConfigConfig.unsafeBlockSigner
+                )
+            )
+        );
     }
 
     /**
@@ -343,23 +360,6 @@ contract SystemDictator is OwnableUpgradeable {
             address(config.implementationAddressConfig.l1ERC721BridgeImpl)
         );
 
-        // Upgrade and initialize the SystemConfig.
-        config.globalConfig.proxyAdmin.upgradeAndCall(
-            payable(config.proxyAddressConfig.systemConfigProxy),
-            address(config.implementationAddressConfig.systemConfigImpl),
-            abi.encodeCall(
-                SystemConfig.initialize,
-                (
-                    config.systemConfigConfig.owner,
-                    config.systemConfigConfig.overhead,
-                    config.systemConfigConfig.scalar,
-                    config.systemConfigConfig.batcherHash,
-                    config.systemConfigConfig.gasLimit,
-                    config.systemConfigConfig.unsafeBlockSigner
-                )
-            )
-        );
-
         // Pause the L1CrossDomainMessenger, chance to check that everything is OK.
         L1CrossDomainMessenger(config.proxyAddressConfig.l1CrossDomainMessengerProxy).pause();
     }

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

@@ -108,4 +108,18 @@ contract ResourceMetering_Test is CommonTest {
         vm.expectRevert("ResourceMetering: cannot buy more gas than available gas limit");
         meter.use(target * elasticity + 1);
     }
+
+    // Demonstrates that the resource metering arithmetic can tolerate very large gaps between
+    // deposits.
+    function testFuzz_meter_largeBlockDiff_succeeds(uint64 _amount, uint256 _blockDiff) external {
+        // This test fails if the following line is commented out.
+        // At 12 seconds per block, this number is effectively unreachable.
+        vm.assume(_blockDiff < 433576281058164217753225238677900874458691);
+
+        uint64 target = uint64(uint256(meter.TARGET_RESOURCE_LIMIT()));
+        uint64 elasticity = uint64(uint256(meter.ELASTICITY_MULTIPLIER()));
+        vm.assume(_amount < target * elasticity);
+        vm.roll(initialBlockNum + _blockDiff);
+        meter.use(_amount);
+    }
 }

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

@@ -28,6 +28,7 @@ const deployFn: DeployFunction = async (hre) => {
     L1StandardBridgeProxyWithSigner,
     L1ERC721BridgeProxy,
     L1ERC721BridgeProxyWithSigner,
+    SystemConfigProxy,
   ] = await getContractsFromArtifacts(hre, [
     {
       name: 'SystemDictatorProxy',
@@ -61,6 +62,11 @@ const deployFn: DeployFunction = async (hre) => {
       name: 'L1ERC721BridgeProxy',
       signerOrProvider: deployer,
     },
+    {
+      name: 'SystemConfigProxy',
+      iface: 'SystemConfig',
+      signerOrProvider: deployer,
+    },
   ])
 
   // If we have the key for the controller then we don't need to wait for external txns.
@@ -251,6 +257,36 @@ const deployFn: DeployFunction = async (hre) => {
           getDeploymentAddress(hre, 'Proxy__OVM_L1StandardBridge')
         )) === 1
       )
+
+      // Check the SystemConfig was initialized properly.
+      await assertContractVariable(
+        SystemConfigProxy,
+        'owner',
+        hre.deployConfig.finalSystemOwner
+      )
+      await assertContractVariable(
+        SystemConfigProxy,
+        'overhead',
+        hre.deployConfig.gasPriceOracleOverhead
+      )
+      await assertContractVariable(
+        SystemConfigProxy,
+        'scalar',
+        hre.deployConfig.gasPriceOracleScalar
+      )
+      await assertContractVariable(
+        SystemConfigProxy,
+        'batcherHash',
+        ethers.utils.hexZeroPad(
+          hre.deployConfig.batchSenderAddress.toLowerCase(),
+          32
+        )
+      )
+      await assertContractVariable(
+        SystemConfigProxy,
+        'gasLimit',
+        hre.deployConfig.l2GenesisBlockGasLimit
+      )
     },
   })
 

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

@@ -30,7 +30,6 @@ const deployFn: DeployFunction = async (hre) => {
     OptimismPortal,
     OptimismMintableERC20Factory,
     L1ERC721Bridge,
-    SystemConfigProxy,
   ] = await getContractsFromArtifacts(hre, [
     {
       name: 'SystemDictatorProxy',
@@ -78,11 +77,6 @@ const deployFn: DeployFunction = async (hre) => {
       iface: 'L1ERC721Bridge',
       signerOrProvider: deployer,
     },
-    {
-      name: 'SystemConfigProxy',
-      iface: 'SystemConfig',
-      signerOrProvider: deployer,
-    },
   ])
 
   // If we have the key for the controller then we don't need to wait for external txns.
@@ -286,40 +280,6 @@ const deployFn: DeployFunction = async (hre) => {
         'messenger',
         L1CrossDomainMessenger.address
       )
-
-      // Check the SystemConfig was initialized properly.
-      await assertContractVariable(
-        SystemConfigProxy,
-        'owner',
-        hre.deployConfig.finalSystemOwner
-      )
-
-      await assertContractVariable(
-        SystemConfigProxy,
-        'overhead',
-        hre.deployConfig.gasPriceOracleOverhead
-      )
-
-      await assertContractVariable(
-        SystemConfigProxy,
-        'scalar',
-        hre.deployConfig.gasPriceOracleScalar
-      )
-
-      await assertContractVariable(
-        SystemConfigProxy,
-        'batcherHash',
-        ethers.utils.hexZeroPad(
-          hre.deployConfig.batchSenderAddress.toLowerCase(),
-          32
-        )
-      )
-
-      await assertContractVariable(
-        SystemConfigProxy,
-        'gasLimit',
-        hre.deployConfig.l2GenesisBlockGasLimit
-      )
     },
   })
 

packages/contracts-bedrock/package.json

@@ -29,7 +29,7 @@
     "coverage:lcov": "yarn build:differential && yarn build:fuzz && forge coverage --report lcov",
     "gas-snapshot": "yarn build:differential && yarn build:fuzz && forge snapshot --no-match-test 'testDiff|testFuzz|invariant'",
     "storage-snapshot": "./scripts/storage-snapshot.sh",
-    "validate-spacers": "hardhat validate-spacers",
+    "validate-spacers": "hardhat compile && hardhat validate-spacers",
     "slither": "./scripts/slither.sh",
     "clean": "rm -rf ./dist ./artifacts ./forge-artifacts ./cache ./tsconfig.tsbuildinfo ./tsconfig.build.tsbuildinfo ./src/contract-artifacts.ts ./test-case-generator/fuzz",
     "lint:ts:check": "eslint . --max-warnings=0",

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

@@ -56,7 +56,7 @@ interface RequiredDeployConfig {
   sequencerWindowSize: number
 
   /**
-   * Number of seconds (w.r.t. L1 time) that a frame can be valid when included in L1.
+   * Number of L1 blocks that a frame stays valid when included in L1.
    */
   channelTimeout: number
 

packages/contracts-bedrock/tasks/wait-for-final-batch.ts

@@ -48,26 +48,31 @@ task('wait-for-final-batch', 'Waits for the final batch to be submitted')
     const wait = async (contract: Contract) => {
       let height = await l2Provider.getBlockNumber()
       let totalElements = await contract.getTotalElements()
-      // The genesis block was not batch submitted so subtract 1 from the height
-      // when comparing with the total elements
-      while (totalElements !== height - 1) {
+      console.log(`  - height: ${height}`)
+      console.log(`  - totalElements: ${totalElements}`)
+
+      while (totalElements.toNumber() !== height) {
         console.log('Total elements does not match')
-        console.log(`  - real height: ${height}`)
-        console.log(`  - height: ${height - 1}`)
+        console.log(`  - height: ${height}`)
         console.log(`  - totalElements: ${totalElements}`)
+        console.log(
+          `Waiting for ${height - totalElements} elements to be submitted`
+        )
         totalElements = await contract.getTotalElements()
         height = await l2Provider.getBlockNumber()
-        await sleep(2 * 1000)
+        await sleep(5 * 1000)
       }
     }
 
     console.log('Waiting for the CanonicalTransactionChain...')
     await wait(CanonicalTransactionChain)
     console.log('All transaction batches have been submitted')
+    console.log()
 
     console.log('Waiting for the StateCommitmentChain...')
     await wait(StateCommitmentChain)
     console.log('All state root batches have been submitted')
+    console.log()
 
     console.log('All batches have been submitted')
   })

packages/contracts-bedrock/tasks/wait-for-final-deposit.ts

@@ -22,6 +22,7 @@ task('wait-for-final-deposit', 'Waits for the final deposit to be ingested')
     const l1Provider = new hre.ethers.providers.StaticJsonRpcProvider(
       args.l1RpcUrl
     )
+
     const l2Provider = new hre.ethers.providers.StaticJsonRpcProvider(
       args.l2RpcUrl
     )
@@ -63,6 +64,9 @@ task('wait-for-final-deposit', 'Waits for the final deposit to be ingested')
 
     console.log(`DTL shutoff block ${dtlShutoffBlock.toString()}`)
 
+    let pending = await CanonicalTransactionChain.getNumPendingQueueElements()
+    console.log(`${pending} deposits must be batch submitted`)
+
     // Now query the number of queue elements in the CTC
     const queueLength = await CanonicalTransactionChain.getQueueLength()
     console.log(`Total number of deposits: ${queueLength}`)
@@ -80,11 +84,10 @@ task('wait-for-final-deposit', 'Waits for the final deposit to be ingested')
 
       if (tx.queueOrigin === 'l1') {
         const queueIndex = BigNumber.from(tx.queueIndex).toNumber()
-        if (queueIndex === queueLength) {
+        if (queueIndex === queueLength - 1) {
           break
         }
         if (queueIndex < queueLength) {
-          console.log()
           throw new Error(
             `Missed the final deposit. queueIndex ${queueIndex}, queueLength ${queueLength}`
           )
@@ -94,4 +97,6 @@ task('wait-for-final-deposit', 'Waits for the final deposit to be ingested')
     }
 
     console.log('Final deposit has been ingested by l2geth')
+    pending = await CanonicalTransactionChain.getNumPendingQueueElements()
+    console.log(`${pending} deposits must be batch submitted`)
   })

packages/contracts/deployments/goerli/README.md

@@ -3,6 +3,10 @@
 - **Chain ID**: 420
 - **Public RPC**: https://goerli.optimism.io
 - **Block Explorer**: https://goerli-optimism.etherscan.io/
+
+**Note:** This list is out of date, now that Goerli is on bedrock.
+[The valid list is here](https://github.com/ethereum-optimism/optimism/tree/develop/packages/contracts-bedrock/deployments/goerli).
+
 ## Layer 1 Contracts
 <table>
 <tr>

packages/data-transport-layer/CHANGELOG.md

 # data transport layer
 
+## 0.5.51
+
+### Patch Changes
+
+- 4396e187d: Fixes a bug in the DTL that would cause it to not be able to sync beyond the deposit shutoff block.
+
 ## 0.5.50
 
 ### Patch Changes

packages/data-transport-layer/package.json

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

packages/data-transport-layer/src/services/l1-ingestion/service.ts

@@ -268,16 +268,16 @@ export class L1IngestionService extends BaseService<L1IngestionServiceOptions> {
           )
         }
 
-        // I prefer to do this in serial to avoid non-determinism. We could have a discussion about
-        // using Promise.all if necessary, but I don't see a good reason to do so unless parsing is
-        // really, really slow for all event types.
-        await this._syncEvents(
-          'CanonicalTransactionChain',
-          'TransactionEnqueued',
-          highestSyncedL1Block,
-          depositTargetL1Block,
-          handleEventsTransactionEnqueued
-        )
+        // We should not sync TransactionEnqueued events beyond the deposit shutoff block.
+        if (depositTargetL1Block >= highestSyncedL1Block) {
+          await this._syncEvents(
+            'CanonicalTransactionChain',
+            'TransactionEnqueued',
+            highestSyncedL1Block,
+            depositTargetL1Block,
+            handleEventsTransactionEnqueued
+          )
+        }
 
         await this._syncEvents(
           'CanonicalTransactionChain',

specs/batcher.md

@@ -4,10 +4,10 @@
 The batch submitter, also referred to as the batcher, is the entity submitting the L2 sequencer data to L1,
 to make it available for verifiers.
 
-[derivation-spec]: ./derivation.md
+[derivation spec]: derivation.md
 
-The format of the data transactions is defined in the [derivation spec]: the data is constructed from L2 blocks
-in the reverse order as it is derived from data into L2 blocks.
+The format of the data transactions is defined in the [derivation spec]:
+the data is constructed from L2 blocks in the reverse order as it is derived from data into L2 blocks.
 
 The timing, operation and transaction signing is implementation-specific: any data can be submitted at any time,
 but only the data that matches the [derivation spec] rules will be valid from the verifier perspective.

specs/derivation.md

@@ -5,7 +5,7 @@
 [g-payload-attr]: glossary.md#payload-attributes
 [g-block]: glossary.md#block
 [g-exec-engine]: glossary.md#execution-engine
-[g-reorg]: glossary.md#re-organization
+[g-reorg]: glossary.md#chain-re-organization
 [g-receipts]: glossary.md#receipt
 [g-inception]: glossary.md#L2-chain-inception
 [g-deposit-contract]: glossary.md#deposit-contract
@@ -27,7 +27,7 @@
 [g-batcher-transaction]: glossary.md#batcher-transaction
 [g-avail-provider]: glossary.md#data-availability-provider
 [g-batcher]: glossary.md#batcher
-[g-l2-output]: glossary.md#l2-output
+[g-l2-output]: glossary.md#l2-output-root
 [g-fault-proof]: glossary.md#fault-proof
 [g-channel]: glossary.md#channel
 [g-channel-frame]: glossary.md#channel-frame
@@ -69,30 +69,29 @@
       - [Timeouts](#timeouts)
       - [Reading](#reading)
       - [Loading frames](#loading-frames)
-    - [Batch Decoding](#batch-decoding)
-    - [Batch Buffering](#batch-buffering)
+    - [Channel Reader (Batch Decoding)](#channel-reader-batch-decoding)
+    - [Batch Queue](#batch-queue)
     - [Payload Attributes Derivation](#payload-attributes-derivation)
     - [Engine Queue](#engine-queue)
+      - [Engine API usage](#engine-api-usage)
+      - [Forkchoice synchronization](#forkchoice-synchronization)
+      - [L1-consolidation: payload attributes matching](#l1-consolidation-payload-attributes-matching)
+      - [L1-sync: payload attributes processing](#l1-sync-payload-attributes-processing)
+      - [Processing unsafe payload attributes](#processing-unsafe-payload-attributes)
     - [Resetting the Pipeline](#resetting-the-pipeline)
+      - [Finding the sync starting point](#finding-the-sync-starting-point)
+      - [Resetting derivation stages](#resetting-derivation-stages)
+      - [About reorgs Post-Merge](#about-reorgs-post-merge)
 - [Deriving Payload Attributes](#deriving-payload-attributes)
   - [Deriving the Transaction List](#deriving-the-transaction-list)
   - [Building Individual Payload Attributes](#building-individual-payload-attributes)
-- [Communication with the Execution Engine](#communication-with-the-execution-engine)
-- [WARNING: BELOW THIS LINE, THE SPEC HAS NOT BEEN REVIEWED AND MAY CONTAIN MISTAKES](#warning-below-this-line-the-spec-has-not-been-reviewed-and-may-contain-mistakes)
-- [Handling L1 Re-Orgs](#handling-l1-re-orgs)
-  - [Resetting the Engine Queue](#resetting-the-engine-queue)
-  - [Resetting Payload Attribute Derivation](#resetting-payload-attribute-derivation)
-  - [Resetting Batch Decoding](#resetting-batch-decoding)
-  - [Resetting Channel Buffering](#resetting-channel-buffering)
-  - [Resetting L1 Retrieval & L1 Traversal](#resetting-l1-retrieval--l1-traversal)
-  - [Reorgs Post-Merge](#reorgs-post-merge)
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 
 # Overview
 
 > **Note** the following assumes a single sequencer and batcher. In the future, the design will be adapted to
-> accomodate multiple such entities.
+> accommodate multiple such entities.
 
 [L2 chain derivation][g-derivation] — deriving L2 [blocks][g-block] from L1 data — is one of the main responsibility of
 the [rollup node][g-rollup-node], both in validator mode, and in sequencer mode (where derivation acts as a sanity check
@@ -105,7 +104,7 @@ L1 block number.
 To derive the L2 blocks in an epoch `E`, we need the following inputs:
 
 - The L1 [sequencing window][g-sequencing-window] for epoch `E`: the L1 blocks in the range `[E, E + SWS)` where `SWS`
-  is the sequencing window size (note that this means that epochs are overlapping). In particular we need:
+  is the sequencing window size (note that this means that epochs are overlapping). In particular, we need:
   - The [batcher transactions][g-batcher-transaction] included in the sequencing window. These allow us to
       reconstruct [sequencer batches][g-sequencer-batch] containing the transactions to include in L2 blocks (each batch
       maps to a single L2 block).
@@ -118,12 +117,10 @@ To derive the L2 blocks in an epoch `E`, we need the following inputs:
   [L2 genesis state][g-l2-genesis].
   - An epoch `E` does not exist if `E <= L2CI`, where `L2CI` is the [L2 chain inception][g-l2-chain-inception].
 
-> **TODO** specify sequencing window size (current thinking: on the order of a few hours, to give maximal flexibility to
-> the batch submitter)
-
 To derive the whole L2 chain from scratch, we simply start with the [L2 genesis state][g-l2-genesis], and the [L2 chain
 inception][g-l2-chain-inception] as first epoch, then process all sequencing windows in order. Refer to the
 [Architecture section][architecture] for more information on how we implement this in practice.
+The L2 chain may contain pre-Bedrock history, but the L2 genesis here refers to the first Bedrock L2 block.
 
 Each epoch may contain a variable number of L2 blocks (one every `l2_block_time`, 2s on Optimism), at the discretion of
 [the sequencer][g-sequencer], but subject to the following constraints for each block:
@@ -139,30 +136,28 @@ Each epoch may contain a variable number of L2 blocks (one every `l2_block_time`
     - `l1_timestamp` is the timestamp of the L1 block associated with the L2 block's epoch
     - `max_sequencer_drift` is the most a sequencer is allowed to get ahead of L1
 
-> **TODO** specify max sequencer drift (current thinking: on the order of 10
-> minutes, we've been using 2-4 minutes in testnets)
-
 Put together, these constraints mean that there must be an L2 block every `l2_block_time` seconds, and that the
 timestamp for the first L2 block of an epoch must never fall behind the timestamp of the L1 block matching the epoch.
 
 Post-merge, Ethereum has a fixed [block time][g-block-time] of 12s (though some slots can be skipped). It is thus
-expected that, most of the time, each epoch on Optimism will contain `12/2 = 6` L2 blocks. The sequencer can however
-lengthen or shorten epochs (subject to above constraints). The rationale is to maintain liveness in case of either a
-skipped slot on L1, or a temporary loss of connection to L1 — which requires longer epochs. Shorter epochs are then
-required to avoid L2 timestamps drifting further and further ahead of L1.
+expected that with a 2-second L2 block time, most of the time, each epoch will contain `12/2 = 6` L2 blocks.
+The sequencer can however lengthen or shorten epochs (subject to above constraints).
+The rationale is to maintain liveness in case of either a skipped slot on L1, or a temporary loss of connection to L1 —
+which requires longer epochs.
+Shorter epochs are then required to avoid L2 timestamps drifting further and further ahead of L1.
 
 ## Eager Block Derivation
 
-In practice, it is often not necesary to wait for a full sequencing window of L1 blocks in order to start deriving the
+In practice, it is often not necessary to wait for a full sequencing window of L1 blocks in order to start deriving the
 L2 blocks in an epoch. Indeed, as long as we are able to reconstruct sequential batches, we can start deriving the
 corresponding L2 blocks. We call this *eager block derivation*.
 
 However, in the very worst case, we can only reconstruct the batch for the first L2 block in the epoch by reading the
 last L1 block of the sequencing window. This happens when some data for that batch is included in the last L1 block of
-the window. In that case, not only can we not derive the first L2 block in the poch, we also can't derive any further L2
-block in the epoch until then, as they need the state that results from applying the epoch's first L2 block. (Note that
-this only applies to *block* derivation. We can still derive further batches, we just won't be able to create blocks
-from them.)
+the window. In that case, not only can we not derive the first L2 block in the epoch, we also cannot derive any further
+L2 block in the epoch until then, as they need the state that results from applying the epoch's first L2 block.
+(Note that this only applies to *block* derivation. Batches can still be derived and tentatively queued,
+we just won't be able to create blocks from them.)
 
 ------------------------------------------------------------------------------------------------------------------------
 
@@ -182,8 +177,8 @@ reference to the previous block (\*).
 (\*) This matters in some edge case where a L1 reorg would occur and a batch would be reposted to the L1 chain but not
 the preceding batch, whereas the predecessor of an L2 block cannot possibly change.
 
-This means that even if the sequencer applies a state transition incorrectly, the transactions in the batch will stil be
-considered part of the canonical L2 chain. Batches are still subject to validity checks (i.e. they have to be encoded
+This means that even if the sequencer applies a state transition incorrectly, the transactions in the batch will still
+be considered part of the canonical L2 chain. Batches are still subject to validity checks (i.e. they have to be encoded
 correctly), and so are individual transactions within the batch (e.g. signatures have to be valid). Invalid batches and
 invalid individual transactions within an otherwise valid batch are discarded by correct nodes.
 
@@ -195,17 +190,6 @@ Refer to the [Batch Submission specification][batcher-spec] for more information
 
 [batcher-spec]: batcher.md
 
-> **TODO** rewrite the batch submission specification
->
-> Here are some things that should be included there:
->
-> - There may be different concurrent data submissions to L1
-> - There may be different actors that submit the data, the system cannot rely on a single EOA nonce value.
-> - The batcher requests safe L2 safe head from the rollup node, then queries the execution engine for the block data.
->   - In the future we might be able to get the safe hea dinformation from the execution engine directly. Not possible
->     right now but there is an upstream geth PR open.
-> - specify batcher authentication (cf. TODO below)
-
 ## Batch Submission Wire Format
 
 [wire-format]: #batch-submission-wire-format
@@ -217,7 +201,7 @@ The [batcher][g-batcher] submits [batcher transactions][g-batcher-transaction] t
 provider][g-avail-provider]. These transactions contain one or multiple [channel frames][g-channel-frame], which are
 chunks of data belonging to a [channel][g-channel].
 
-A [channel][g-channel] is a sequence of [sequencer batches][g-sequencer-batch] (for sequential blocks) compressed
+A [channel][g-channel] is a sequence of [sequencer batches][g-sequencer-batch] (for any L2 blocks) compressed
 together. The reason to group multiple batches together is simply to obtain a better compression rate, hence reducing
 data availability costs.
 
@@ -227,15 +211,20 @@ into chunks known as [channel frames][g-channel-frame]. A single batcher transac
 
 This design gives use the maximum flexibility in how we aggregate batches into channels, and split channels over batcher
 transactions. It notably allows us to maximize data utilisation in a batcher transaction: for instance it allows us to
-pack the final (small) frame of a window with large frames from the next window. It also allows the [batcher][g-batcher]
-to employ multiple signers (private keys) to submit one or multiple channels in parallel (1).
+pack the final (small) frame of a window with large frames from the next window.
 
-(1) This helps alleviate issues where, because of transaction nonces, multiple transactions made by the same signer are
-stuck waiting on the inclusion of a previous transaction.
+In the future this channel identification feature also allows the [batcher][g-batcher] to employ multiple signers
+(private keys) to submit one or multiple channels in parallel (1).
+
+(1) This helps alleviate issues where, because of transaction nonce values affecting the L2 tx-pool and thus inclusion:
+multiple transactions made by the same signer are stuck waiting on the inclusion of a previous transaction.
 
 Also note that we use a streaming compression scheme, and we do not need to know how many blocks a channel will end up
 containing when we start a channel, or even as we send the first frames in the channel.
 
+And by splitting channels across multiple data transactions, the L2 can have larger block data than the
+data-availability layer may support.
+
 All of this is illustrated in the following diagram. Explanations below.
 
 ![batch derivation chain diagram](./assets/batch-deriv-chain.svg)
@@ -253,7 +242,7 @@ Each colored chunk within the boxes represents a [channel frame][g-channel-frame
 
 In the next line, the rounded boxes represent individual [sequencer batches][g-sequencer-batch] that were extracted from
 the channels. The four blue/purple/pink were derived from channel `A` while the other were derived from channel `B`.
-These batches are here represented in the order the were decoded from batches (in this case `B` is decoded first).
+These batches are here represented in the order they were decoded from batches (in this case `B` is decoded first).
 
 > **Note** The caption here says "Channel B was seen first and will be decoded into batches first", but this is not a
 > requirement. For instance, it would be equally acceptable for an implementation to peek into the channels and decode
@@ -263,7 +252,7 @@ The rest of the diagram is conceptually distinct from the first part and illustr
 channels have been reordered.
 
 The first line shows batcher transactions. Note that in this case, there exists an ordering of the batches that makes
-all frames within the channels appear contiguously. This is not true in true in general. For instance, in the second
+all frames within the channels appear contiguously. This is not true in general. For instance, in the second
 transaction, the position of `A1` and `B0` could have been inverted for exactly the same result — no changes needed in
 the rest of the diagram.
 
@@ -278,12 +267,12 @@ information about the L1 block that matches the L2 block's epoch. The first numb
 the second number (the "sequence number") denotes the position within the epoch.
 
 Finally, the sixth line shows [user-deposited transactions][g-user-deposited] derived from the [deposit
-contract][g-deposit-contract] event mentionned earlier.
+contract][g-deposit-contract] event mentioned earlier.
 
 Note the `101-0` L1 attributes transaction on the bottom right of the diagram. Its presence there is only possible if
 frame `B2` indicates that it is the last frame within the channel and (2) no empty blocks must be inserted.
 
-The diagram does not specify the sequencing window size in use, but from it we can infer that it must be at least 4
+The diagram does not specify the sequencing window size in use, but from this we can infer that it must be at least 4
 blocks, because the last frame of channel `A` appears in block 102, but belong to epoch 99.
 
 As for the comment on "security types", it explains the classification of blocks as used on L1 and L2.
@@ -295,8 +284,7 @@ As for the comment on "security types", it explains the classification of blocks
   than the [challenge period].
 
 These security levels map to the `headBlockHash`, `safeBlockHash` and `finalizedBlockHash` values transmitted when
-interacting with the [execution-engine API][exec-engine]. Refer to the the [Communication with the Execution
-Engine][exec-engine-comm] section for more information.
+interacting with the [execution-engine API][exec-engine].
 
 ### Batcher Transaction Format
 
@@ -391,7 +379,7 @@ Recall that a batch contains a list of transactions to be included in a specific
 A batch is encoded as `batch_version ++ content`, where `content` depends on the `batch_version`:
 
 | `batch_version` | `content`                                                                          |
-| --------------- |------------------------------------------------------------------------------------|
+|-----------------|------------------------------------------------------------------------------------|
 | 0               | `rlp_encode([parent_hash, epoch_number, epoch_hash, timestamp, transaction_list])` |
 
 where:
@@ -410,8 +398,8 @@ where:
 
 Unknown versions make the batch invalid (it must be ignored by the rollup node), as do malformed contents.
 
-The `epoch_number` and the `timestamp` must also respect the constraints listed in the [Batch
-Buffering][batch-buffering] section, otherwise the batch is considered invalid.
+The `epoch_number` and the `timestamp` must also respect the constraints listed in the [Batch Queue][batch-queue]
+section, otherwise the batch is considered invalid and will be ignored.
 
 ------------------------------------------------------------------------------------------------------------------------
 
@@ -419,15 +407,12 @@ Buffering][batch-buffering] section, otherwise the batch is considered invalid.
 
 [architecture]: #architecture
 
-The above describes the general process of L2 chain derivation, and specifies how batches are encoded within [batcher
-transactions][g-batcher-transaction].
+The above primarily describes the general encodings used in L2 chain derivation,
+primarily how batches are encoded within [batcher transactions][g-batcher-transaction].
 
-However, there remains many details to specify. These are mostly tied to the rollup node architecture for derivation.
-Therefore we present this architecture as a way to specify these details.
+This section describes how the L2 chain is produced from the L1 batches using a pipeline architecture.
 
-A validator that only reads from L1 (and so doesn't interact with the sequencer directly) does not need to be
-implemented in the way presented below. It does however need to derive the same blocks (i.e. it needs to be semantically
-equivalent). We do believe the architecture presented below has many advantages.
+A verifier may implement this differently, but must be semantically equivalent to not diverge from the L2 chain.
 
 ## L2 Chain Derivation Pipeline
 
@@ -437,16 +422,15 @@ Our architecture decomposes the derivation process into a pipeline made up of th
 
 1. L1 Traversal
 2. L1 Retrieval
-3. Channel Bank
-4. Batch Decoding (called `ChannelInReader` in the code)
-5. Batch Buffering (Called `BatchQueue` in the code)
-6. Payload Attributes Derivation (called `AttributesQueue` in the code)
-7. Engine Queue
+3. Frame Queue
+4. Channel Bank
+5. Channel Reader (Batch Decoding)
+6. Batch Queue
+7. Payload Attributes Derivation
+8. Engine Queue
 
-> **TODO** can we change code names for these three things? maybe as part of a refactor
-
-The data flows flows from the start (outer) of the pipeline towards the end (inner). Each stage is able to push data to
-the next stage.
+The data flows from the start (outer) of the pipeline towards the end (inner).
+From the innermost stage the data is pulled from the outermost stage.
 
 However, data is *processed* in reverse order. Meaning that if there is any data to be processed in the last stage, it
 will be processed first. Processing proceeds in "steps" that can be taken at each stage. We try to take as many steps as
@@ -455,9 +439,11 @@ possible in the last (most inner) stage before taking any steps in its outer sta
 This ensures that we use the data we already have before pulling more data and minimizes the latency of data traversing
 the derivation pipeline.
 
-Each stage can maintain its own inner state as necessary. **In particular, each stage maintains a L1 block reference
+Each stage can maintain its own inner state as necessary. In particular, each stage maintains a L1 block reference
 (number + hash) to the latest L1 block such that all data originating from previous blocks has been fully processed, and
-the data from that block is being or has been processed.**
+the data from that block is being or has been processed. This allows the innermost stage to account for finalization of
+the L1 data-availability used to produce the L2 chain, to reflect in the L2 chain forkchoice when the L2 chain inputs
+become irreversible.
 
 Let's briefly describe each stage of the pipeline.
 
@@ -547,16 +533,16 @@ Frame insertion conditions:
 
 If a frame is closing (`is_last == 1`) any existing higher-numbered frames are removed from the channel.
 
-### Batch Decoding
+### Channel Reader (Batch Decoding)
 
-In the *Batch Decoding* stage, we decompress the channel we received in the last stage, then parse
+In this stage, we decompress the channel we pull from the last stage, and then parse
 [batches][g-sequencer-batch] from the decompressed byte stream.
 
 See [Batch Format][batch-format] for decompression and decoding specification.
 
-### Batch Buffering
+### Batch Queue
 
-[batch-buffering]: #batch-buffering
+[batch-queue]: #batch-queue
 
 During the *Batch Buffering* stage, we reorder batches by their timestamps. If batches are missing for some [time
 slots][g-time-slot] and a valid batch with a higher timestamp exists, this stage also generates empty batches to fill
@@ -578,6 +564,7 @@ A batch can have 4 different forms of validity:
 - `future`: the batch may be valid, but cannot be processed yet and should be checked again later.
 
 The batches are processed in order of the inclusion on L1: if multiple batches can be `accept`-ed the first is applied.
+An implementation can defer `future` batches a later derivation step to reduce validation work.
 
 The batches validity is derived as follows:
 
@@ -649,32 +636,83 @@ The system configuration is updated with L1 log events whenever the L1 epoch ref
 In the *Engine Queue* stage, the previously derived `PayloadAttributes` structures are buffered and sent to the
 [execution engine][g-exec-engine] to be executed and converted into a proper L2 block.
 
-The engine queue maintains references to two L2 blocks:
+The stage maintains references to three L2 blocks:
 
+- The [finalized L2 head][g-finalized-l2-head]: everything up to and including this block can be fully derived from the
+  [finalized][l1-finality] (i.e. canonical and forever irreversible) part of the L1 chain.
 - The [safe L2 head][g-safe-l2-head]: everything up to and including this block can be fully derived from the
-  canonical L1 chain.
+  currently canonical L1 chain.
 - The [unsafe L2 head][g-unsafe-l2-head]: blocks between the safe and unsafe heads are [unsafe
   blocks][g-unsafe-l2-block] that have not been derived from L1. These blocks either come from sequencing (in sequencer
   mode) or from [unsafe sync][g-unsafe-sync] to the sequencer (in validator mode).
+  This is also known as the "latest" head.
+
+Additionally, it buffers a short history of references to recently processed safe L2 blocks, along with references
+from which L1 blocks each was derived.
+This history does not have to be complete, but enables later L1 finality signals to be translated into L2 finality.
+
+#### Engine API usage
+
+To interact with the engine, the [execution engine API][exec-engine] is used, with the following JSON-RPC methods:
 
-If the unsafe head is ahead of the safe head, then [consolidation][g-consolidation] is attempted.
+[exec-engine]: exec-engine.md
+
+- [`engine_forkchoiceUpdatedV1`] — updates the forkchoice (i.e. the chain head) to `headBlockHash` if different, and
+  instructs the engine to start building an execution payload if the payload attributes parameter is not `null`.
+- [`engine_getPayloadV1`] — retrieves a previously requested execution payload build.
+- [`engine_newPayloadV1`] — executes an execution payload to create a block.
+
+[`engine_forkchoiceUpdatedV1`]: exec-engine.md#engine_forkchoiceupdatedv1
+[`engine_getPayloadV1`]: exec-engine.md#engine_getpayloadv1
+[`engine_newPayloadV1`]: exec-engine.md#engine_newpayloadv1
+
+The execution payload is an object of type [`ExecutionPayloadV1`][eth-payload].
+
+[eth-payload]: https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#executionpayloadv1
+
+#### Forkchoice synchronization
+
+If there are any forkchoice updates to be applied, before additional inputs are derived or processed, then these are
+applied to the engine first.
+
+This synchronization may happen when:
+
+- A L1 finality signal finalizes one or more L2 blocks: updating the "finalized" L2 block.
+- A successful consolidation of unsafe L2 blocks: updating the "safe" L2 block.
+- The first thing after a derivation pipeline reset, to ensure a consistent execution engine forkchoice state.
+
+The new forkchoice state is applied with `engine_forkchoiceUpdatedV1`.
+On forkchoice-state validity errors the derivation pipeline must be reset to recover to consistent state.
+
+#### L1-consolidation: payload attributes matching
+
+If the unsafe head is ahead of the safe head, then [consolidation][g-consolidation] is attempted, verifying that
+existing unsafe L2 chain matches the derived L2 inputs as derived from the canonical L1 data.
 
 During consolidation, we consider the oldest unsafe L2 block, i.e. the unsafe L2 block directly after the safe head. If
 the payload attributes match this oldest unsafe L2 block, then that block can be considered "safe" and becomes the new
 safe head.
 
-In particular, the following fields of the payload attributes are checked for equality with the block:
+The following fields of the derived L2 payload attributes are checked for equality with the L2 block:
 
 - `parent_hash`
 - `timestamp`
 - `randao`
 - `fee_recipient`
-- `transactions_list` (first length, then equality of each of the encoded transactions)
+- `transactions_list` (first length, then equality of each of the encoded transactions, including deposits)
+
+If consolidation succeeds, the forkchoice change will synchronize as described in the section above.
 
-If consolidation fails, the unsafe L2 head is reset to the safe L2 head.
+If consolidation fails, the L2 payload attributes will be processed immediately as described in the section below.
+The payload attributes are chosen in favor of the previous unsafe L2 block, creating an L2 chain reorg on top of the
+current safe block. Immediately processing the new alternative attributes enables execution engines like go-ethereum to
+enact the change, as linear rewinds of the tip of the chain may not be supported.
 
-If the safe and unsafe L2 heads are identical (whether because of failed consolidation or not), we send the block to the
-execution engine to be converted into a proper L2 block, which will become both the new L2 safe and unsafe head.
+#### L1-sync: payload attributes processing
+
+If the safe and unsafe L2 heads are identical (whether because of failed consolidation or not), we send the L2 payload
+attributes to the execution engine to be constructed into a proper L2 block.
+This L2 block will then become both the new L2 safe and unsafe head.
 
 If a payload attributes created from a batch cannot be inserted into the chain because of a validation error (i.e. there
 was an invalid transaction or state transition in the block) the batch should be dropped & the safe head should not be
@@ -685,10 +723,136 @@ always valid.
 Interaction with the execution engine via the execution engine API is detailed in the [Communication with the Execution
 Engine][exec-engine-comm] section.
 
+The payload attributes are then processed with a sequence of:
+
+- `engine_forkchoiceUpdatedV1` with current forkchoice state of the stage, and the attributes to start block building.
+  - Non-deterministic sources, like the tx-pool, must be disabled to reconstruct the expected block.
+- `engine_getPayload` to retrieve the payload, by the payload-ID in the result of the previous step.
+- `engine_forkchoiceUpdatedV1` to make the new payload canonical,
+   now with a change of both `safe` and `unsafe` fields to refer to the payload, and no payload attributes.
+
+Engine API Error handling:
+
+- On RPC-type errors the payload attributes processing should be re-attempted in a future step.
+- On payload processing errors the attributes must be dropped, and the forkchoice state must be left unchanged.
+  - Eventually the derivation pipeline will produce alternative payload attributes, with or without batches.
+  - If the payload attributes only contained deposits, then it is a critical derivation error if these are invalid.
+- On forkchoice-state validity errors the derivation pipeline must be reset to recover to consistent state.
+
+#### Processing unsafe payload attributes
+
+If no forkchoice updates or L1 data remain to be processed, and if the next possible L2 block is already available
+through an unsafe source such as the sequencer publishing it via the p2p network, then it is optimistically processed as
+an "unsafe" block. This reduces later derivation work to just consolidation with L1 in the happy case, and enables the
+user to see the head of the L2 chain faster than the L1 may confirm the L2 batches.
+
+To process unsafe payloads, the payload must:
+
+- Have a block number higher than the current safe L2 head.
+  - The safe L2 head may only be reorged out due to L1 reorgs.
+- Have a parent blockhash that matches the current unsafe L2 head.
+  - This prevents the execution engine individually syncing a larger gap in the unsafe L2 chain.
+  - This prevents unsafe L2 blocks from reorging other previously validated L2 blocks.
+  - This check may change in the future versions to adopt e.g. the L1 snap-sync protocol.
+
+The payload is then processed with a sequence of:
+
+- `engine_newPayloadV1`: process the payload. It does not become canonical yet.
+- `engine_forkchoiceUpdatedV1`: make the payload the canonical unsafe L2 head, and keep the safe/finalized L2 heads.
+
+Engine API Error handling:
+
+- On RPC-type errors the payload processing should be re-attempted in a future step.
+- On payload processing errors the payload must be dropped, and not be marked as canonical.
+- On forkchoice-state validity errors the derivation pipeline must be reset to recover to consistent state.
+
 ### Resetting the Pipeline
 
-It is possible to reset the pipeline, for instance if we detect an L1 [re-org][g-reorg]. For more details on this, see
-the [Handling L1 Re-Orgs][handling-reorgs] section.
+It is possible to reset the pipeline, for instance if we detect an L1 [reorg (reorganization)][g-reorg].
+**This enables the rollup node to handle L1 chain reorg events.**
+
+Resetting will recover the pipeline into a state that produces the same outputs as a full L2 derivation process,
+but starting from an existing L2 chain that is traversed back just enough to reconcile with the current L1 chain.
+
+Note that this algorithm covers several important use-cases:
+
+- Initialize the pipeline without starting from 0, e.g. when the rollup node restarts with an existing engine instance.
+- Recover the pipeline if it becomes inconsistent with the execution engine chain, e.g. when the engine syncs/changes.
+- Recover the pipeline when the L1 chain reorganizes, e.g. a late L1 block is orphaned, or a larger attestation failure.
+- Initialize the pipeline to derive a disputed L2 block with prior L1 and L2 history inside a fault-proof program.
+
+Handling these cases also means a node can be configured to eagerly sync L1 data with 0 confirmations,
+as it can undo the changes if the L1 later does recognize the data as canonical, enabling safe low-latency usage.
+
+The Engine Queue is first reset, to determine the L1 and L2 starting points to continue derivation from.
+After this, the other stages are reset independent of each other.
+
+#### Finding the sync starting point
+
+To find the starting point, there are several steps, relative to the head of the chain traversing back:
+
+1. Find the current L2 forkchoice state
+   - If no `finalized` block can be found, start at the Bedrock genesis block.
+   - If no `safe` block can be found, fallback to the `finalized` block.
+   - The `unsafe` block should always be available and consistent with the above
+     (it may not be in rare engine-corruption recovery cases, this is being reviewed).
+2. Find the first L2 block with plausible L1 reference to be the new `unsafe` starting point,
+   starting from previous `unsafe`, back to `finalized` and no further.
+   - Plausible iff: the L1 origin of the L2 block is known and canonical, or unknown and has a block-number ahead of L1.
+3. Find the first L2 block with an L1 reference older than the sequencing window, to be the new `safe` starting point,
+   starting at the above plausible `unsafe` head, back to `finalized` and no further.
+   - If at any point the L1 origin is known but not canonical, the `unsafe` head is revised to parent of the current.
+   - The highest L2 block with known canonical L1 origin is remembered as `highest`.
+   - If at any point the L1 origin in the block is corrupt w.r.t. derivation rules, then error. Corruption includes:
+     - Inconsistent L1 origin block number or parent-hash with parent L1 origin
+     - Inconsistent L1 sequence number (always changes to `0` for a L1 origin change, or increments by `1` if not)
+   - If the L1 origin of the L2 block `n` is older than the L1 origin of `highest` by more than a sequence window,
+     and `n.sequence_number == 0`, then the parent L2 block of `n` will be the `safe` starting point.
+4. The `finalized` L2 block persists as the `finalized` starting point.
+5. Find the first L2 block with an L1 reference older than the channel-timeout
+   - The L1 origin referenced by this block which we call `l2base` will be the `base` for the L2 pipeline derivation:
+     By starting here, the stages can buffer any necessary data, while dropping incomplete derivation outputs until
+     L1 traversal has caught up with the actual L2 safe head.
+
+While traversing back the L2 chain, an implementation may sanity-check that the starting point is never set too far
+back compared to the existing forkchoice state, to avoid an intensive reorg because of misconfiguration.
+
+Implementers note: step 1-4 are known as `FindL2Heads`. Step 5 is currently part of the Engine Queue reset.
+This may change to isolate the starting-point search from the bare reset logic.
+
+#### Resetting derivation stages
+
+1. L1 Traversal: start at L1 `base` as first block to be pulled by next stage.
+2. L1 Retrieval: empty previous data, and fetch the `base` L1 data, or defer the fetching work to a later pipeline step.
+3. Frame Queue: empty the queue.
+4. Channel Bank: empty the channel bank.
+5. Channel Reader: reset any batch decoding state.
+6. Batch Queue: empty the batch queue, use `base` as initial L1 point of reference.
+7. Payload Attributes Derivation: empty any batch/attributes state.
+8. Engine Queue:
+   - Initialize L2 forkchoice state with syncing start point state. (`finalized`/`safe`/`unsafe`)
+   - Initialize the L1 point of reference of the stage to `base`.
+   - Require a forkchoice update as first task
+   - Reset any finality data
+
+Where necessary, stages starting at `base` can initialize their system-config from data encoded in the `l2base` block.
+
+#### About reorgs Post-Merge
+
+Note that post-[merge], the depth of reorgs will be bounded by the [L1 finality delay][l1-finality]
+(2 L1 beacon epochs, or approximately 13 minutes, unless more than 1/3 of the network consistently disagrees).
+New L1 blocks may be finalized every L1 beacon epoch (approximately 6.4 minutes), and depending on these
+finality-signals and batch-inclusion, the derived L2 chain will become irreversible as well.
+
+Note that this form of finalization only affects inputs, and nodes can then subjectively say the chain is irreversible,
+by reproducing the chain from these irreversible inputs and the set protocol rules and parameters.
+
+This is however completely unrelated to the outputs posted on L1, which require a form of proof like a fault-proof or
+zk-proof to finalize. Optimistic-rollup outputs like withdrawals on L1 are only labeled "finalized" after passing a week
+without dispute (fault proof challenge window), a name-collision with the proof-of-stake finalization.
+
+[merge]: https://ethereum.org/en/upgrades/merge/
+[l1-finality]: https://ethereum.org/en/developers/docs/consensus-mechanisms/pos/#finality
 
 ------------------------------------------------------------------------------------------------------------------------
 
@@ -696,9 +860,12 @@ the [Handling L1 Re-Orgs][handling-reorgs] section.
 
 [deriving-payload-attr]: #deriving-payload-attributes
 
-For every L2 block we wish to create, we need to build [payload attributes][g-payload-attr],
+For every L2 block derived from L1 data, we need to build [payload attributes][g-payload-attr],
 represented by an [expanded version][expanded-payload] of the [`PayloadAttributesV1`][eth-payload] object,
-which includes the additional `transactions` and `noTxPool` fields.
+which includes additional `transactions` and `noTxPool` fields.
+
+This process happens during the payloads-attributes queue ran by a verifier node, as well as during block-production
+ran by a sequencer node (the sequencer may enable the tx-pool usage if the transactions are batch-submitted).
 
 [expanded-payload]: exec-engine.md#extended-payloadattributesv1
 [eth-payload]: https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#payloadattributesv1
@@ -735,7 +902,8 @@ entries.
 
 [payload attributes]: #building-individual-payload-attributes
 
-After deriving the transaction list, the rollup node constructs a [`PayloadAttributesV1`][expanded-payload] as follows:
+After deriving the transactions list, the rollup node constructs a [`PayloadAttributesV1`][extended-attributes] as
+follows:
 
 - `timestamp` is set to the batch's timestamp.
 - `random` is set to the `prev_randao` L1 block attribute.
@@ -745,281 +913,4 @@ After deriving the transaction list, the rollup node constructs a [`PayloadAttri
 - `noTxPool` is set to `true`, to use the exact above `transactions` list when constructing the block.
 - `gasLimit` is set to the current `gasLimit` value in the [system configuration][g-system-config] of this payload.
 
-[expanded-payload]: exec-engine.md#extended-payloadattributesv1
-
-# Communication with the Execution Engine
-
-[exec-engine-comm]: #communication-with-the-execution-engine
-
-The [engine queue] is responsible for interacting with the execution engine, sending it
-[`PayloadAttributesV1`][expanded-payload] objects and receiving L2 block references as a result. This happens whenever
-the [safe L2 head][g-safe-l2-head] and the [unsafe L2 head][g-unsafe-l2-head] are identical, either because [unsafe
-block consolidation][g-consolidation] failed or because no [unsafe L2 blocks][g-unsafe-l2-block] were known in the first
-place. This section explains how this happens.
-
-> **Note** This only describes interaction with the execution engine in the context of L2 chain derivation from L1. The
-> sequencer also interacts with the engine when it needs to create new L2 blocks using L2 transactions submitted by
-> users.
-
-Let:
-
-- `safeL2Head` be a variable in the state of the execution engine, tracking the (hash of) the current [safe L2
-  head][g-safe-l2-head]
-- `unsafeL2Head` be a variable in the state of the execution engine, tracking the (hash of) the current [unsafe L2
-  head][g-unsafe-l2-head]
-- `finalizedL2Head` be a variable in the state of the execution engine, tracking the (hash of) the current [finalized L2
-  head][g-finalized-l2-head]
-  - This is not yet implemented, and currently always holds the zero hash — this does not prevent the pseudocode below
-      from working.
-- `payloadAttributes` be some previously derived [payload attributes][g-payload-attr] for the L2 block with number
-  `l2Number(safeL2Head) + 1`
-
-[finality]: https://hackmd.io/@prysmaticlabs/finality
-
-Then we can apply the following pseudocode logic to update the state of both the rollup driver and execution engine:
-
-```javascript
-
-
-fun makeL2Block(payloadAttributes) {
-
-    // request a new execution payload
-    forkChoiceState = {
-        headBlockHash: safeL2Head,
-        safeBlockHash: safeL2Head,
-        finalizedBlockHash: finalizedL2Head,
-    }
-
-    [status, payloadID, rpcErr] = engine_forkchoiceUpdatedV1(forkChoiceState, payloadAttributes)
-    if (rpcErr != null) return softError()
-    if (status != "VALID") return payloadError()
-
-    // retrieve and execute the execution payload
-    [executionPayload, rpcErr] = engine_getPayloadV1(payloadID)
-    if (rpcErr != null) return softError()
-
-    [status, rpcErr] = engine_newPayloadV1(executionPayload)
-    if (rpcErr != null) return softError()
-    if (status != "VALID") return payloadError()
-
-
-    newL2Head = executionPayload.blockHash
-
-    // update head to new refL2
-    forkChoiceState = {
-        headBlockHash: newL2Head,
-        safeBlockHash: newL2Head,
-        finalizedBlockHash: finalizedL2Head,
-    }
-    [status, payloadID, rpcErr] = engine_forkchoiceUpdatedV1(forkChoiceState, null)
-    if (rpcErr != null) return softError()
-    if (status != "SUCCESS") return payloadError()
-
-    return newL2Head
-}
-
-result = softError()
-
-while (isSoftError(result)) {
-    result = makeL2Block(payloadAttributes)
-    if (isPayloadError(result)) {
-        payloadAttributes = onlyDeposits(payloadAttributes)
-        result = makeL2Block(payloadAttributes)
-    }
-    if (isPayloadError(result)) {
-        panic("this should never happen")
-    }
-}
-
-if (!isError(result)) {
-    safeL2Head = result
-    unsafeL2Head = result
-}
-```
-
-> **TODO** `finalizedL2Head` is not being changed yet, but can be set to point to a L2 block fully derived from data up
-> to a finalized L1 block.
-
-As should apparent from the assignations, within the `forkChoiceState` object, the properties have the following
-meaning:
-
-- `headBlockHash`: block hash of the last block of the L2 chain, according to the sequencer.
-- `safeBlockHash`: same as `headBlockHash`.
-- `finalizedBlockHash`: the [finalized L2 head][g-finalized-l2-head].
-
-Error handling:
-
-- A value returned by `payloadError()` means the inputs were wrong.
-  - This could mean the sequencer included invalid transactions in the batch. **In this case, all transactions from the
-      batch should be dropped**. We assume this is the case, and modify the payload via `onlyDeposits` to only include
-      [deposited transactions][g-deposited], and retry.
-  - In the case of deposits, the [execution engine][g-exec-engine] will skip invalid transactions, so bad deposited
-      transactions should never cause a payload error.
-- A value returned by `softError()` means that the interaction failed by chance, and should be reattempted (this is the
-  purpose of the `while` loop in the pseudo-code).
-
-> **TODO** define "invalid transactions" properly, check the interpretation for the execution engine
-
-The following JSON-RPC methods are part of the [execution engine API][exec-engine]:
-
-[exec-engine]: exec-engine.md
-
-- [`engine_forkchoiceUpdatedV1`] — updates the forkchoice (i.e. the chain head) to `headBlockHash` if different, and
-  instructs the engine to start building an execution payload if the payload attributes isn't `null`
-- [`engine_getPayloadV1`] — retrieves a previously requested execution payload
-- [`engine_newPayloadV1`] — executes an execution payload to create a block
-
-[`engine_forkchoiceUpdatedV1`]: exec-engine.md#engine_forkchoiceUpdatedV1
-[`engine_getPayloadV1`]: exec-engine.md#engine_newPayloadV1
-[`engine_newPayloadV1`]: exec-engine.md#engine_newPayloadV1
-
-The execution payload is an object of type [`ExecutionPayloadV1`][eth-payload].
-
-[eth-payload]: https://github.com/ethereum/execution-apis/blob/main/src/engine/paris.md#executionpayloadv1
-
-------------------------------------------------------------------------------------------------------------------------
-
-# WARNING: BELOW THIS LINE, THE SPEC HAS NOT BEEN REVIEWED AND MAY CONTAIN MISTAKES
-
-We still expect that the explanations here should be pretty useful.
-
-------------------------------------------------------------------------------------------------------------------------
-
-# Handling L1 Re-Orgs
-
-[handling-reorgs]: #handling-l1-re-orgs
-
-The [L2 chain derivation pipeline][pipeline] as described above assumes linear progression of the L1 chain.
-
-If the L1 chain [re-orgs][g-reorg], the rollup node must re-derive sections of the L2 chain such that it derives the
-same L2 chain that a rollup node would derive if it only followed the new L1 chain.
-
-A re-org can be recovered without re-deriving the full L2 chain, by resetting each pipeline stage from end (Engine
-Queue) to start (L1 Traversal).
-
-The general idea is to backpropagate the new L1 head through the stages, and reset the state in each stage so that the
-stage will next process data originating from that block onwards.
-
-## Resetting the Engine Queue
-
-The engine queue maintains references to two L2 blocks:
-
-- The safe L2 block (or *safe head*): everything up to and including this block can be fully derived from the
-  canonical L1 chain.
-- The unsafe L2 block (or *unsafe head*): blocks between the safe and unsafe heads are blocks that have not been
-  derived from L1. These blocks either come from sequencing (in sequencer mode) or from "unsafe sync" to the sequencer
-  (in validator mode).
-
-When resetting the L1 head, we need to rollback the safe head such that the L1 origin of the new safe head is a
-canonical L1 block (i.e. an the new L1 head, or one of its ancestors). We achieved this by walking back the L2 chain
-(starting from the current safe head) until we find such an L2 block. While doing this, we must take care not to walk
-past the [L2 genesis][g-l2-genesis] or L1 genesis.
-
-The unsafe head does not necessarily need to be reset, as long as its L1 origin is *plausible*. The L1 origin of the
-unsafe head is considered plausible as long as it is in the canonical L1 chain or is ahead (higher number) than the head
-of the L1 chain. When we determine that this is no longer the case, we reset the unsafe head to be equal to the safe
-head.
-
-> **TODO** Don't we always need to discard the unsafe head when there is a L1 re-org, because the unsafe head's origin
-> builds on L1 blocks that have been re-orged away?
->
-> I'm guessing maybe we received some unsafe blocks that build upon the re-orged L2, which we accept without relating
-> them back to the safe head?
-
-## Resetting Payload Attribute Derivation
-
-In payload attribute derivation, we need to ensure that the L1 head is reset to the safe L2 head's L1 origin. In the
-worst case, this would be as far back as `SWS` ([sequencing window][g-sequencing-window] size) blocks before the engine
-queue's L1 head.
-
-In the worst case, a whole sequencing window of L1 blocks was required to derive the L2 safe head (meaning that
-`safeL2Head.l1Origin == engineQueue.l1Head - SWS`). This means that to derive the next L2 block, we have to read data
-derived from L1 block `engineQueue.l1Head - SWS` and onwards, hence the need to reset the L1 head back to that value for
-this stage.
-
-However, in general, it is only necessary to reset as far back as `safeL2Head.l1Origin`, since it marks the start of the
-sequencing window for the safe L2 head's epoch. As such, the next L2 block never depends on data derived from L1 blocks
-before `safeL2Head.l1Origin`.
-
-> **TODO** in the implementation, we always rollback by SWS, which is unecessary
-> Quote from original spec:"We must find the first L2 block whose complete sequencing window is unchanged in the reorg."
-
-> **TODO** sanity check this section, it was incorrect in previous spec, and confused me multiple times
-
-## Resetting Batch Decoding
-
-The batch decoding stage is simply reset by resetting its L1 head to the payload attribute derivation stage's L1 head.
-(The same reasoning as the payload derivation stage applies.)
-
-## Resetting Channel Buffering
-
-> **Note** in this section, the term *next (L2) block* will refer to the block that will become the next L2 safe head.
-
-> **TODO** The above can be changed in the case where we always reset the unsafe head to the safe head upon L1 re-org.
-> (See TODO above in "Resetting the Engine Queue")
-
-Because we group [sequencer batches][g-sequencer-batch] into [channels][g-channel], it means that decoding a batch that
-has data posted (in a [channel frame][g-channel-frame]) within the sequencing window of its epoch might require [channel
-frames][g-channel-frame] posted before the start of the [sequencing window][g-sequencing-window]. Note that this is only
-possible if we start sending channel frames before knowing all the batches that will go into the channel.
-
-In the worst case, decoding the batch for the next L2 block would require reading the last frame from a channel, posted
-in a [batcher transaction][g-batcher-transaction] in `safeL2Head.l1Origin + 1` (second L1 block of the next L2 block's
-epoch sequencing window, assuming it is in the same epoch as `safeL2Head`).
-
-> **Note** In reality, there are no checks or constraints preventing the batch from landing in `safeL2Head.l1Origin`.
-> However this would be strange, because the next L2 block is built after the current L2 safe block, which requires
-> reading the deposits L1 attributes and deposits from `safeL2Head.l1Origin`. Still, a wonky or misbehaving sequencer
-> could post a batch for the L2 block `safeL2Head + 1` on L1 block `safeL2Head.1Origin`.
-
-Keeping things worst case, `safeL2Head.l1Origin` would also be the last allowable block for the frame to land. The
-allowed time range for frames within a channel to land on L1 is `[channel_id.number, channel_id.number +
-CHANNEL_TIMEOUT]`. The allowed L1 block range for these frames are any L1 block whose number falls inside this block
-range.
-
-Therefore, to be safe, we can reset the L1 head of Channel Buffering to the L1 block whose number is
-`safeL2Head.l1Origin.number - CHANNEL_TIMEOUT`.
-
-> **Note** The above is what the implementation currently does.
-
-In reality it's only strictly necessary to reset the oldest L1 block whose timestamp is higher than the oldest
-`channel_id.timestamp` found in the batcher transaction that is not older than `safeL2Head.l1Origin.timestamp -
-CHANNEL_TIMEOUT`.
-
-We define `CHANNEL_TIMEOUT = 50`, i.e. 10mins
-
-> **TODO** does `CHANNEL_TIMEOUT` have a relationship with `SWS`?
->
-> I think yes, it has to be shorter than `SWS` but ONLY if we can't do streaming decryption (the case currently).
-> Otherwise it could be shorter or longer.
-
-— and explain its relationship with `SWS` if any?
-
-This situation is the main purpose of the [channel timeout][g-channel-timeout]: without the timeout, we might have to
-look arbitrarily far back on L1 to be able to decompress batches, which is not acceptable for performance reasons.
-
-The other puprose of the channel timeout is to avoid having the rollup node keep old unclosed channel data around
-forever.
-
-Once the L1 head is reset, we then need to discard any frames read from blocks more recent than this updated L1 head.
-
-## Resetting L1 Retrieval & L1 Traversal
-
-These are simply reset by resetting their L1 head to `channelBuffering.l1Head`, and dropping any buffered data.
-
-## Reorgs Post-Merge
-
-Note that post-[merge], the depth of re-orgs will be bounded by the [L1 finality delay][l1-finality] (every 2 epochs, or
-approximately 12 minutes, unless an attacker controls more than 1/3 of the total stake).
-
-[merge]: https://ethereum.org/en/upgrades/merge/
-[l1-finality]: https://ethereum.org/en/developers/docs/consensus-mechanisms/pos/#finality
-
-> **TODO** This was in the spec:
->
-> In practice, we'll pick an already-finalized L1 block as L2
-> inception point to preclude the possibility of a re-org past genesis, at the cost of a few empty blocks at the start
-> of the L2 chain.
->
-> This makes sense, but is in conflict with how the [L2 chain inception][g-l2-chain-inception] is currently determined,
-> which is via the L2 output oracle deployment & upgrades.
+[extended-attributes]: exec-engine.md#extended-payloadattributesv1

specs/glossary.md

@@ -479,7 +479,7 @@ transaction must also be signed by a recognized batch submitter account.
 
 [channel-timeout]: glossary.md#channel-timeout
 
-The channel timeout is a duration (in seconds) during which [channel frames][channel-frame may land on L1 within
+The channel timeout is a duration (in L1 blocks) during which [channel frames][channel-frame] may land on L1 within
 [batcher transactions][batcher-transaction].
 
 The acceptable time range for the frames of a [channel][channel] is `[channel_id.timestamp, channel_id.timestamp +