Merge branch 'develop' into refcell/batcher/manager/tests

.changeset/chilled-melons-speak.md

----
-'@eth-optimism/contracts-bedrock': patch
----
-
-Optionally print cast commands during migration

.changeset/flat-adults-hope.md

----
-'@eth-optimism/atst': minor
----
-
-Update readAttestations and prepareWriteAttestation to handle keys longer than 32 bytes

.changeset/fluffy-geese-yell.md

----
-'@eth-optimism/atst': minor
----
-
-Remove broken allowFailures as option

.changeset/long-frogs-study.md

----
-'@eth-optimism/common-ts': patch
----
-
-Fix BaseServiceV2 configuration for caseCase options

.changeset/metal-apes-taste.md

----
-'@eth-optimism/atst': patch
----
-
-Update docs

.changeset/metal-feet-give.md

----
-'@eth-optimism/atst': minor
----
-
-Move react api to @eth-optimism/atst/react so react isn't required to run the core sdk

.changeset/poor-buses-hug.md

----
-'@eth-optimism/sdk': patch
----
-
-Update migrated withdrawal gaslimit calculation

.changeset/quiet-crews-leave.md

----
-'@eth-optimism/atst': minor
----
-
-Fix main and module in atst package.json

.changeset/sixty-days-explain.md

----
-'@eth-optimism/atst': patch
----
-
-Fixed bug with atst not defaulting to currently connected chain

.changeset/slimy-mangos-brake.md

----
-'@eth-optimism/atst': minor
----
-
-Deprecate parseAttestationBytes and createRawKey in favor for createKey, createValue

.changeset/three-apes-study.md

----
-'@eth-optimism/fault-detector': patch
----
-
-Fixes a bug that would cause the fault detector to error out if no outputs had been proposed yet.

.changeset/wicked-ads-pump.md

----
-'@eth-optimism/contracts-bedrock': patch
----
-
-Print tenderly simulation links during deployment

.circleci/config.yml

@@ -97,7 +97,6 @@ jobs:
             - "packages/migration-data/node_modules"
             - "packages/replica-healthcheck/node_modules"
             - "packages/sdk/node_modules"
-            - "packages/two-step-monitor/node_modules"
       - run:
           name: print forge version
           command: forge --version
@@ -543,10 +542,6 @@ jobs:
           name: Check integration-tests
           command: npx depcheck
           working_directory: integration-tests
-      - run:
-          name: Check two-step-monitor
-          command: npx depcheck
-          working_directory: packages/two-step-monitor
 
   go-lint:
     parameters:

docs/op-stack/src/.vuepress/config.js

@@ -38,8 +38,8 @@ module.exports = {
       offset: -200,
     },
     algolia: {
-      appId: '7Q6XITDI0Z',
-      apiKey: '9d55a31a04b210cd26f97deabd161705',
+      appId: 'O9WKE9RMCV',
+      apiKey: '00cf17cba30b374d08d7f7afead974be',
       indexName: 'optimism'
     },
     nav: [

docs/op-stack/src/.vuepress/styles/index.styl

@@ -19,13 +19,13 @@ aside.sidebar {
 p.sidebar-heading {
   color: #323A43 !important;
   font-family: 'Open Sans', sans-serif;
-  font-weight: 600;
+  font-weight: 600 !important;
   font-size: 14px !important;
   line-height: 24px !important;
   min-height: 36px;
-  margin-left: 32px;
+  margin-left: 20px;
   padding: 8px 16px !important;
-  width: calc(100% - 64px) !important;
+  width: calc(100% - 60px) !important;
   border-radius: 8px;
 }
 
@@ -34,15 +34,17 @@ a.sidebar-link {
   font-size: 14px !important;
   line-height: 24px !important;
   min-height: 36px;
-  margin-left: 32px;
+  margin-top: 3px;
+  margin-left: 20px;
   padding: 8px 16px !important;
-  width: calc(100% - 64px) !important;
+  width: calc(100% - 60px) !important;
   border-radius: 8px;
 }
 
-section.sidebar-group a.sidebar-link  {
-  margin-left: 44px;
-  width: calc(100% - 64px) !important;
+section.sidebar-group a.sidebar-link,
+section.sidebar-group p.sidebar-heading.clickable  {
+  margin-left: 32px;
+  width: calc(100% - 60px) !important;
 }
 
 .sidebar-links:not(.sidebar-group-items) > li > a.sidebar-link {

integration-tests/package.json

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

op-batcher/batcher/channel_builder.go

@@ -11,6 +11,28 @@ import (
 	"github.com/ethereum/go-ethereum/core/types"
 )
 
+var (
+	ErrInvalidMaxFrameSize   = errors.New("max frame size cannot be zero")
+	ErrInvalidChannelTimeout = errors.New("channel timeout is less than the safety margin")
+	ErrInputTargetReached    = errors.New("target amount of input data reached")
+	ErrMaxFrameIndex         = errors.New("max frame index reached (uint16)")
+	ErrMaxDurationReached    = errors.New("max channel duration reached")
+	ErrChannelTimeoutClose   = errors.New("close to channel timeout")
+	ErrSeqWindowClose        = errors.New("close to sequencer window timeout")
+)
+
+type ChannelFullError struct {
+	Err error
+}
+
+func (e *ChannelFullError) Error() string {
+	return "channel full: " + e.Err.Error()
+}
+
+func (e *ChannelFullError) Unwrap() error {
+	return e.Err
+}
+
 type ChannelConfig struct {
 	// Number of epochs (L1 blocks) per sequencing window, including the epoch
 	// L1 origin block itself
@@ -48,6 +70,24 @@ type ChannelConfig struct {
 	ApproxComprRatio float64
 }
 
+// Check validates the [ChannelConfig] parameters.
+func (cc *ChannelConfig) Check() error {
+	// The [ChannelTimeout] must be larger than the [SubSafetyMargin].
+	// Otherwise, new blocks would always be considered timed out.
+	if cc.ChannelTimeout < cc.SubSafetyMargin {
+		return ErrInvalidChannelTimeout
+	}
+
+	// If the [MaxFrameSize] is set to 0, the channel builder
+	// will infinitely loop when trying to create frames in the
+	// [channelBuilder.OutputFrames] function.
+	if cc.MaxFrameSize == 0 {
+		return ErrInvalidMaxFrameSize
+	}
+
+	return nil
+}
+
 // InputThreshold calculates the input data threshold in bytes from the given
 // parameters.
 func (c ChannelConfig) InputThreshold() uint64 {
@@ -371,23 +411,3 @@ func (c *channelBuilder) PushFrame(frame frameData) {
 	}
 	c.frames = append(c.frames, frame)
 }
-
-var (
-	ErrInputTargetReached  = errors.New("target amount of input data reached")
-	ErrMaxFrameIndex       = errors.New("max frame index reached (uint16)")
-	ErrMaxDurationReached  = errors.New("max channel duration reached")
-	ErrChannelTimeoutClose = errors.New("close to channel timeout")
-	ErrSeqWindowClose      = errors.New("close to sequencer window timeout")
-)
-
-type ChannelFullError struct {
-	Err error
-}
-
-func (e *ChannelFullError) Error() string {
-	return "channel full: " + e.Err.Error()
-}
-
-func (e *ChannelFullError) Unwrap() error {
-	return e.Err
-}

op-batcher/batcher/channel_builder_test.go

+package batcher
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+// defaultChannelConfig returns a valid, default [ChannelConfig] struct.
+func defaultChannelConfig() ChannelConfig {
+	return ChannelConfig{
+		SeqWindowSize:      15,
+		ChannelTimeout:     40,
+		MaxChannelDuration: 1,
+		SubSafetyMargin:    4,
+		MaxFrameSize:       120000,
+		TargetFrameSize:    100000,
+		TargetNumFrames:    1,
+		ApproxComprRatio:   0.4,
+	}
+}
+
+// TestConfigValidation tests the validation of the [ChannelConfig] struct.
+func TestConfigValidation(t *testing.T) {
+	// Construct a valid config.
+	validChannelConfig := defaultChannelConfig()
+	require.NoError(t, validChannelConfig.Check())
+
+	// Set the config to have a zero max frame size.
+	validChannelConfig.MaxFrameSize = 0
+	require.ErrorIs(t, validChannelConfig.Check(), ErrInvalidMaxFrameSize)
+
+	// Reset the config and test the Timeout error.
+	// NOTE: We should be fuzzing these values with the constraint that
+	// 		 SubSafetyMargin > ChannelTimeout to ensure validation.
+	validChannelConfig = defaultChannelConfig()
+	validChannelConfig.ChannelTimeout = 0
+	validChannelConfig.SubSafetyMargin = 1
+	require.ErrorIs(t, validChannelConfig.Check(), ErrInvalidChannelTimeout)
+}

op-batcher/batcher/config.go

@@ -35,6 +35,17 @@ type Config struct {
 	Channel ChannelConfig
 }
 
+// Check ensures that the [Config] is valid.
+func (c *Config) Check() error {
+	if err := c.Rollup.Check(); err != nil {
+		return err
+	}
+	if err := c.Channel.Check(); err != nil {
+		return err
+	}
+	return nil
+}
+
 type CLIConfig struct {
 	/* Required Params */
 

op-batcher/batcher/driver.go

@@ -99,6 +99,11 @@ func NewBatchSubmitterFromCLIConfig(cfg CLIConfig, l log.Logger) (*BatchSubmitte
 		},
 	}
 
+	// Validate the batcher config
+	if err := batcherCfg.Check(); err != nil {
+		return nil, err
+	}
+
 	return NewBatchSubmitter(ctx, batcherCfg, l)
 }
 

op-batcher/batcher/txmgr.go

@@ -55,7 +55,7 @@ func (t *TransactionManager) SendTransaction(ctx context.Context, data []byte) (
 		return nil, fmt.Errorf("failed to create tx: %w", err)
 	}
 
-	ctx, cancel := context.WithTimeout(ctx, 100*time.Second) // TODO: Select a timeout that makes sense here.
+	ctx, cancel := context.WithTimeout(ctx, 10*time.Minute) // TODO: Select a timeout that makes sense here.
 	defer cancel()
 	if receipt, err := t.txMgr.Send(ctx, tx); err != nil {
 		t.log.Warn("unable to publish tx", "err", err, "data_size", len(data))

op-chain-ops/cmd/check-migration/main.go

+package main
+
+import (
+	"context"
+	"fmt"
+	"math/big"
+	"os"
+	"strings"
+
+	"github.com/ethereum-optimism/optimism/op-chain-ops/crossdomain"
+
+	"github.com/ethereum-optimism/optimism/op-chain-ops/db"
+	"github.com/mattn/go-isatty"
+
+	"github.com/ethereum-optimism/optimism/op-node/eth"
+	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
+	"github.com/ethereum/go-ethereum/common"
+
+	"github.com/ethereum/go-ethereum/core/types"
+
+	"github.com/ethereum/go-ethereum/log"
+
+	"github.com/ethereum-optimism/optimism/op-bindings/hardhat"
+
+	"github.com/ethereum-optimism/optimism/op-chain-ops/genesis"
+	"github.com/ethereum/go-ethereum/ethclient"
+
+	"github.com/urfave/cli"
+)
+
+func main() {
+	log.Root().SetHandler(log.StreamHandler(os.Stderr, log.TerminalFormat(isatty.IsTerminal(os.Stderr.Fd()))))
+
+	app := &cli.App{
+		Name:  "check-migration",
+		Usage: "Run sanity checks on a migrated database",
+		Flags: []cli.Flag{
+			&cli.StringFlag{
+				Name:     "l1-rpc-url",
+				Value:    "http://127.0.0.1:8545",
+				Usage:    "RPC URL for an L1 Node",
+				Required: true,
+			},
+			&cli.StringFlag{
+				Name:     "ovm-addresses",
+				Usage:    "Path to ovm-addresses.json",
+				Required: true,
+			},
+			&cli.StringFlag{
+				Name:     "ovm-allowances",
+				Usage:    "Path to ovm-allowances.json",
+				Required: true,
+			},
+			&cli.StringFlag{
+				Name:     "ovm-messages",
+				Usage:    "Path to ovm-messages.json",
+				Required: true,
+			},
+			&cli.StringFlag{
+				Name:     "witness-file",
+				Usage:    "Path to witness file",
+				Required: true,
+			},
+			&cli.StringFlag{
+				Name:     "db-path",
+				Usage:    "Path to database",
+				Required: true,
+			},
+			cli.StringFlag{
+				Name:     "deploy-config",
+				Usage:    "Path to hardhat deploy config file",
+				Required: true,
+			},
+			cli.StringFlag{
+				Name:     "network",
+				Usage:    "Name of hardhat deploy network",
+				Required: true,
+			},
+			cli.StringFlag{
+				Name:     "hardhat-deployments",
+				Usage:    "Comma separated list of hardhat deployment directories",
+				Required: true,
+			},
+			cli.IntFlag{
+				Name:  "db-cache",
+				Usage: "LevelDB cache size in mb",
+				Value: 1024,
+			},
+			cli.IntFlag{
+				Name:  "db-handles",
+				Usage: "LevelDB number of handles",
+				Value: 60,
+			},
+		},
+		Action: func(ctx *cli.Context) error {
+			deployConfig := ctx.String("deploy-config")
+			config, err := genesis.NewDeployConfig(deployConfig)
+			if err != nil {
+				return err
+			}
+
+			ovmAddresses, err := crossdomain.NewAddresses(ctx.String("ovm-addresses"))
+			if err != nil {
+				return err
+			}
+			ovmAllowances, err := crossdomain.NewAllowances(ctx.String("ovm-allowances"))
+			if err != nil {
+				return err
+			}
+			ovmMessages, err := crossdomain.NewSentMessageFromJSON(ctx.String("ovm-messages"))
+			if err != nil {
+				return err
+			}
+			evmMessages, evmAddresses, err := crossdomain.ReadWitnessData(ctx.String("witness-file"))
+			if err != nil {
+				return err
+			}
+
+			log.Info(
+				"Loaded witness data",
+				"ovmAddresses", len(ovmAddresses),
+				"evmAddresses", len(evmAddresses),
+				"ovmAllowances", len(ovmAllowances),
+				"ovmMessages", len(ovmMessages),
+				"evmMessages", len(evmMessages),
+			)
+
+			migrationData := crossdomain.MigrationData{
+				OvmAddresses:  ovmAddresses,
+				EvmAddresses:  evmAddresses,
+				OvmAllowances: ovmAllowances,
+				OvmMessages:   ovmMessages,
+				EvmMessages:   evmMessages,
+			}
+
+			network := ctx.String("network")
+			deployments := strings.Split(ctx.String("hardhat-deployments"), ",")
+			hh, err := hardhat.New(network, []string{}, deployments)
+			if err != nil {
+				return err
+			}
+
+			l1RpcURL := ctx.String("l1-rpc-url")
+			l1Client, err := ethclient.Dial(l1RpcURL)
+			if err != nil {
+				return err
+			}
+
+			var block *types.Block
+			tag := config.L1StartingBlockTag
+			if tag.BlockNumber != nil {
+				block, err = l1Client.BlockByNumber(context.Background(), big.NewInt(tag.BlockNumber.Int64()))
+			} else if tag.BlockHash != nil {
+				block, err = l1Client.BlockByHash(context.Background(), *tag.BlockHash)
+			} else {
+				return fmt.Errorf("invalid l1StartingBlockTag in deploy config: %v", tag)
+			}
+			if err != nil {
+				return err
+			}
+
+			dbCache := ctx.Int("db-cache")
+			dbHandles := ctx.Int("db-handles")
+
+			// Read the required deployment addresses from disk if required
+			if err := config.GetDeployedAddresses(hh); err != nil {
+				return err
+			}
+
+			if err := config.Check(); err != nil {
+				return err
+			}
+
+			postLDB, err := db.Open(ctx.String("db-path"), dbCache, dbHandles)
+			if err != nil {
+				return err
+			}
+
+			if err := genesis.PostCheckMigratedDB(
+				postLDB,
+				migrationData,
+				&config.L1CrossDomainMessengerProxy,
+				config.L1ChainID,
+				config.FinalSystemOwner,
+				config.ProxyAdminOwner,
+				&derive.L1BlockInfo{
+					Number:        block.NumberU64(),
+					Time:          block.Time(),
+					BaseFee:       block.BaseFee(),
+					BlockHash:     block.Hash(),
+					BatcherAddr:   config.BatchSenderAddress,
+					L1FeeOverhead: eth.Bytes32(common.BigToHash(new(big.Int).SetUint64(config.GasPriceOracleOverhead))),
+					L1FeeScalar:   eth.Bytes32(common.BigToHash(new(big.Int).SetUint64(config.GasPriceOracleScalar))),
+				},
+			); err != nil {
+				return err
+			}
+
+			if err := postLDB.Close(); err != nil {
+				return err
+			}
+
+			return nil
+		},
+	}
+
+	if err := app.Run(os.Args); err != nil {
+		log.Crit("error in migration", "err", err)
+	}
+}

op-chain-ops/cmd/op-migrate/main.go

@@ -106,6 +106,11 @@ func main() {
 				Value:    "rollup.json",
 				Required: true,
 			},
+			cli.BoolFlag{
+				Name:     "post-check-only",
+				Usage:    "Only perform sanity checks",
+				Required: false,
+			},
 		},
 		Action: func(ctx *cli.Context) error {
 			deployConfig := ctx.String("deploy-config")

op-chain-ops/ether/cli.go

@@ -25,8 +25,8 @@ func GetOVMETHTotalSupplySlot() common.Hash {
 	return getOVMETHTotalSupplySlot()
 }
 
-// getOVMETHBalance gets a user's OVM ETH balance from state by querying the
+// GetOVMETHBalance gets a user's OVM ETH balance from state by querying the
 // appropriate storage slot directly.
-func getOVMETHBalance(db *state.StateDB, addr common.Address) *big.Int {
+func GetOVMETHBalance(db *state.StateDB, addr common.Address) *big.Int {
 	return db.GetState(OVMETHAddress, CalcOVMETHStorageKey(addr)).Big()
 }

op-chain-ops/ether/migrate.go

@@ -29,7 +29,9 @@ var (
 	}
 )
 
-func MigrateLegacyETH(db *state.StateDB, addresses []common.Address, chainID int, noCheck bool) error {
+type FilteredOVMETHAddresses []common.Address
+
+func MigrateLegacyETH(db *state.StateDB, addresses FilteredOVMETHAddresses, chainID int, noCheck bool) error {
 	// Chain params to use for integrity checking.
 	params := crossdomain.ParamsByChainID[chainID]
 	if params == nil {
@@ -39,28 +41,15 @@ func MigrateLegacyETH(db *state.StateDB, addresses []common.Address, chainID int
 	// Log the chain params for debugging purposes.
 	log.Info("Chain params", "chain-id", chainID, "supply-delta", params.ExpectedSupplyDelta)
 
-	// Deduplicate the list of addresses by converting to a map.
-	deduped := make(map[common.Address]bool)
-	for _, addr := range addresses {
-		deduped[addr] = true
-	}
-
 	// Migrate the legacy ETH to ETH.
 	log.Info("Migrating legacy ETH to ETH", "num-accounts", len(addresses))
 	totalMigrated := new(big.Int)
 	logAccountProgress := util.ProgressLogger(1000, "imported accounts")
-	for addr := range deduped {
-		// No accounts should have a balance in state. If they do, bail.
-		if db.GetBalance(addr).Sign() > 0 {
-			if noCheck {
-				log.Error("account has non-zero balance in state - should never happen", "addr", addr)
-			} else {
-				log.Crit("account has non-zero balance in state - should never happen", "addr", addr)
-			}
-		}
+	for _, addr := range addresses {
+		// Balances are pre-checked not have any balances in state.
 
 		// Pull out the OVM ETH balance.
-		ovmBalance := getOVMETHBalance(db, addr)
+		ovmBalance := GetOVMETHBalance(db, addr)
 
 		// Actually perform the migration by setting the appropriate values in state.
 		db.SetBalance(addr, ovmBalance)

op-chain-ops/ether/precheck_test.go

+package ether
+
+import (
+	"bytes"
+	"math/big"
+	"math/rand"
+	"os"
+	"sort"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/log"
+
+	"github.com/ethereum-optimism/optimism/op-chain-ops/crossdomain"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/rawdb"
+	"github.com/ethereum/go-ethereum/core/state"
+	"github.com/ethereum/go-ethereum/trie"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPreCheckBalances(t *testing.T) {
+	log.Root().SetHandler(log.StreamHandler(os.Stderr, log.TerminalFormat(true)))
+
+	tests := []struct {
+		name            string
+		totalSupply     *big.Int
+		expDiff         *big.Int
+		stateBalances   map[common.Address]*big.Int
+		stateAllowances map[common.Address]common.Address
+		inputAddresses  []common.Address
+		inputAllowances []*crossdomain.Allowance
+		check           func(t *testing.T, addrs FilteredOVMETHAddresses, err error)
+	}{
+		{
+			name:        "everything matches",
+			totalSupply: big.NewInt(3),
+			expDiff:     big.NewInt(0),
+			stateBalances: map[common.Address]*big.Int{
+				common.HexToAddress("0x123"): big.NewInt(1),
+				common.HexToAddress("0x456"): big.NewInt(2),
+			},
+			stateAllowances: map[common.Address]common.Address{
+				common.HexToAddress("0x123"): common.HexToAddress("0x456"),
+			},
+			inputAddresses: []common.Address{
+				common.HexToAddress("0x123"),
+				common.HexToAddress("0x456"),
+			},
+			inputAllowances: []*crossdomain.Allowance{
+				{
+					From: common.HexToAddress("0x123"),
+					To:   common.HexToAddress("0x456"),
+				},
+			},
+			check: func(t *testing.T, addrs FilteredOVMETHAddresses, err error) {
+				require.NoError(t, err)
+				require.EqualValues(t, FilteredOVMETHAddresses{
+					common.HexToAddress("0x123"),
+					common.HexToAddress("0x456"),
+				}, addrs)
+			},
+		},
+		{
+			name:        "extra input addresses",
+			totalSupply: big.NewInt(1),
+			expDiff:     big.NewInt(0),
+			stateBalances: map[common.Address]*big.Int{
+				common.HexToAddress("0x123"): big.NewInt(1),
+			},
+			inputAddresses: []common.Address{
+				common.HexToAddress("0x123"),
+				common.HexToAddress("0x456"),
+			},
+			check: func(t *testing.T, addrs FilteredOVMETHAddresses, err error) {
+				require.NoError(t, err)
+				require.EqualValues(t, FilteredOVMETHAddresses{
+					common.HexToAddress("0x123"),
+				}, addrs)
+			},
+		},
+		{
+			name:        "extra input allowances",
+			totalSupply: big.NewInt(1),
+			expDiff:     big.NewInt(0),
+			stateBalances: map[common.Address]*big.Int{
+				common.HexToAddress("0x123"): big.NewInt(1),
+			},
+			stateAllowances: map[common.Address]common.Address{
+				common.HexToAddress("0x123"): common.HexToAddress("0x456"),
+			},
+			inputAddresses: []common.Address{
+				common.HexToAddress("0x123"),
+				common.HexToAddress("0x456"),
+			},
+			inputAllowances: []*crossdomain.Allowance{
+				{
+					From: common.HexToAddress("0x123"),
+					To:   common.HexToAddress("0x456"),
+				},
+				{
+					From: common.HexToAddress("0x123"),
+					To:   common.HexToAddress("0x789"),
+				},
+			},
+			check: func(t *testing.T, addrs FilteredOVMETHAddresses, err error) {
+				require.NoError(t, err)
+				require.EqualValues(t, FilteredOVMETHAddresses{
+					common.HexToAddress("0x123"),
+				}, addrs)
+			},
+		},
+		{
+			name:        "missing input addresses",
+			totalSupply: big.NewInt(2),
+			expDiff:     big.NewInt(0),
+			stateBalances: map[common.Address]*big.Int{
+				common.HexToAddress("0x123"): big.NewInt(1),
+				common.HexToAddress("0x456"): big.NewInt(1),
+			},
+			inputAddresses: []common.Address{
+				common.HexToAddress("0x123"),
+			},
+			check: func(t *testing.T, addrs FilteredOVMETHAddresses, err error) {
+				require.Error(t, err)
+				require.ErrorContains(t, err, "unknown storage slot")
+			},
+		},
+		{
+			name:        "missing input allowances",
+			totalSupply: big.NewInt(2),
+			expDiff:     big.NewInt(0),
+			stateBalances: map[common.Address]*big.Int{
+				common.HexToAddress("0x123"): big.NewInt(1),
+			},
+			stateAllowances: map[common.Address]common.Address{
+				common.HexToAddress("0x123"): common.HexToAddress("0x456"),
+				common.HexToAddress("0x123"): common.HexToAddress("0x789"),
+			},
+			inputAddresses: []common.Address{
+				common.HexToAddress("0x123"),
+			},
+			inputAllowances: []*crossdomain.Allowance{
+				{
+					From: common.HexToAddress("0x123"),
+					To:   common.HexToAddress("0x456"),
+				},
+			},
+			check: func(t *testing.T, addrs FilteredOVMETHAddresses, err error) {
+				require.Error(t, err)
+				require.ErrorContains(t, err, "unknown storage slot")
+			},
+		},
+		{
+			name:        "bad supply diff",
+			totalSupply: big.NewInt(4),
+			expDiff:     big.NewInt(0),
+			stateBalances: map[common.Address]*big.Int{
+				common.HexToAddress("0x123"): big.NewInt(1),
+				common.HexToAddress("0x456"): big.NewInt(2),
+			},
+			inputAddresses: []common.Address{
+				common.HexToAddress("0x123"),
+				common.HexToAddress("0x456"),
+			},
+			check: func(t *testing.T, addrs FilteredOVMETHAddresses, err error) {
+				require.Error(t, err)
+				require.ErrorContains(t, err, "supply mismatch")
+			},
+		},
+		{
+			name:        "good supply diff",
+			totalSupply: big.NewInt(4),
+			expDiff:     big.NewInt(1),
+			stateBalances: map[common.Address]*big.Int{
+				common.HexToAddress("0x123"): big.NewInt(1),
+				common.HexToAddress("0x456"): big.NewInt(2),
+			},
+			inputAddresses: []common.Address{
+				common.HexToAddress("0x123"),
+				common.HexToAddress("0x456"),
+			},
+			check: func(t *testing.T, addrs FilteredOVMETHAddresses, err error) {
+				require.NoError(t, err)
+				require.EqualValues(t, FilteredOVMETHAddresses{
+					common.HexToAddress("0x123"),
+					common.HexToAddress("0x456"),
+				}, addrs)
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			db := makeLegacyETH(t, tt.totalSupply, tt.stateBalances, tt.stateAllowances)
+			factory := func() (*state.StateDB, error) {
+				return db, nil
+			}
+			addrs, err := doMigration(factory, tt.inputAddresses, tt.inputAllowances, tt.expDiff, false)
+
+			// Sort the addresses since they come in in a random order.
+			sort.Slice(addrs, func(i, j int) bool {
+				return bytes.Compare(addrs[i][:], addrs[j][:]) < 0
+			})
+
+			tt.check(t, addrs, err)
+		})
+	}
+}
+
+func makeLegacyETH(t *testing.T, totalSupply *big.Int, balances map[common.Address]*big.Int, allowances map[common.Address]common.Address) *state.StateDB {
+	db, err := state.New(common.Hash{}, state.NewDatabaseWithConfig(rawdb.NewMemoryDatabase(), &trie.Config{
+		Preimages: true,
+		Cache:     1024,
+	}), nil)
+	require.NoError(t, err)
+
+	db.CreateAccount(OVMETHAddress)
+	db.SetState(OVMETHAddress, getOVMETHTotalSupplySlot(), common.BigToHash(totalSupply))
+
+	for slot := range ignoredSlots {
+		if slot == getOVMETHTotalSupplySlot() {
+			continue
+		}
+		db.SetState(OVMETHAddress, slot, common.Hash{31: 0xff})
+	}
+	for addr, balance := range balances {
+		db.SetState(OVMETHAddress, CalcOVMETHStorageKey(addr), common.BigToHash(balance))
+	}
+	for from, to := range allowances {
+		db.SetState(OVMETHAddress, CalcAllowanceStorageKey(from, to), common.BigToHash(big.NewInt(1)))
+	}
+
+	root, err := db.Commit(false)
+	require.NoError(t, err)
+
+	err = db.Database().TrieDB().Commit(root, true)
+	require.NoError(t, err)
+
+	return db
+}
+
+// TestPreCheckBalancesRandom tests that the pre-check balances function works
+// with random addresses. This test makes sure that the partition logic doesn't
+// miss anything.
+func TestPreCheckBalancesRandom(t *testing.T) {
+	addresses := make([]common.Address, 0)
+	stateBalances := make(map[common.Address]*big.Int)
+
+	allowances := make([]*crossdomain.Allowance, 0)
+	stateAllowances := make(map[common.Address]common.Address)
+
+	totalSupply := big.NewInt(0)
+
+	for i := 0; i < 100; i++ {
+		for i := 0; i < rand.Intn(1000); i++ {
+			addr := randAddr(t)
+			addresses = append(addresses, addr)
+			stateBalances[addr] = big.NewInt(int64(rand.Intn(1_000_000)))
+			totalSupply = new(big.Int).Add(totalSupply, stateBalances[addr])
+		}
+
+		sort.Slice(addresses, func(i, j int) bool {
+			return bytes.Compare(addresses[i][:], addresses[j][:]) < 0
+		})
+
+		for i := 0; i < rand.Intn(1000); i++ {
+			addr := randAddr(t)
+			to := randAddr(t)
+			allowances = append(allowances, &crossdomain.Allowance{
+				From: addr,
+				To:   to,
+			})
+			stateAllowances[addr] = to
+		}
+
+		db := makeLegacyETH(t, totalSupply, stateBalances, stateAllowances)
+		factory := func() (*state.StateDB, error) {
+			return db, nil
+		}
+
+		outAddrs, err := doMigration(factory, addresses, allowances, big.NewInt(0), false)
+		require.NoError(t, err)
+
+		sort.Slice(outAddrs, func(i, j int) bool {
+			return bytes.Compare(outAddrs[i][:], outAddrs[j][:]) < 0
+		})
+		require.EqualValues(t, addresses, outAddrs)
+	}
+}
+
+func randAddr(t *testing.T) common.Address {
+	var addr common.Address
+	_, err := rand.Read(addr[:])
+	require.NoError(t, err)
+	return addr
+}

op-chain-ops/genesis/check.go

@@ -7,6 +7,8 @@ import (
 	"fmt"
 	"math/big"
 
+	"github.com/ethereum-optimism/optimism/op-chain-ops/ether"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/rawdb"
 	"github.com/ethereum/go-ethereum/core/state"
@@ -251,7 +253,7 @@ func PostCheckPredeploys(prevDB, currDB *state.StateDB) error {
 
 		// Balances and nonces should match legacy
 		oldNonce := prevDB.GetNonce(addr)
-		oldBalance := prevDB.GetBalance(addr)
+		oldBalance := ether.GetOVMETHBalance(prevDB, addr)
 		newNonce := currDB.GetNonce(addr)
 		newBalance := currDB.GetBalance(addr)
 		if oldNonce != newNonce {
@@ -543,7 +545,7 @@ func CheckWithdrawalsAfter(db vm.StateDB, data crossdomain.MigrationData, l1Cros
 
 		// If the sender is _not_ the L2XDM, the value should not be migrated.
 		wd := wdsByOldSlot[key]
-		if wd.XDomainSender == predeploys.L2CrossDomainMessengerAddr {
+		if wd.MessageSender == predeploys.L2CrossDomainMessengerAddr {
 			// Make sure the value is abiTrue if this withdrawal should be migrated.
 			if migratedValue != abiTrue {
 				innerErr = fmt.Errorf("expected migrated value to be true, but got %s", migratedValue)
@@ -552,7 +554,7 @@ func CheckWithdrawalsAfter(db vm.StateDB, data crossdomain.MigrationData, l1Cros
 		} else {
 			// Otherwise, ensure that withdrawals from senders other than the L2XDM are _not_ migrated.
 			if migratedValue != abiFalse {
-				innerErr = fmt.Errorf("a migration from a sender other than the L2XDM was migrated")
+				innerErr = fmt.Errorf("a migration from a sender other than the L2XDM was migrated. sender: %s, migrated value: %s", wd.MessageSender, migratedValue)
 				return false
 			}
 		}

op-chain-ops/genesis/db_migration.go

@@ -82,6 +82,7 @@ func MigrateDB(ldb ethdb.Database, config *DeployConfig, l1Block *types.Block, m
 		)
 	}
 
+	dbFactory := func() (*state.StateDB, error) {
 		// Set up the backing store.
 		underlyingDB := state.NewDatabaseWithConfig(ldb, &trie.Config{
 			Preimages: true,
@@ -94,6 +95,14 @@ func MigrateDB(ldb ethdb.Database, config *DeployConfig, l1Block *types.Block, m
 			return nil, fmt.Errorf("cannot open StateDB: %w", err)
 		}
 
+		return db, nil
+	}
+
+	db, err := dbFactory()
+	if err != nil {
+		return nil, fmt.Errorf("cannot create StateDB: %w", err)
+	}
+
 	// Before we do anything else, we need to ensure that all of the input configuration is correct
 	// and nothing is missing. We'll first verify the contract configuration, then we'll verify the
 	// witness data for the migration. We operate under the assumption that the witness data is
@@ -139,7 +148,7 @@ func MigrateDB(ldb ethdb.Database, config *DeployConfig, l1Block *types.Block, m
 	// Unlike with withdrawals, we do not need to filter out extra addresses because their balances
 	// would necessarily be zero and therefore not affect the migration.
 	log.Info("Checking addresses...", "no-check", noCheck)
-	addrs, err := ether.PreCheckBalances(ldb, db, migrationData.Addresses(), migrationData.OvmAllowances, int(config.L1ChainID), noCheck)
+	addrs, err := ether.PreCheckBalances(dbFactory, migrationData.Addresses(), migrationData.OvmAllowances, int(config.L1ChainID), noCheck)
 	if err != nil {
 		return nil, fmt.Errorf("addresses mismatch: %w", err)
 	}

op-e2e/actions/fork_test.go

+package actions
+
+import (
+	"testing"
+
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/stretchr/testify/require"
+
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils"
+	"github.com/ethereum-optimism/optimism/op-node/testlog"
+)
+
+func TestShapellaL1Fork(gt *testing.T) {
+	t := NewDefaultTesting(gt)
+	dp := e2eutils.MakeDeployParams(t, defaultRollupTestParams)
+
+	sd := e2eutils.Setup(t, dp, defaultAlloc)
+	activation := sd.L1Cfg.Timestamp + 24
+	sd.L1Cfg.Config.ShanghaiTime = &activation
+	log := testlog.Logger(t, log.LvlDebug)
+
+	_, _, miner, sequencer, _, verifier, _, batcher := setupReorgTestActors(t, dp, sd, log)
+
+	require.False(t, sd.L1Cfg.Config.IsShanghai(miner.l1Chain.CurrentBlock().Time()), "not active yet")
+
+	// start op-nodes
+	sequencer.ActL2PipelineFull(t)
+	verifier.ActL2PipelineFull(t)
+
+	// build empty L1 blocks, crossing the fork boundary
+	miner.ActEmptyBlock(t)
+	miner.ActEmptyBlock(t)
+	miner.ActEmptyBlock(t)
+
+	// verify Shanghai is active
+	l1Head := miner.l1Chain.CurrentBlock()
+	require.True(t, sd.L1Cfg.Config.IsShanghai(l1Head.Time()))
+
+	// build L2 chain up to and including L2 blocks referencing shanghai L1 blocks
+	sequencer.ActL1HeadSignal(t)
+	sequencer.ActBuildToL1Head(t)
+	miner.ActL1StartBlock(12)(t)
+	batcher.ActSubmitAll(t)
+	miner.ActL1IncludeTx(batcher.batcherAddr)(t)
+	miner.ActL1EndBlock(t)
+
+	// sync verifier
+	verifier.ActL1HeadSignal(t)
+	verifier.ActL2PipelineFull(t)
+	// verify verifier accepted shanghai L1 inputs
+	require.Equal(t, l1Head.Hash(), verifier.SyncStatus().SafeL2.L1Origin.Hash, "verifier synced L1 chain that includes shanghai headers")
+	require.Equal(t, sequencer.SyncStatus().UnsafeL2, verifier.SyncStatus().UnsafeL2, "verifier and sequencer agree")
+}

op-e2e/actions/l1_miner.go

@@ -72,6 +72,9 @@ func (s *L1Miner) ActL1StartBlock(timeDelta uint64) Action {
 				header.GasLimit = parent.GasLimit * s.l1Cfg.Config.ElasticityMultiplier()
 			}
 		}
+		if s.l1Cfg.Config.IsShanghai(header.Time) {
+			header.WithdrawalsHash = &types.EmptyWithdrawalsHash
+		}
 
 		s.l1Building = true
 		s.l1BuildingHeader = header
@@ -135,6 +138,9 @@ func (s *L1Miner) ActL1EndBlock(t Testing) {
 	s.l1BuildingHeader.GasUsed = s.l1BuildingHeader.GasLimit - uint64(*s.l1GasPool)
 	s.l1BuildingHeader.Root = s.l1BuildingState.IntermediateRoot(s.l1Cfg.Config.IsEIP158(s.l1BuildingHeader.Number))
 	block := types.NewBlock(s.l1BuildingHeader, s.l1Transactions, nil, s.l1Receipts, trie.NewStackTrie(nil))
+	if s.l1Cfg.Config.IsShanghai(s.l1BuildingHeader.Time) {
+		block = block.WithWithdrawals(make([]*types.Withdrawal, 0))
+	}
 
 	// Write state changes to db
 	root, err := s.l1BuildingState.Commit(s.l1Cfg.Config.IsEIP158(s.l1BuildingHeader.Number))

op-e2e/setup.go

@@ -7,6 +7,7 @@ import (
 	"math/big"
 	"os"
 	"path"
+	"sort"
 	"strings"
 	"testing"
 	"time"
@@ -119,14 +120,6 @@ func DefaultSystemConfig(t *testing.T) SystemConfig {
 		JWTFilePath:            writeDefaultJWT(t),
 		JWTSecret:              testingJWTSecret,
 		Nodes: map[string]*rollupNode.Config{
-			"verifier": {
-				Driver: driver.Config{
-					VerifierConfDepth:  0,
-					SequencerConfDepth: 0,
-					SequencerEnabled:   false,
-				},
-				L1EpochPollInterval: time.Second * 4,
-			},
 			"sequencer": {
 				Driver: driver.Config{
 					VerifierConfDepth:  0,
@@ -141,6 +134,14 @@ func DefaultSystemConfig(t *testing.T) SystemConfig {
 				},
 				L1EpochPollInterval: time.Second * 4,
 			},
+			"verifier": {
+				Driver: driver.Config{
+					VerifierConfDepth:  0,
+					SequencerConfDepth: 0,
+					SequencerEnabled:   false,
+				},
+				L1EpochPollInterval: time.Second * 4,
+			},
 		},
 		Loggers: map[string]log.Logger{
 			"verifier":  testlog.Logger(t, log.LvlInfo).New("role", "verifier"),
@@ -225,7 +226,43 @@ func (sys *System) Close() {
 	sys.Mocknet.Close()
 }
 
-func (cfg SystemConfig) Start() (*System, error) {
+type systemConfigHook func(sCfg *SystemConfig, s *System)
+
+type SystemConfigOption struct {
+	key    string
+	role   string
+	action systemConfigHook
+}
+
+type SystemConfigOptions struct {
+	opts map[string]systemConfigHook
+}
+
+func NewSystemConfigOptions(_opts []SystemConfigOption) (SystemConfigOptions, error) {
+	opts := make(map[string]systemConfigHook)
+	for _, opt := range _opts {
+		if _, ok := opts[opt.key+":"+opt.role]; ok {
+			return SystemConfigOptions{}, fmt.Errorf("duplicate option for key %s and role %s", opt.key, opt.role)
+		}
+		opts[opt.key+":"+opt.role] = opt.action
+	}
+
+	return SystemConfigOptions{
+		opts: opts,
+	}, nil
+}
+
+func (s *SystemConfigOptions) Get(key, role string) (systemConfigHook, bool) {
+	v, ok := s.opts[key+":"+role]
+	return v, ok
+}
+
+func (cfg SystemConfig) Start(_opts ...SystemConfigOption) (*System, error) {
+	opts, err := NewSystemConfigOptions(_opts)
+	if err != nil {
+		return nil, err
+	}
+
 	sys := &System{
 		cfg:         cfg,
 		Nodes:       make(map[string]*node.Node),
@@ -457,7 +494,17 @@ func (cfg SystemConfig) Start() (*System, error) {
 	snapLog.SetHandler(log.DiscardHandler())
 
 	// Rollup nodes
-	for name, nodeConfig := range cfg.Nodes {
+
+	// Ensure we are looping through the nodes in alphabetical order
+	ks := make([]string, 0, len(cfg.Nodes))
+	for k := range cfg.Nodes {
+		ks = append(ks, k)
+	}
+	// Sort strings in ascending alphabetical order
+	sort.Strings(ks)
+
+	for _, name := range ks {
+		nodeConfig := cfg.Nodes[name]
 		c := *nodeConfig // copy
 		c.Rollup = makeRollupConfig()
 
@@ -482,6 +529,10 @@ func (cfg SystemConfig) Start() (*System, error) {
 			return nil, err
 		}
 		sys.RollupNodes[name] = node
+
+		if action, ok := opts.Get("afterRollupNodeStart", name); ok {
+			action(&cfg, sys)
+		}
 	}
 
 	if cfg.P2PTopology != nil {

op-e2e/system_test.go

@@ -649,8 +649,94 @@ func TestSystemMockP2P(t *testing.T) {
 	require.Contains(t, received, receiptVerif.BlockHash)
 }
 
+// TestSystemMockP2P sets up a L1 Geth node, a rollup node, and a L2 geth node and then confirms that
+// the nodes can sync L2 blocks before they are confirmed on L1.
+//
+// Test steps:
+// 1. Spin up the nodes (P2P is disabled on the verifier)
+// 2. Send a transaction to the sequencer.
+// 3. Wait for the TX to be mined on the sequencer chain.
+// 5. Wait for the verifier to detect a gap in the payload queue vs. the unsafe head
+// 6. Wait for the RPC sync method to grab the block from the sequencer over RPC and insert it into the verifier's unsafe chain.
+// 7. Wait for the verifier to sync the unsafe chain into the safe chain.
+// 8. Verify that the TX is included in the verifier's safe chain.
+func TestSystemMockAltSync(t *testing.T) {
+	parallel(t)
+	if !verboseGethNodes {
+		log.Root().SetHandler(log.DiscardHandler())
+	}
+
+	cfg := DefaultSystemConfig(t)
+	// slow down L1 blocks so we can see the L2 blocks arrive well before the L1 blocks do.
+	// Keep the seq window small so the L2 chain is started quick
+	cfg.DeployConfig.L1BlockTime = 10
+
+	var published, received []common.Hash
+	seqTracer, verifTracer := new(FnTracer), new(FnTracer)
+	seqTracer.OnPublishL2PayloadFn = func(ctx context.Context, payload *eth.ExecutionPayload) {
+		published = append(published, payload.BlockHash)
+	}
+	verifTracer.OnUnsafeL2PayloadFn = func(ctx context.Context, from peer.ID, payload *eth.ExecutionPayload) {
+		received = append(received, payload.BlockHash)
+	}
+	cfg.Nodes["sequencer"].Tracer = seqTracer
+	cfg.Nodes["verifier"].Tracer = verifTracer
+
+	sys, err := cfg.Start(SystemConfigOption{
+		key:  "afterRollupNodeStart",
+		role: "sequencer",
+		action: func(sCfg *SystemConfig, system *System) {
+			rpc, _ := system.Nodes["sequencer"].Attach() // never errors
+			cfg.Nodes["verifier"].L2Sync = &rollupNode.L2SyncRPCConfig{
+				Rpc: client.NewBaseRPCClient(rpc),
+			}
+		},
+	})
+	require.Nil(t, err, "Error starting up system")
+	defer sys.Close()
+
+	l2Seq := sys.Clients["sequencer"]
+	l2Verif := sys.Clients["verifier"]
+
+	// Transactor Account
+	ethPrivKey := cfg.Secrets.Alice
+
+	// Submit a TX to L2 sequencer node
+	toAddr := common.Address{0xff, 0xff}
+	tx := types.MustSignNewTx(ethPrivKey, types.LatestSignerForChainID(cfg.L2ChainIDBig()), &types.DynamicFeeTx{
+		ChainID:   cfg.L2ChainIDBig(),
+		Nonce:     0,
+		To:        &toAddr,
+		Value:     big.NewInt(1_000_000_000),
+		GasTipCap: big.NewInt(10),
+		GasFeeCap: big.NewInt(200),
+		Gas:       21000,
+	})
+	err = l2Seq.SendTransaction(context.Background(), tx)
+	require.Nil(t, err, "Sending L2 tx to sequencer")
+
+	// Wait for tx to be mined on the L2 sequencer chain
+	receiptSeq, err := waitForTransaction(tx.Hash(), l2Seq, 6*time.Duration(sys.RollupConfig.BlockTime)*time.Second)
+	require.Nil(t, err, "Waiting for L2 tx on sequencer")
+
+	// Wait for alt RPC sync to pick up the blocks on the sequencer chain
+	receiptVerif, err := waitForTransaction(tx.Hash(), l2Verif, 12*time.Duration(sys.RollupConfig.BlockTime)*time.Second)
+	require.Nil(t, err, "Waiting for L2 tx on verifier")
+
+	require.Equal(t, receiptSeq, receiptVerif)
+
+	// Verify that the tx was received via RPC sync (P2P is disabled)
+	require.Contains(t, received, receiptVerif.BlockHash)
+
+	// Verify that everything that was received was published
+	require.GreaterOrEqual(t, len(published), len(received))
+	require.ElementsMatch(t, received, published[:len(received)])
+}
+
 // TestSystemDenseTopology sets up a dense p2p topology with 3 verifier nodes and 1 sequencer node.
 func TestSystemDenseTopology(t *testing.T) {
+	t.Skip("Skipping dense topology test to avoid flakiness. @refcell address in p2p scoring pr.")
+
 	parallel(t)
 	if !verboseGethNodes {
 		log.Root().SetHandler(log.DiscardHandler())

op-node/cmd/batch_decoder/README.md

@@ -26,6 +26,16 @@ the transaction hash.
 into channels. It then stores the channels with metadata on disk where the file name is the Channel ID.
 
 
+### Force Close
+
+`batch_decoder force-close` will create a transaction data that can be sent from the batcher address to
+the batch inbox address which will force close the given channels. This will allow future channels to
+be read without waiting for the channel timeout. It uses uses the results from `batch_decoder fetch` to
+create the close transaction because the transaction it creates for a specific channel requires information
+about if the channel has been closed or not. If it has been closed already but is missing specific frames
+those frames need to be generated differently than simply closing the channel.
+
+
 ## JQ Cheat Sheet
 
 `jq` is a really useful utility for manipulating JSON files.
@@ -48,7 +58,6 @@ jq "select(.is_ready == false)|[.id, .frames[0].inclusion_block, .frames[0].tran
 ## Roadmap
 
 - Parallel transaction fetching (CLI-3563)
-- Create force-close channel tx data from channel ID (CLI-3564)
 - Pull the batches out of channels & store that information inside the ChannelWithMetadata (CLI-3565)
 	- Transaction Bytes used
 	- Total uncompressed (different from tx bytes) + compressed bytes

op-node/cmd/batch_decoder/main.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/ethereum-optimism/optimism/op-node/cmd/batch_decoder/fetch"
 	"github.com/ethereum-optimism/optimism/op-node/cmd/batch_decoder/reassemble"
+	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/urfave/cli"
@@ -113,6 +114,46 @@ func main() {
 				return nil
 			},
 		},
+		{
+			Name:  "force-close",
+			Usage: "Create the tx data which will force close a channel",
+			Flags: []cli.Flag{
+				cli.StringFlag{
+					Name:     "id",
+					Required: true,
+					Usage:    "ID of the channel to close",
+				},
+				cli.StringFlag{
+					Name:  "inbox",
+					Value: "0x0000000000000000000000000000000000000000",
+					Usage: "(Optional) Batch Inbox Address",
+				},
+				cli.StringFlag{
+					Name:  "in",
+					Value: "/tmp/batch_decoder/transactions_cache",
+					Usage: "Cache directory for the found transactions",
+				},
+			},
+			Action: func(cliCtx *cli.Context) error {
+				var id derive.ChannelID
+				if err := (&id).UnmarshalText([]byte(cliCtx.String("id"))); err != nil {
+					log.Fatal(err)
+				}
+				frames := reassemble.LoadFrames(cliCtx.String("in"), common.HexToAddress(cliCtx.String("inbox")))
+				var filteredFrames []derive.Frame
+				for _, frame := range frames {
+					if frame.Frame.ID == id {
+						filteredFrames = append(filteredFrames, frame.Frame)
+					}
+				}
+				data, err := derive.ForceCloseTxData(filteredFrames)
+				if err != nil {
+					log.Fatal(err)
+				}
+				fmt.Printf("%x\n", data)
+				return nil
+			},
+		},
 	}
 
 	if err := app.Run(os.Args); err != nil {

op-node/cmd/batch_decoder/reassemble/reassemble.go

@@ -38,14 +38,8 @@ type Config struct {
 	OutDirectory string
 }
 
-// Channels loads all transactions from the given input directory that are submitted to the
-// specified batch inbox and then re-assembles all channels & writes the re-assembled channels
-// to the out directory.
-func Channels(config Config) {
-	if err := os.MkdirAll(config.OutDirectory, 0750); err != nil {
-		log.Fatal(err)
-	}
-	txns := loadTransactions(config.InDirectory, config.BatchInbox)
+func LoadFrames(directory string, inbox common.Address) []FrameWithMetadata {
+	txns := loadTransactions(directory, inbox)
 	// Sort first by block number then by transaction index inside the block number range.
 	// This is to match the order they are processed in derivation.
 	sort.Slice(txns, func(i, j int) bool {
@@ -56,7 +50,17 @@ func Channels(config Config) {
 		}
 
 	})
-	frames := transactionsToFrames(txns)
+	return transactionsToFrames(txns)
+}
+
+// Channels loads all transactions from the given input directory that are submitted to the
+// specified batch inbox and then re-assembles all channels & writes the re-assembled channels
+// to the out directory.
+func Channels(config Config) {
+	if err := os.MkdirAll(config.OutDirectory, 0750); err != nil {
+		log.Fatal(err)
+	}
+	frames := LoadFrames(config.InDirectory, config.BatchInbox)
 	framesByChannel := make(map[derive.ChannelID][]FrameWithMetadata)
 	for _, frame := range frames {
 		framesByChannel[frame.Frame.ID] = append(framesByChannel[frame.Frame.ID], frame)
@@ -143,6 +147,7 @@ func transactionsToFrames(txns []fetch.TransactionWithMetadata) []FrameWithMetad
 	return out
 }
 
+// if inbox is the zero address, it will load all frames
 func loadTransactions(dir string, inbox common.Address) []fetch.TransactionWithMetadata {
 	files, err := os.ReadDir(dir)
 	if err != nil {
@@ -152,7 +157,7 @@ func loadTransactions(dir string, inbox common.Address) []fetch.TransactionWithM
 	for _, file := range files {
 		f := path.Join(dir, file.Name())
 		txm := loadTransactionsFile(f)
-		if txm.InboxAddr == inbox && txm.ValidSender {
+		if (inbox == common.Address{} || txm.InboxAddr == inbox) && txm.ValidSender {
 			out = append(out, txm)
 		}
 	}

op-node/flags/flags.go

@@ -185,6 +185,12 @@ var (
 		EnvVar: prefixEnvVar("HEARTBEAT_URL"),
 		Value:  "https://heartbeat.optimism.io",
 	}
+	BackupL2UnsafeSyncRPC = cli.StringFlag{
+		Name:     "l2.backup-unsafe-sync-rpc",
+		Usage:    "Set the backup L2 unsafe sync RPC endpoint.",
+		EnvVar:   prefixEnvVar("L2_BACKUP_UNSAFE_SYNC_RPC"),
+		Required: false,
+	}
 )
 
 var requiredFlags = []cli.Flag{
@@ -219,6 +225,7 @@ var optionalFlags = append([]cli.Flag{
 	HeartbeatEnabledFlag,
 	HeartbeatMonikerFlag,
 	HeartbeatURLFlag,
+	BackupL2UnsafeSyncRPC,
 }, p2pFlags...)
 
 // Flags contains the list of configuration options available to the binary.

op-node/node/api.go

@@ -9,6 +9,7 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/log"
 
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
 	"github.com/ethereum-optimism/optimism/op-node/eth"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
@@ -114,7 +115,16 @@ func (n *nodeAPI) OutputAtBlock(ctx context.Context, number hexutil.Uint64) (*et
 	}
 
 	var l2OutputRootVersion eth.Bytes32 // it's zero for now
-	l2OutputRoot := rollup.ComputeL2OutputRoot(l2OutputRootVersion, head.Hash(), head.Root(), proof.StorageHash)
+	l2OutputRoot, err := rollup.ComputeL2OutputRoot(&bindings.TypesOutputRootProof{
+		Version:                  l2OutputRootVersion,
+		StateRoot:                head.Root(),
+		MessagePasserStorageRoot: proof.StorageHash,
+		LatestBlockhash:          head.Hash(),
+	})
+	if err != nil {
+		n.log.Error("Error computing L2 output root, nil ptr passed to hashing function")
+		return nil, err
+	}
 
 	return &eth.OutputResponse{
 		Version:               l2OutputRootVersion,

op-node/node/client.go

@@ -19,6 +19,11 @@ type L2EndpointSetup interface {
 	Check() error
 }
 
+type L2SyncEndpointSetup interface {
+	Setup(ctx context.Context, log log.Logger) (cl client.RPC, err error)
+	Check() error
+}
+
 type L1EndpointSetup interface {
 	// Setup a RPC client to a L1 node to pull rollup input-data from.
 	// The results of the RPC client may be trusted for faster processing, or strictly validated.
@@ -75,6 +80,50 @@ func (p *PreparedL2Endpoints) Setup(ctx context.Context, log log.Logger) (client
 	return p.Client, nil
 }
 
+// L2SyncEndpointConfig contains configuration for the fallback sync endpoint
+type L2SyncEndpointConfig struct {
+	// Address of the L2 RPC to use for backup sync
+	L2NodeAddr string
+}
+
+var _ L2SyncEndpointSetup = (*L2SyncEndpointConfig)(nil)
+
+func (cfg *L2SyncEndpointConfig) Setup(ctx context.Context, log log.Logger) (client.RPC, error) {
+	l2Node, err := client.NewRPC(ctx, log, cfg.L2NodeAddr)
+	if err != nil {
+		return nil, err
+	}
+
+	return l2Node, nil
+}
+
+func (cfg *L2SyncEndpointConfig) Check() error {
+	if cfg.L2NodeAddr == "" {
+		return errors.New("empty L2 Node Address")
+	}
+
+	return nil
+}
+
+type L2SyncRPCConfig struct {
+	// RPC endpoint to use for syncing
+	Rpc client.RPC
+}
+
+var _ L2SyncEndpointSetup = (*L2SyncRPCConfig)(nil)
+
+func (cfg *L2SyncRPCConfig) Setup(ctx context.Context, log log.Logger) (client.RPC, error) {
+	return cfg.Rpc, nil
+}
+
+func (cfg *L2SyncRPCConfig) Check() error {
+	if cfg.Rpc == nil {
+		return errors.New("rpc cannot be nil")
+	}
+
+	return nil
+}
+
 type L1EndpointConfig struct {
 	L1NodeAddr string // Address of L1 User JSON-RPC endpoint to use (eth namespace required)
 

op-node/node/config.go

@@ -15,6 +15,7 @@ import (
 type Config struct {
 	L1     L1EndpointSetup
 	L2     L2EndpointSetup
+	L2Sync L2SyncEndpointSetup
 
 	Driver driver.Config
 

op-node/node/node.go

@@ -197,7 +197,28 @@ func (n *OpNode) initL2(ctx context.Context, cfg *Config, snapshotLog log.Logger
 		return err
 	}
 
-	n.l2Driver = driver.NewDriver(&cfg.Driver, &cfg.Rollup, n.l2Source, n.l1Source, n, n.log, snapshotLog, n.metrics)
+	var syncClient *sources.SyncClient
+	// If the L2 sync config is present, use it to create a sync client
+	if cfg.L2Sync != nil {
+		if err := cfg.L2Sync.Check(); err != nil {
+			log.Info("L2 sync config is not present, skipping L2 sync client setup", "err", err)
+		} else {
+			rpcSyncClient, err := cfg.L2Sync.Setup(ctx, n.log)
+			if err != nil {
+				return fmt.Errorf("failed to setup L2 execution-engine RPC client for backup sync: %w", err)
+			}
+
+			// The sync client's RPC is always trusted
+			config := sources.SyncClientDefaultConfig(&cfg.Rollup, true)
+
+			syncClient, err = sources.NewSyncClient(n.OnUnsafeL2Payload, rpcSyncClient, n.log, n.metrics.L2SourceCache, config)
+			if err != nil {
+				return fmt.Errorf("failed to create sync client: %w", err)
+			}
+		}
+	}
+
+	n.l2Driver = driver.NewDriver(&cfg.Driver, &cfg.Rollup, n.l2Source, n.l1Source, syncClient, n, n.log, snapshotLog, n.metrics)
 
 	return nil
 }
@@ -263,13 +284,21 @@ func (n *OpNode) initP2PSigner(ctx context.Context, cfg *Config) error {
 
 func (n *OpNode) Start(ctx context.Context) error {
 	n.log.Info("Starting execution engine driver")
+
 	// start driving engine: sync blocks by deriving them from L1 and driving them into the engine
-	err := n.l2Driver.Start()
-	if err != nil {
+	if err := n.l2Driver.Start(); err != nil {
 		n.log.Error("Could not start a rollup node", "err", err)
 		return err
 	}
 
+	// If the backup unsafe sync client is enabled, start its event loop
+	if n.l2Driver.L2SyncCl != nil {
+		if err := n.l2Driver.L2SyncCl.Start(); err != nil {
+			n.log.Error("Could not start the backup sync client", "err", err)
+			return err
+		}
+	}
+
 	return nil
 }
 
@@ -382,6 +411,13 @@ func (n *OpNode) Close() error {
 		if err := n.l2Driver.Close(); err != nil {
 			result = multierror.Append(result, fmt.Errorf("failed to close L2 engine driver cleanly: %w", err))
 		}
+
+		// If the L2 sync client is present & running, close it.
+		if n.l2Driver.L2SyncCl != nil {
+			if err := n.l2Driver.L2SyncCl.Close(); err != nil {
+				result = multierror.Append(result, fmt.Errorf("failed to close L2 engine backup sync client cleanly: %w", err))
+			}
+		}
 	}
 
 	// close L2 engine RPC client

op-node/rollup/derive/channel_out.go

@@ -213,3 +213,58 @@ func BlockToBatch(block *types.Block) (*BatchData, error) {
 		},
 	}, nil
 }
+
+// ForceCloseTxData generates the transaction data for a transaction which will force close
+// a channel. It should be given every frame of that channel which has been submitted on
+// chain. The frames should be given in order that they appear on L1.
+func ForceCloseTxData(frames []Frame) ([]byte, error) {
+	if len(frames) == 0 {
+		return nil, errors.New("must provide at least one frame")
+	}
+	frameNumbers := make(map[uint16]struct{})
+	id := frames[0].ID
+	closeNumber := uint16(0)
+	closed := false
+	for i, frame := range frames {
+		if !closed && frame.IsLast {
+			closeNumber = frame.FrameNumber
+		}
+		closed = closed || frame.IsLast
+		frameNumbers[frame.FrameNumber] = struct{}{}
+		if frame.ID != id {
+			return nil, fmt.Errorf("invalid ID in list: first ID: %v, %vth ID: %v", id, i, frame.ID)
+		}
+	}
+
+	var out bytes.Buffer
+	out.WriteByte(DerivationVersion0)
+
+	if !closed {
+		f := Frame{
+			ID:          id,
+			FrameNumber: 0,
+			Data:        nil,
+			IsLast:      true,
+		}
+		if err := f.MarshalBinary(&out); err != nil {
+			return nil, err
+		}
+	} else {
+		for i := uint16(0); i <= closeNumber; i++ {
+			if _, ok := frameNumbers[i]; ok {
+				continue
+			}
+			f := Frame{
+				ID:          id,
+				FrameNumber: i,
+				Data:        nil,
+				IsLast:      false,
+			}
+			if err := f.MarshalBinary(&out); err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	return out.Bytes(), nil
+}

op-node/rollup/derive/channel_out_test.go

@@ -5,6 +5,7 @@ import (
 	"math/big"
 	"testing"
 
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/rlp"
 	"github.com/stretchr/testify/require"
@@ -49,3 +50,69 @@ func TestRLPByteLimit(t *testing.T) {
 	require.Equal(t, err, rlp.ErrValueTooLarge)
 	require.Equal(t, out2, "")
 }
+
+func TestForceCloseTxData(t *testing.T) {
+	id := [16]byte{0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef}
+	tests := []struct {
+		frames []Frame
+		errors bool
+		output string
+	}{
+		{
+			frames: []Frame{},
+			errors: true,
+			output: "",
+		},
+		{
+			frames: []Frame{Frame{FrameNumber: 0, IsLast: false}, Frame{ID: id, FrameNumber: 1, IsLast: true}},
+			errors: true,
+			output: "",
+		},
+		{
+			frames: []Frame{Frame{ID: id, FrameNumber: 0, IsLast: false}},
+			errors: false,
+			output: "00deadbeefdeadbeefdeadbeefdeadbeef00000000000001",
+		},
+		{
+			frames: []Frame{Frame{ID: id, FrameNumber: 0, IsLast: true}},
+			errors: false,
+			output: "00",
+		},
+		{
+			frames: []Frame{Frame{ID: id, FrameNumber: 1, IsLast: false}},
+			errors: false,
+			output: "00deadbeefdeadbeefdeadbeefdeadbeef00000000000001",
+		},
+		{
+			frames: []Frame{Frame{ID: id, FrameNumber: 1, IsLast: true}},
+			errors: false,
+			output: "00deadbeefdeadbeefdeadbeefdeadbeef00000000000000",
+		},
+		{
+			frames: []Frame{Frame{ID: id, FrameNumber: 2, IsLast: true}},
+			errors: false,
+			output: "00deadbeefdeadbeefdeadbeefdeadbeef00000000000000deadbeefdeadbeefdeadbeefdeadbeef00010000000000",
+		},
+		{
+			frames: []Frame{Frame{ID: id, FrameNumber: 1, IsLast: false}, Frame{ID: id, FrameNumber: 3, IsLast: true}},
+			errors: false,
+			output: "00deadbeefdeadbeefdeadbeefdeadbeef00000000000000deadbeefdeadbeefdeadbeefdeadbeef00020000000000",
+		},
+		{
+			frames: []Frame{Frame{ID: id, FrameNumber: 1, IsLast: false}, Frame{ID: id, FrameNumber: 3, IsLast: true}, Frame{ID: id, FrameNumber: 5, IsLast: true}},
+			errors: false,
+			output: "00deadbeefdeadbeefdeadbeefdeadbeef00000000000000deadbeefdeadbeefdeadbeefdeadbeef00020000000000",
+		},
+	}
+
+	for i, test := range tests {
+		out, err := ForceCloseTxData(test.frames)
+		if test.errors {
+			require.NotNil(t, err, "Should error on tc %v", i)
+			require.Nil(t, out, "Should return no value in tc %v", i)
+		} else {
+			require.NoError(t, err, "Should not error on tc %v", i)
+			require.Equal(t, common.FromHex(test.output), out, "Should match output tc %v", i)
+		}
+	}
+}

op-node/rollup/derive/engine_queue.go

@@ -133,6 +133,7 @@ func NewEngineQueue(log log.Logger, cfg *rollup.Config, engine Engine, metrics M
 		unsafePayloads: PayloadsQueue{
 			MaxSize:  maxUnsafePayloadsMemory,
 			SizeFn:   payloadMemSize,
+			blockNos: make(map[uint64]bool),
 		},
 		prev:      prev,
 		l1Fetcher: l1Fetcher,
@@ -662,3 +663,20 @@ func (eq *EngineQueue) Reset(ctx context.Context, _ eth.L1BlockRef, _ eth.System
 	eq.logSyncProgress("reset derivation work")
 	return io.EOF
 }
+
+// GetUnsafeQueueGap retrieves the current [start, end] range of the gap between the tip of the unsafe priority queue and the unsafe head.
+// If there is no gap, the difference between end and start will be 0.
+func (eq *EngineQueue) GetUnsafeQueueGap(expectedNumber uint64) (start uint64, end uint64) {
+	// The start of the gap is always the unsafe head + 1
+	start = eq.unsafeHead.Number + 1
+
+	// If the priority queue is empty, the end is the first block number at the top of the priority queue
+	// Otherwise, the end is the expected block number
+	if first := eq.unsafePayloads.Peek(); first != nil {
+		end = first.ID().Number
+	} else {
+		end = expectedNumber
+	}
+
+	return start, end
+}

op-node/rollup/derive/payloads_queue.go

@@ -77,6 +77,7 @@ type PayloadsQueue struct {
 	pq          payloadsByNumber
 	currentSize uint64
 	MaxSize     uint64
+	blockNos    map[uint64]bool
 	SizeFn      func(p *eth.ExecutionPayload) uint64
 }
 
@@ -99,6 +100,9 @@ func (upq *PayloadsQueue) Push(p *eth.ExecutionPayload) error {
 	if p == nil {
 		return errors.New("cannot add nil payload")
 	}
+	if upq.blockNos[p.ID().Number] {
+		return errors.New("cannot add duplicate payload")
+	}
 	size := upq.SizeFn(p)
 	if size > upq.MaxSize {
 		return fmt.Errorf("cannot add payload %s, payload mem size %d is larger than max queue size %d", p.ID(), size, upq.MaxSize)
@@ -111,6 +115,7 @@ func (upq *PayloadsQueue) Push(p *eth.ExecutionPayload) error {
 	for upq.currentSize > upq.MaxSize {
 		upq.Pop()
 	}
+	upq.blockNos[p.ID().Number] = true
 	return nil
 }
 
@@ -132,5 +137,7 @@ func (upq *PayloadsQueue) Pop() *eth.ExecutionPayload {
 	}
 	ps := heap.Pop(&upq.pq).(payloadAndSize) // nosemgrep
 	upq.currentSize -= ps.size
+	// remove the key from the blockNos map
+	delete(upq.blockNos, ps.payload.ID().Number)
 	return ps.payload
 }

op-node/rollup/derive/payloads_queue_test.go

@@ -77,6 +77,7 @@ func TestPayloadsQueue(t *testing.T) {
 	pq := PayloadsQueue{
 		MaxSize:  payloadMemFixedCost * 3,
 		SizeFn:   payloadMemSize,
+		blockNos: make(map[uint64]bool),
 	}
 	require.Equal(t, 0, pq.Len())
 	require.Equal(t, (*eth.ExecutionPayload)(nil), pq.Peek())
@@ -85,6 +86,7 @@ func TestPayloadsQueue(t *testing.T) {
 	a := &eth.ExecutionPayload{BlockNumber: 3}
 	b := &eth.ExecutionPayload{BlockNumber: 4}
 	c := &eth.ExecutionPayload{BlockNumber: 5}
+	d := &eth.ExecutionPayload{BlockNumber: 6}
 	bAlt := &eth.ExecutionPayload{BlockNumber: 4}
 	require.NoError(t, pq.Push(b))
 	require.Equal(t, pq.Len(), 1)
@@ -105,28 +107,33 @@ func TestPayloadsQueue(t *testing.T) {
 	require.Equal(t, pq.Pop(), a)
 	require.Equal(t, pq.Len(), 2, "expecting to pop the lowest")
 
-	require.NoError(t, pq.Push(bAlt))
-	require.Equal(t, pq.Len(), 3)
-	require.Equal(t, pq.Peek(), b, "expecting b to be lowest, compared to bAlt and c")
+	require.Equal(t, pq.Peek(), b, "expecting b to be lowest, compared to c")
 
 	require.Equal(t, pq.Pop(), b)
-	require.Equal(t, pq.Len(), 2)
-	require.Equal(t, pq.MemSize(), 2*payloadMemFixedCost)
-
-	require.Equal(t, pq.Pop(), bAlt)
 	require.Equal(t, pq.Len(), 1)
-	require.Equal(t, pq.Peek(), c, "expecting c to only remain")
+	require.Equal(t, pq.MemSize(), payloadMemFixedCost)
+
+	require.Equal(t, pq.Pop(), c)
+	require.Equal(t, pq.Len(), 0, "expecting no items to remain")
 
-	d := &eth.ExecutionPayload{BlockNumber: 5, Transactions: []eth.Data{make([]byte, payloadMemFixedCost*3+1)}}
-	require.Error(t, pq.Push(d), "cannot add payloads that are too large")
+	e := &eth.ExecutionPayload{BlockNumber: 5, Transactions: []eth.Data{make([]byte, payloadMemFixedCost*3+1)}}
+	require.Error(t, pq.Push(e), "cannot add payloads that are too large")
 
 	require.NoError(t, pq.Push(b))
+	require.Equal(t, pq.Len(), 1, "expecting b")
+	require.Equal(t, pq.Peek(), b)
+	require.NoError(t, pq.Push(c))
 	require.Equal(t, pq.Len(), 2, "expecting b, c")
 	require.Equal(t, pq.Peek(), b)
 	require.NoError(t, pq.Push(a))
 	require.Equal(t, pq.Len(), 3, "expecting a, b, c")
 	require.Equal(t, pq.Peek(), a)
-	require.NoError(t, pq.Push(bAlt))
-	require.Equal(t, pq.Len(), 3, "expecting b, bAlt, c")
+
+	// No duplicates allowed
+	require.Error(t, pq.Push(bAlt))
+
+	require.NoError(t, pq.Push(d))
+	require.Equal(t, pq.Len(), 3)
+	require.Equal(t, pq.Peek(), b, "expecting b, c, d")
 	require.NotContainsf(t, pq.pq[:], a, "a should be dropped after 3 items already exist under max size constraint")
 }

op-node/rollup/derive/pipeline.go

@@ -51,6 +51,7 @@ type EngineQueueStage interface {
 
 	Finalize(l1Origin eth.L1BlockRef)
 	AddUnsafePayload(payload *eth.ExecutionPayload)
+	GetUnsafeQueueGap(expectedNumber uint64) (uint64, uint64)
 	Step(context.Context) error
 }
 
@@ -160,6 +161,12 @@ func (dp *DerivationPipeline) AddUnsafePayload(payload *eth.ExecutionPayload) {
 	dp.eng.AddUnsafePayload(payload)
 }
 
+// GetUnsafeQueueGap retrieves the current [start, end] range of the gap between the tip of the unsafe priority queue and the unsafe head.
+// If there is no gap, the start and end will be 0.
+func (dp *DerivationPipeline) GetUnsafeQueueGap(expectedNumber uint64) (uint64, uint64) {
+	return dp.eng.GetUnsafeQueueGap(expectedNumber)
+}
+
 // Step tries to progress the buffer.
 // An EOF is returned if there pipeline is blocked by waiting for new L1 data.
 // If ctx errors no error is returned, but the step may exit early in a state that can still be continued.

op-node/rollup/driver/driver.go

@@ -10,6 +10,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-node/eth"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
+	"github.com/ethereum-optimism/optimism/op-node/sources"
 )
 
 type Metrics interface {
@@ -48,6 +49,7 @@ type DerivationPipeline interface {
 	Reset()
 	Step(ctx context.Context) error
 	AddUnsafePayload(payload *eth.ExecutionPayload)
+	GetUnsafeQueueGap(expectedNumber uint64) (uint64, uint64)
 	Finalize(ref eth.L1BlockRef)
 	FinalizedL1() eth.L1BlockRef
 	Finalized() eth.L2BlockRef
@@ -80,7 +82,7 @@ type Network interface {
 }
 
 // NewDriver composes an events handler that tracks L1 state, triggers L2 derivation, and optionally sequences new L2 blocks.
-func NewDriver(driverCfg *Config, cfg *rollup.Config, l2 L2Chain, l1 L1Chain, network Network, log log.Logger, snapshotLog log.Logger, metrics Metrics) *Driver {
+func NewDriver(driverCfg *Config, cfg *rollup.Config, l2 L2Chain, l1 L1Chain, syncClient *sources.SyncClient, network Network, log log.Logger, snapshotLog log.Logger, metrics Metrics) *Driver {
 	l1State := NewL1State(log, metrics)
 	sequencerConfDepth := NewConfDepth(driverCfg.SequencerConfDepth, l1State.L1Head, l1)
 	findL1Origin := NewL1OriginSelector(log, cfg, sequencerConfDepth)
@@ -112,5 +114,6 @@ func NewDriver(driverCfg *Config, cfg *rollup.Config, l2 L2Chain, l1 L1Chain, ne
 		l1SafeSig:        make(chan eth.L1BlockRef, 10),
 		l1FinalizedSig:   make(chan eth.L1BlockRef, 10),
 		unsafeL2Payloads: make(chan *eth.ExecutionPayload, 10),
+		L2SyncCl:         syncClient,
 	}
 }

op-node/rollup/driver/state.go

@@ -16,6 +16,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-node/eth"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
 	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
+	"github.com/ethereum-optimism/optimism/op-node/sources"
 	"github.com/ethereum-optimism/optimism/op-service/backoff"
 )
 
@@ -63,7 +64,11 @@ type Driver struct {
 	l1SafeSig      chan eth.L1BlockRef
 	l1FinalizedSig chan eth.L1BlockRef
 
+	// Backup unsafe sync client
+	L2SyncCl *sources.SyncClient
+
 	// L2 Signals:
+
 	unsafeL2Payloads chan *eth.ExecutionPayload
 
 	l1        L1Chain
@@ -195,6 +200,12 @@ func (s *Driver) eventLoop() {
 		sequencerTimer.Reset(delay)
 	}
 
+	// Create a ticker to check if there is a gap in the engine queue every 15 seconds
+	// If there is, we send requests to the backup RPC to retrieve the missing payloads
+	// and add them to the unsafe queue.
+	altSyncTicker := time.NewTicker(15 * time.Second)
+	defer altSyncTicker.Stop()
+
 	for {
 		// If we are sequencing, and the L1 state is ready, update the trigger for the next sequencer action.
 		// This may adjust at any time based on fork-choice changes or previous errors.
@@ -223,6 +234,12 @@ func (s *Driver) eventLoop() {
 				}
 			}
 			planSequencerAction() // schedule the next sequencer action to keep the sequencing looping
+		case <-altSyncTicker.C:
+			// Check if there is a gap in the current unsafe payload queue. If there is, attempt to fetch
+			// missing payloads from the backup RPC (if it is configured).
+			if s.L2SyncCl != nil {
+				s.checkForGapInUnsafeQueue(ctx)
+			}
 		case payload := <-s.unsafeL2Payloads:
 			s.snapshot("New unsafe payload")
 			s.log.Info("Optimistically queueing unsafe L2 execution payload", "id", payload.ID())
@@ -442,3 +459,36 @@ type hashAndErrorChannel struct {
 	hash common.Hash
 	err  chan error
 }
+
+// checkForGapInUnsafeQueue checks if there is a gap in the unsafe queue and attempts to retrieve the missing payloads from the backup RPC.
+// WARNING: The sync client's attempt to retrieve the missing payloads is not guaranteed to succeed, and it will fail silently (besides
+// emitting warning logs) if the requests fail.
+func (s *Driver) checkForGapInUnsafeQueue(ctx context.Context) {
+	// subtract genesis time from wall clock to get the time elapsed since genesis, and then divide that
+	// difference by the block time to get the expected L2 block number at the current time. If the
+	// unsafe head does not have this block number, then there is a gap in the queue.
+	wallClock := uint64(time.Now().Unix())
+	genesisTimestamp := s.config.Genesis.L2Time
+	wallClockGenesisDiff := wallClock - genesisTimestamp
+	expectedL2Block := wallClockGenesisDiff / s.config.BlockTime
+
+	start, end := s.derivation.GetUnsafeQueueGap(expectedL2Block)
+	size := end - start
+
+	// Check if there is a gap between the unsafe head and the expected L2 block number at the current time.
+	if size > 0 {
+		s.log.Warn("Gap in payload queue tip and expected unsafe chain detected", "start", start, "end", end, "size", size)
+		s.log.Info("Attempting to fetch missing payloads from backup RPC", "start", start, "end", end, "size", size)
+
+		// Attempt to fetch the missing payloads from the backup unsafe sync RPC concurrently.
+		// Concurrent requests are safe here due to the engine queue being a priority queue.
+		for blockNumber := start; blockNumber <= end; blockNumber++ {
+			select {
+			case s.L2SyncCl.FetchUnsafeBlock <- blockNumber:
+				// Do nothing- the block number was successfully sent into the channel
+			default:
+				return // If the channel is full, return and wait for the next iteration of the event loop
+			}
+		}
+	}
+}

op-node/rollup/output_root.go

 package rollup
 
 import (
+	"errors"
+
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-node/eth"
-	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
 )
 
-// ComputeL2OutputRoot computes the L2 output root
-func ComputeL2OutputRoot(l2OutputRootVersion eth.Bytes32, blockHash common.Hash, blockRoot common.Hash, storageRoot common.Hash) eth.Bytes32 {
-	digest := crypto.Keccak256Hash(
-		l2OutputRootVersion[:],
-		blockRoot.Bytes(),
-		storageRoot[:],
-		blockHash.Bytes(),
-	)
-	return eth.Bytes32(digest)
-}
+var NilProof = errors.New("Output root proof is nil")
+
+// ComputeL2OutputRoot computes the L2 output root by hashing an output root proof.
+func ComputeL2OutputRoot(proofElements *bindings.TypesOutputRootProof) (eth.Bytes32, error) {
+	if proofElements == nil {
+		return eth.Bytes32{}, NilProof
+	}
 
-// HashOutputRootProof computes the hash of the output root proof
-func HashOutputRootProof(proof *bindings.TypesOutputRootProof) eth.Bytes32 {
-	return ComputeL2OutputRoot(
-		proof.Version,
-		proof.StateRoot,
-		proof.MessagePasserStorageRoot,
-		proof.LatestBlockhash,
+	digest := crypto.Keccak256Hash(
+		proofElements.Version[:],
+		proofElements.StateRoot[:],
+		proofElements.MessagePasserStorageRoot[:],
+		proofElements.LatestBlockhash[:],
 	)
+	return eth.Bytes32(digest), nil
 }

op-node/rollup/types.go

@@ -157,7 +157,7 @@ func (cfg *Config) CheckL2ChainID(ctx context.Context, client L2Client) error {
 		return err
 	}
 	if cfg.L2ChainID.Cmp(id) != 0 {
-		return fmt.Errorf("incorrect L2 RPC chain id %d, expected %d", cfg.L2ChainID, id)
+		return fmt.Errorf("incorrect L2 RPC chain id, expected from config %d, obtained from client %d", cfg.L2ChainID, id)
 	}
 	return nil
 }

op-node/service.go

@@ -36,10 +36,7 @@ func NewConfig(ctx *cli.Context, log log.Logger) (*node.Config, error) {
 		return nil, err
 	}
 
-	driverConfig, err := NewDriverConfig(ctx)
-	if err != nil {
-		return nil, err
-	}
+	driverConfig := NewDriverConfig(ctx)
 
 	p2pSignerSetup, err := p2pcli.LoadSignerSetup(ctx)
 	if err != nil {
@@ -51,19 +48,19 @@ func NewConfig(ctx *cli.Context, log log.Logger) (*node.Config, error) {
 		return nil, fmt.Errorf("failed to load p2p config: %w", err)
 	}
 
-	l1Endpoint, err := NewL1EndpointConfig(ctx)
-	if err != nil {
-		return nil, fmt.Errorf("failed to load l1 endpoint info: %w", err)
-	}
+	l1Endpoint := NewL1EndpointConfig(ctx)
 
 	l2Endpoint, err := NewL2EndpointConfig(ctx, log)
 	if err != nil {
 		return nil, fmt.Errorf("failed to load l2 endpoints info: %w", err)
 	}
 
+	l2SyncEndpoint := NewL2SyncEndpointConfig(ctx)
+
 	cfg := &node.Config{
 		L1:     l1Endpoint,
 		L2:     l2Endpoint,
+		L2Sync: l2SyncEndpoint,
 		Rollup: *rollupConfig,
 		Driver: *driverConfig,
 		RPC: node.RPCConfig{
@@ -96,12 +93,12 @@ func NewConfig(ctx *cli.Context, log log.Logger) (*node.Config, error) {
 	return cfg, nil
 }
 
-func NewL1EndpointConfig(ctx *cli.Context) (*node.L1EndpointConfig, error) {
+func NewL1EndpointConfig(ctx *cli.Context) *node.L1EndpointConfig {
 	return &node.L1EndpointConfig{
 		L1NodeAddr: ctx.GlobalString(flags.L1NodeAddr.Name),
 		L1TrustRPC: ctx.GlobalBool(flags.L1TrustRPC.Name),
 		L1RPCKind:  sources.RPCProviderKind(strings.ToLower(ctx.GlobalString(flags.L1RPCProviderKind.Name))),
-	}, nil
+	}
 }
 
 func NewL2EndpointConfig(ctx *cli.Context, log log.Logger) (*node.L2EndpointConfig, error) {
@@ -134,13 +131,21 @@ func NewL2EndpointConfig(ctx *cli.Context, log log.Logger) (*node.L2EndpointConf
 	}, nil
 }
 
-func NewDriverConfig(ctx *cli.Context) (*driver.Config, error) {
+// NewL2SyncEndpointConfig returns a pointer to a L2SyncEndpointConfig if the
+// flag is set, otherwise nil.
+func NewL2SyncEndpointConfig(ctx *cli.Context) *node.L2SyncEndpointConfig {
+	return &node.L2SyncEndpointConfig{
+		L2NodeAddr: ctx.GlobalString(flags.BackupL2UnsafeSyncRPC.Name),
+	}
+}
+
+func NewDriverConfig(ctx *cli.Context) *driver.Config {
 	return &driver.Config{
 		VerifierConfDepth:  ctx.GlobalUint64(flags.VerifierL1Confs.Name),
 		SequencerConfDepth: ctx.GlobalUint64(flags.SequencerL1Confs.Name),
 		SequencerEnabled:   ctx.GlobalBool(flags.SequencerEnabledFlag.Name),
 		SequencerStopped:   ctx.GlobalBool(flags.SequencerStoppedFlag.Name),
-	}, nil
+	}
 }
 
 func NewRollupConfig(ctx *cli.Context) (*rollup.Config, error) {

op-node/sources/sync_client.go

+package sources
+
+import (
+	"context"
+	"errors"
+	"sync"
+
+	"github.com/ethereum-optimism/optimism/op-node/client"
+	"github.com/ethereum-optimism/optimism/op-node/eth"
+	"github.com/ethereum-optimism/optimism/op-node/rollup"
+	"github.com/ethereum-optimism/optimism/op-node/sources/caching"
+	"github.com/ethereum/go-ethereum/log"
+	"github.com/libp2p/go-libp2p/core/peer"
+)
+
+var ErrNoUnsafeL2PayloadChannel = errors.New("unsafeL2Payloads channel must not be nil")
+
+// RpcSyncPeer is a mock PeerID for the RPC sync client.
+var RpcSyncPeer peer.ID = "ALT_RPC_SYNC"
+
+type receivePayload = func(ctx context.Context, from peer.ID, payload *eth.ExecutionPayload) error
+
+type SyncClientInterface interface {
+	Start() error
+	Close() error
+	fetchUnsafeBlockFromRpc(ctx context.Context, blockNumber uint64)
+}
+
+type SyncClient struct {
+	*L2Client
+	FetchUnsafeBlock chan uint64
+	done             chan struct{}
+	receivePayload   receivePayload
+	wg               sync.WaitGroup
+}
+
+var _ SyncClientInterface = (*SyncClient)(nil)
+
+type SyncClientConfig struct {
+	L2ClientConfig
+}
+
+func SyncClientDefaultConfig(config *rollup.Config, trustRPC bool) *SyncClientConfig {
+	return &SyncClientConfig{
+		*L2ClientDefaultConfig(config, trustRPC),
+	}
+}
+
+func NewSyncClient(receiver receivePayload, client client.RPC, log log.Logger, metrics caching.Metrics, config *SyncClientConfig) (*SyncClient, error) {
+	l2Client, err := NewL2Client(client, log, metrics, &config.L2ClientConfig)
+	if err != nil {
+		return nil, err
+	}
+
+	return &SyncClient{
+		L2Client:         l2Client,
+		FetchUnsafeBlock: make(chan uint64, 128),
+		done:             make(chan struct{}),
+		receivePayload:   receiver,
+	}, nil
+}
+
+// Start starts up the state loop.
+// The loop will have been started if err is not nil.
+func (s *SyncClient) Start() error {
+	s.wg.Add(1)
+	go s.eventLoop()
+	return nil
+}
+
+// Close sends a signal to the event loop to stop.
+func (s *SyncClient) Close() error {
+	s.done <- struct{}{}
+	s.wg.Wait()
+	return nil
+}
+
+// eventLoop is the main event loop for the sync client.
+func (s *SyncClient) eventLoop() {
+	defer s.wg.Done()
+	s.log.Info("Starting sync client event loop")
+
+	for {
+		select {
+		case <-s.done:
+			return
+		case blockNumber := <-s.FetchUnsafeBlock:
+			s.fetchUnsafeBlockFromRpc(context.Background(), blockNumber)
+		}
+	}
+}
+
+// fetchUnsafeBlockFromRpc attempts to fetch an unsafe execution payload from the backup unsafe sync RPC.
+// WARNING: This function fails silently (aside from warning logs).
+//
+// Post Shanghai hardfork, the engine API's `PayloadBodiesByRange` method will be much more efficient, but for now,
+// the `eth_getBlockByNumber` method is more widely available.
+func (s *SyncClient) fetchUnsafeBlockFromRpc(ctx context.Context, blockNumber uint64) {
+	s.log.Info("Requesting unsafe payload from backup RPC", "block number", blockNumber)
+
+	payload, err := s.PayloadByNumber(ctx, blockNumber)
+	if err != nil {
+		s.log.Warn("Failed to convert block to execution payload", "block number", blockNumber, "err", err)
+		return
+	}
+
+	// Signature validation is not necessary here since the backup RPC is trusted.
+	if _, ok := payload.CheckBlockHash(); !ok {
+		s.log.Warn("Received invalid payload from backup RPC; invalid block hash", "payload", payload.ID())
+		return
+	}
+
+	s.log.Info("Received unsafe payload from backup RPC", "payload", payload.ID())
+
+	// Send the retrieved payload to the `unsafeL2Payloads` channel.
+	if err = s.receivePayload(ctx, RpcSyncPeer, payload); err != nil {
+		s.log.Warn("Failed to send payload into the driver's unsafeL2Payloads channel", "payload", payload.ID(), "err", err)
+		return
+	} else {
+		s.log.Info("Sent received payload into the driver's unsafeL2Payloads channel", "payload", payload.ID())
+	}
+}

op-node/sources/types.go

@@ -47,6 +47,9 @@ type HeaderInfo struct {
 	txHash      common.Hash
 	receiptHash common.Hash
 	gasUsed     uint64
+
+	// withdrawalsRoot was added in Shapella and is thus optional
+	withdrawalsRoot *common.Hash
 }
 
 var _ eth.BlockInfo = (*HeaderInfo)(nil)
@@ -113,7 +116,10 @@ type rpcHeader struct {
 	Nonce       types.BlockNonce `json:"nonce"`
 
 	// BaseFee was added by EIP-1559 and is ignored in legacy headers.
-	BaseFee *hexutil.Big `json:"baseFeePerGas" rlp:"optional"`
+	BaseFee *hexutil.Big `json:"baseFeePerGas"`
+
+	// WithdrawalsRoot was added by EIP-4895 and is ignored in legacy headers.
+	WithdrawalsRoot *common.Hash `json:"withdrawalsRoot"`
 
 	// untrusted info included by RPC, may have to be checked
 	Hash common.Hash `json:"hash"`
@@ -160,6 +166,7 @@ func (hdr *rpcHeader) computeBlockHash() common.Hash {
 		MixDigest:       hdr.MixDigest,
 		Nonce:           hdr.Nonce,
 		BaseFee:         (*big.Int)(hdr.BaseFee),
+		WithdrawalsHash: hdr.WithdrawalsRoot,
 	}
 	return gethHeader.Hash()
 }
@@ -188,6 +195,7 @@ func (hdr *rpcHeader) Info(trustCache bool, mustBePostMerge bool) (*HeaderInfo,
 		txHash:          hdr.TxHash,
 		receiptHash:     hdr.ReceiptHash,
 		gasUsed:         uint64(hdr.GasUsed),
+		withdrawalsRoot: hdr.WithdrawalsRoot,
 	}
 	return &info, nil
 }

op-proposer/proposer/l2_output_submitter.go

@@ -384,30 +384,31 @@ func (l *L2OutputSubmitter) loop() {
 	for {
 		select {
 		case <-ticker.C:
-			cCtx, cancel := context.WithTimeout(ctx, 3*time.Minute)
+			cCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
 			output, shouldPropose, err := l.FetchNextOutputInfo(cCtx)
-			if err != nil {
-				l.log.Error("Failed to fetch next output", "err", err)
 			cancel()
+			if err != nil {
 				break
 			}
 			if !shouldPropose {
-				cancel()
 				break
 			}
 
+			cCtx, cancel = context.WithTimeout(ctx, 30*time.Second)
 			tx, err := l.CreateProposalTx(cCtx, output)
+			cancel()
 			if err != nil {
 				l.log.Error("Failed to create proposal transaction", "err", err)
-				cancel()
 				break
 			}
+			cCtx, cancel = context.WithTimeout(ctx, 10*time.Minute)
 			if err := l.SendTransaction(cCtx, tx); err != nil {
 				l.log.Error("Failed to send proposal transaction", "err", err)
 				cancel()
 				break
-			}
+			} else {
 				cancel()
+			}
 
 		case <-l.done:
 			return

packages/actor-tests/CHANGELOG.md

 # @eth-optimism/actor-tests
 
+## 0.0.23
+
+### Patch Changes
+
+- Updated dependencies [22c3885f5]
+- Updated dependencies [66cafc00a]
+- Updated dependencies [f52c07529]
+  - @eth-optimism/contracts-bedrock@0.13.1
+  - @eth-optimism/sdk@2.0.1
+
 ## 0.0.22
 
 ### Patch Changes

packages/actor-tests/package.json

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

packages/atst/CHANGELOG.md

 # @eth-optimism/atst
 
+## 0.2.0
+
+### Minor Changes
+
+- dcd13eec1: Update readAttestations and prepareWriteAttestation to handle keys longer than 32 bytes
+- 9fd5be8e2: Remove broken allowFailures as option
+- 3f4a43542: Move react api to @eth-optimism/atst/react so react isn't required to run the core sdk
+- 71727eae9: Fix main and module in atst package.json
+- 3d5f26c49: Deprecate parseAttestationBytes and createRawKey in favor for createKey, createValue
+
+### Patch Changes
+
+- 68bbe48b6: Update docs
+- 6fea2f2db: Fixed bug with atst not defaulting to currently connected chain
+
 ## 0.1.0
 
 ### Minor Changes

packages/atst/package.json

 {
   "name": "@eth-optimism/atst",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "main": "dist/index.cjs",
   "types": "src/index.ts",

packages/chain-mon/CHANGELOG.md

 # @eth-optimism/drippie-mon
 
+## 0.2.1
+
+### Patch Changes
+
+- Updated dependencies [fecd42d67]
+- Updated dependencies [66cafc00a]
+  - @eth-optimism/common-ts@0.8.1
+  - @eth-optimism/sdk@2.0.1
+
 ## 0.2.0
 
 ### Minor Changes

packages/chain-mon/package.json

 {
   "private": true,
   "name": "@eth-optimism/chain-mon",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "[Optimism] Chain monitoring services",
   "main": "dist/index",
   "types": "dist/index",
@@ -32,10 +32,10 @@
     "url": "https://github.com/ethereum-optimism/optimism.git"
   },
   "dependencies": {
-    "@eth-optimism/common-ts": "0.8.0",
+    "@eth-optimism/common-ts": "0.8.1",
     "@eth-optimism/contracts-periphery": "1.0.7",
     "@eth-optimism/core-utils": "0.12.0",
-    "@eth-optimism/sdk": "2.0.0",
+    "@eth-optimism/sdk": "2.0.1",
     "ethers": "^5.7.0",
     "@types/dateformat": "^5.0.0",
     "chai-as-promised": "^7.1.1",

packages/common-ts/CHANGELOG.md

 # @eth-optimism/common-ts
 
+## 0.8.1
+
+### Patch Changes
+
+- fecd42d67: Fix BaseServiceV2 configuration for caseCase options
+
 ## 0.8.0
 
 ### Minor Changes

packages/common-ts/package.json

 {
   "name": "@eth-optimism/common-ts",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "[Optimism] Advanced typescript tooling used by various services",
   "main": "dist/index",
   "types": "dist/index",

packages/contracts-bedrock/.gas-snapshot

@@ -266,9 +266,9 @@ OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_ifOutp
 OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_ifOutputTimestampIsNotFinalized_reverts() (gas: 207520)
 OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_ifWithdrawalNotProven_reverts() (gas: 41753)
 OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_ifWithdrawalProofNotOldEnough_reverts() (gas: 199464)
-OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_onInsufficientGas_reverts() (gas: 206360)
+OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_onInsufficientGas_reverts() (gas: 205818)
 OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_onRecentWithdrawal_reverts() (gas: 180229)
-OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_onReentrancy_reverts() (gas: 244377)
+OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_onReentrancy_reverts() (gas: 243835)
 OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_onReplay_reverts() (gas: 245528)
 OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_paused_reverts() (gas: 53555)
 OptimismPortal_FinalizeWithdrawal_Test:test_finalizeWithdrawalTransaction_provenWithdrawalHash_succeeds() (gas: 234941)

packages/contracts-bedrock/.gitignore

@@ -12,3 +12,4 @@ deployments/mainnet-forked
 deploy-config/mainnet-forked.json
 test-case-generator/fuzz
 .resource-metering.csv
+scripts/differential-testing/differential-testing

packages/contracts-bedrock/CHANGELOG.md

 # @eth-optimism/contracts-bedrock
 
+## 0.13.1
+
+### Patch Changes
+
+- 22c3885f5: Optionally print cast commands during migration
+- f52c07529: Print tenderly simulation links during deployment
+
 ## 0.13.0
 
 ### Minor Changes

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

@@ -477,16 +477,15 @@ contract FFIInterface is Test {
             bytes[] memory
         )
     {
-        string[] memory cmds = new string[](9);
-        cmds[0] = "node";
-        cmds[1] = "dist/scripts/differential-testing.js";
-        cmds[2] = "getProveWithdrawalTransactionInputs";
-        cmds[3] = vm.toString(_tx.nonce);
-        cmds[4] = vm.toString(_tx.sender);
-        cmds[5] = vm.toString(_tx.target);
-        cmds[6] = vm.toString(_tx.value);
-        cmds[7] = vm.toString(_tx.gasLimit);
-        cmds[8] = vm.toString(_tx.data);
+        string[] memory cmds = new string[](8);
+        cmds[0] = "scripts/differential-testing/differential-testing";
+        cmds[1] = "getProveWithdrawalTransactionInputs";
+        cmds[2] = vm.toString(_tx.nonce);
+        cmds[3] = vm.toString(_tx.sender);
+        cmds[4] = vm.toString(_tx.target);
+        cmds[5] = vm.toString(_tx.value);
+        cmds[6] = vm.toString(_tx.gasLimit);
+        cmds[7] = vm.toString(_tx.data);
 
         bytes memory result = vm.ffi(cmds);
         (
@@ -508,16 +507,15 @@ contract FFIInterface is Test {
         uint256 _gasLimit,
         bytes memory _data
     ) external returns (bytes32) {
-        string[] memory cmds = new string[](9);
-        cmds[0] = "node";
-        cmds[1] = "dist/scripts/differential-testing.js";
-        cmds[2] = "hashCrossDomainMessage";
-        cmds[3] = vm.toString(_nonce);
-        cmds[4] = vm.toString(_sender);
-        cmds[5] = vm.toString(_target);
-        cmds[6] = vm.toString(_value);
-        cmds[7] = vm.toString(_gasLimit);
-        cmds[8] = vm.toString(_data);
+        string[] memory cmds = new string[](8);
+        cmds[0] = "scripts/differential-testing/differential-testing";
+        cmds[1] = "hashCrossDomainMessage";
+        cmds[2] = vm.toString(_nonce);
+        cmds[3] = vm.toString(_sender);
+        cmds[4] = vm.toString(_target);
+        cmds[5] = vm.toString(_value);
+        cmds[6] = vm.toString(_gasLimit);
+        cmds[7] = vm.toString(_data);
 
         bytes memory result = vm.ffi(cmds);
         return abi.decode(result, (bytes32));
@@ -531,16 +529,15 @@ contract FFIInterface is Test {
         uint256 _gasLimit,
         bytes memory _data
     ) external returns (bytes32) {
-        string[] memory cmds = new string[](9);
-        cmds[0] = "node";
-        cmds[1] = "dist/scripts/differential-testing.js";
-        cmds[2] = "hashWithdrawal";
-        cmds[3] = vm.toString(_nonce);
-        cmds[4] = vm.toString(_sender);
-        cmds[5] = vm.toString(_target);
-        cmds[6] = vm.toString(_value);
-        cmds[7] = vm.toString(_gasLimit);
-        cmds[8] = vm.toString(_data);
+        string[] memory cmds = new string[](8);
+        cmds[0] = "scripts/differential-testing/differential-testing";
+        cmds[1] = "hashWithdrawal";
+        cmds[2] = vm.toString(_nonce);
+        cmds[3] = vm.toString(_sender);
+        cmds[4] = vm.toString(_target);
+        cmds[5] = vm.toString(_value);
+        cmds[6] = vm.toString(_gasLimit);
+        cmds[7] = vm.toString(_data);
 
         bytes memory result = vm.ffi(cmds);
         return abi.decode(result, (bytes32));
@@ -552,14 +549,13 @@ contract FFIInterface is Test {
         bytes32 _messagePasserStorageRoot,
         bytes32 _latestBlockhash
     ) external returns (bytes32) {
-        string[] memory cmds = new string[](7);
-        cmds[0] = "node";
-        cmds[1] = "dist/scripts/differential-testing.js";
-        cmds[2] = "hashOutputRootProof";
-        cmds[3] = Strings.toHexString(uint256(_version));
-        cmds[4] = Strings.toHexString(uint256(_stateRoot));
-        cmds[5] = Strings.toHexString(uint256(_messagePasserStorageRoot));
-        cmds[6] = Strings.toHexString(uint256(_latestBlockhash));
+        string[] memory cmds = new string[](6);
+        cmds[0] = "scripts/differential-testing/differential-testing";
+        cmds[1] = "hashOutputRootProof";
+        cmds[2] = Strings.toHexString(uint256(_version));
+        cmds[3] = Strings.toHexString(uint256(_stateRoot));
+        cmds[4] = Strings.toHexString(uint256(_messagePasserStorageRoot));
+        cmds[5] = Strings.toHexString(uint256(_latestBlockhash));
 
         bytes memory result = vm.ffi(cmds);
         return abi.decode(result, (bytes32));
@@ -572,20 +568,19 @@ contract FFIInterface is Test {
         uint256 _value,
         uint64 _gas,
         bytes memory _data,
-        uint256 _logIndex
+        uint64 _logIndex
     ) external returns (bytes32) {
-        string[] memory cmds = new string[](11);
-        cmds[0] = "node";
-        cmds[1] = "dist/scripts/differential-testing.js";
-        cmds[2] = "hashDepositTransaction";
-        cmds[3] = "0x0000000000000000000000000000000000000000000000000000000000000000";
-        cmds[4] = vm.toString(_logIndex);
-        cmds[5] = vm.toString(_from);
-        cmds[6] = vm.toString(_to);
-        cmds[7] = vm.toString(_mint);
-        cmds[8] = vm.toString(_value);
-        cmds[9] = vm.toString(_gas);
-        cmds[10] = vm.toString(_data);
+        string[] memory cmds = new string[](10);
+        cmds[0] = "scripts/differential-testing/differential-testing";
+        cmds[1] = "hashDepositTransaction";
+        cmds[2] = "0x0000000000000000000000000000000000000000000000000000000000000000";
+        cmds[3] = vm.toString(_logIndex);
+        cmds[4] = vm.toString(_from);
+        cmds[5] = vm.toString(_to);
+        cmds[6] = vm.toString(_mint);
+        cmds[7] = vm.toString(_value);
+        cmds[8] = vm.toString(_gas);
+        cmds[9] = vm.toString(_data);
 
         bytes memory result = vm.ffi(cmds);
         return abi.decode(result, (bytes32));
@@ -595,19 +590,18 @@ contract FFIInterface is Test {
         external
         returns (bytes memory)
     {
-        string[] memory cmds = new string[](12);
-        cmds[0] = "node";
-        cmds[1] = "dist/scripts/differential-testing.js";
-        cmds[2] = "encodeDepositTransaction";
-        cmds[3] = vm.toString(txn.from);
-        cmds[4] = vm.toString(txn.to);
-        cmds[5] = vm.toString(txn.value);
-        cmds[6] = vm.toString(txn.mint);
-        cmds[7] = vm.toString(txn.gasLimit);
-        cmds[8] = vm.toString(txn.isCreation);
-        cmds[9] = vm.toString(txn.data);
-        cmds[10] = vm.toString(txn.l1BlockHash);
-        cmds[11] = vm.toString(txn.logIndex);
+        string[] memory cmds = new string[](11);
+        cmds[0] = "scripts/differential-testing/differential-testing";
+        cmds[1] = "encodeDepositTransaction";
+        cmds[2] = vm.toString(txn.from);
+        cmds[3] = vm.toString(txn.to);
+        cmds[4] = vm.toString(txn.value);
+        cmds[5] = vm.toString(txn.mint);
+        cmds[6] = vm.toString(txn.gasLimit);
+        cmds[7] = vm.toString(txn.isCreation);
+        cmds[8] = vm.toString(txn.data);
+        cmds[9] = vm.toString(txn.l1BlockHash);
+        cmds[10] = vm.toString(txn.logIndex);
 
         bytes memory result = vm.ffi(cmds);
         return abi.decode(result, (bytes));
@@ -621,27 +615,25 @@ contract FFIInterface is Test {
         uint256 _gasLimit,
         bytes memory _data
     ) external returns (bytes memory) {
-        string[] memory cmds = new string[](9);
-        cmds[0] = "node";
-        cmds[1] = "dist/scripts/differential-testing.js";
-        cmds[2] = "encodeCrossDomainMessage";
-        cmds[3] = vm.toString(_nonce);
-        cmds[4] = vm.toString(_sender);
-        cmds[5] = vm.toString(_target);
-        cmds[6] = vm.toString(_value);
-        cmds[7] = vm.toString(_gasLimit);
-        cmds[8] = vm.toString(_data);
+        string[] memory cmds = new string[](8);
+        cmds[0] = "scripts/differential-testing/differential-testing";
+        cmds[1] = "encodeCrossDomainMessage";
+        cmds[2] = vm.toString(_nonce);
+        cmds[3] = vm.toString(_sender);
+        cmds[4] = vm.toString(_target);
+        cmds[5] = vm.toString(_value);
+        cmds[6] = vm.toString(_gasLimit);
+        cmds[7] = vm.toString(_data);
 
         bytes memory result = vm.ffi(cmds);
         return abi.decode(result, (bytes));
     }
 
     function decodeVersionedNonce(uint256 nonce) external returns (uint256, uint256) {
-        string[] memory cmds = new string[](4);
-        cmds[0] = "node";
-        cmds[1] = "dist/scripts/differential-testing.js";
-        cmds[2] = "decodeVersionedNonce";
-        cmds[3] = vm.toString(nonce);
+        string[] memory cmds = new string[](3);
+        cmds[0] = "scripts/differential-testing/differential-testing";
+        cmds[1] = "decodeVersionedNonce";
+        cmds[2] = vm.toString(nonce);
 
         bytes memory result = vm.ffi(cmds);
         return abi.decode(result, (uint256, uint256));

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

@@ -91,7 +91,7 @@ contract Encoding_Test is CommonTest {
         uint64 _gas,
         bool isCreate,
         bytes memory _data,
-        uint256 _logIndex
+        uint64 _logIndex
     ) external {
         Types.UserDepositTransaction memory t = Types.UserDepositTransaction(
             _from,

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

@@ -129,7 +129,7 @@ contract Hashing_hashDepositTransaction_Test is CommonTest {
         uint256 _value,
         uint64 _gas,
         bytes memory _data,
-        uint256 _logIndex
+        uint64 _logIndex
     ) external {
         assertEq(
             Hashing.hashDepositTransaction(

packages/contracts-bedrock/package.json

 {
   "name": "@eth-optimism/contracts-bedrock",
-  "version": "0.13.0",
+  "version": "0.13.1",
   "description": "Contracts for Optimism Specs",
   "main": "dist/index",
   "types": "dist/index",
@@ -17,7 +17,7 @@
     "bindings": "cd ../../op-bindings && make",
     "build:forge": "forge build",
     "build:with-metadata": "FOUNDRY_PROFILE=echidna yarn build:forge",
-    "build:differential": "tsc scripts/differential-testing.ts --outDir dist --moduleResolution node --esModuleInterop",
+    "build:differential": "go build -o ./scripts/differential-testing/differential-testing ./scripts/differential-testing",
     "build:fuzz": "(cd test-case-generator && go build ./cmd/fuzz.go)",
     "prebuild": "yarn ts-node scripts/verify-foundry-install.ts",
     "build": "hardhat compile && yarn autogen:artifacts && yarn build:ts && yarn typechain",
@@ -59,8 +59,6 @@
   },
   "devDependencies": {
     "@eth-optimism/hardhat-deploy-config": "^0.2.5",
-    "@ethereumjs/trie": "^5.0.0-beta.1",
-    "@ethereumjs/util": "^8.0.0-beta.1",
     "@ethersproject/abstract-provider": "^5.7.0",
     "@ethersproject/abstract-signer": "^5.7.0",
     "ethereumjs-wallet": "^1.0.2",

packages/contracts-bedrock/scripts/differential-testing.ts

-import { BigNumber, utils, constants } from 'ethers'
-import {
-  decodeVersionedNonce,
-  hashCrossDomainMessage,
-  DepositTx,
-  SourceHashDomain,
-  encodeCrossDomainMessage,
-  hashWithdrawal,
-  hashOutputRootProof,
-} from '@eth-optimism/core-utils'
-import { SecureTrie } from '@ethereumjs/trie'
-import { Account, Address, toBuffer, bufferToHex } from '@ethereumjs/util'
-
-import { predeploys } from '../src'
-
-const { hexZeroPad, keccak256 } = utils
-
-const args = process.argv.slice(2)
-const command = args[0]
-
-;(async () => {
-  switch (command) {
-    case 'decodeVersionedNonce': {
-      const input = BigNumber.from(args[1])
-      const { nonce, version } = decodeVersionedNonce(input)
-
-      const output = utils.defaultAbiCoder.encode(
-        ['uint256', 'uint256'],
-        [nonce.toHexString(), version.toHexString()]
-      )
-      process.stdout.write(output)
-      break
-    }
-    case 'encodeCrossDomainMessage': {
-      const nonce = BigNumber.from(args[1])
-      const sender = args[2]
-      const target = args[3]
-      const value = BigNumber.from(args[4])
-      const gasLimit = BigNumber.from(args[5])
-      const data = args[6]
-
-      const encoding = encodeCrossDomainMessage(
-        nonce,
-        sender,
-        target,
-        value,
-        gasLimit,
-        data
-      )
-
-      const output = utils.defaultAbiCoder.encode(['bytes'], [encoding])
-      process.stdout.write(output)
-      break
-    }
-    case 'hashCrossDomainMessage': {
-      const nonce = BigNumber.from(args[1])
-      const sender = args[2]
-      const target = args[3]
-      const value = BigNumber.from(args[4])
-      const gasLimit = BigNumber.from(args[5])
-      const data = args[6]
-
-      const hash = hashCrossDomainMessage(
-        nonce,
-        sender,
-        target,
-        value,
-        gasLimit,
-        data
-      )
-      const output = utils.defaultAbiCoder.encode(['bytes32'], [hash])
-      process.stdout.write(output)
-      break
-    }
-    case 'hashDepositTransaction': {
-      // The solidity transaction hash computation currently only works with
-      // user deposits. System deposit transaction hashing is not supported.
-      const l1BlockHash = args[1]
-      const logIndex = BigNumber.from(args[2])
-      const from = args[3]
-      const to = args[4]
-      const mint = BigNumber.from(args[5])
-      const value = BigNumber.from(args[6])
-      const gas = BigNumber.from(args[7])
-      const data = args[8]
-
-      const tx = new DepositTx({
-        l1BlockHash,
-        logIndex,
-        from,
-        to,
-        mint,
-        value,
-        gas,
-        data,
-        isSystemTransaction: false,
-        domain: SourceHashDomain.UserDeposit,
-      })
-
-      const digest = tx.hash()
-      const output = utils.defaultAbiCoder.encode(['bytes32'], [digest])
-      process.stdout.write(output)
-      break
-    }
-    case 'encodeDepositTransaction': {
-      const from = args[1]
-      const to = args[2]
-      const value = BigNumber.from(args[3])
-      const mint = BigNumber.from(args[4])
-      const gasLimit = BigNumber.from(args[5])
-      const isCreate = args[6] === 'true' ? true : false
-      const data = args[7]
-      const l1BlockHash = args[8]
-      const logIndex = BigNumber.from(args[9])
-
-      const tx = new DepositTx({
-        from,
-        to: isCreate ? null : to,
-        value,
-        mint,
-        gas: gasLimit,
-        data,
-        l1BlockHash,
-        logIndex,
-        domain: SourceHashDomain.UserDeposit,
-      })
-
-      const raw = tx.encode()
-      const output = utils.defaultAbiCoder.encode(['bytes'], [raw])
-      process.stdout.write(output)
-      break
-    }
-    case 'hashWithdrawal': {
-      const nonce = BigNumber.from(args[1])
-      const sender = args[2]
-      const target = args[3]
-      const value = BigNumber.from(args[4])
-      const gas = BigNumber.from(args[5])
-      const data = args[6]
-
-      const hash = hashWithdrawal(nonce, sender, target, value, gas, data)
-      const output = utils.defaultAbiCoder.encode(['bytes32'], [hash])
-      process.stdout.write(output)
-      break
-    }
-    case 'hashOutputRootProof': {
-      const version = hexZeroPad(BigNumber.from(args[1]).toHexString(), 32)
-      const stateRoot = hexZeroPad(BigNumber.from(args[2]).toHexString(), 32)
-      const messagePasserStorageRoot = hexZeroPad(
-        BigNumber.from(args[3]).toHexString(),
-        32
-      )
-      const latestBlockhash = hexZeroPad(
-        BigNumber.from(args[4]).toHexString(),
-        32
-      )
-
-      const hash = hashOutputRootProof({
-        version,
-        stateRoot,
-        messagePasserStorageRoot,
-        latestBlockhash,
-      })
-      const output = utils.defaultAbiCoder.encode(['bytes32'], [hash])
-      process.stdout.write(output)
-      break
-    }
-    case 'getProveWithdrawalTransactionInputs': {
-      const nonce = BigNumber.from(args[1])
-      const sender = args[2]
-      const target = args[3]
-      const value = BigNumber.from(args[4])
-      const gas = BigNumber.from(args[5])
-      const data = args[6]
-
-      // Compute the withdrawalHash
-      const withdrawalHash = hashWithdrawal(
-        nonce,
-        sender,
-        target,
-        value,
-        gas,
-        data
-      )
-
-      // Compute the storage slot the withdrawalHash will be stored in
-      const slot = utils.defaultAbiCoder.encode(
-        ['bytes32', 'bytes32'],
-        [withdrawalHash, utils.hexZeroPad('0x', 32)]
-      )
-      const key = keccak256(slot)
-
-      // Create the account storage trie
-      const storage = new SecureTrie()
-      // Put a bool "true" into storage
-      await storage.put(toBuffer(key), toBuffer('0x01'))
-
-      // Put the storage root into the L2ToL1MessagePasser storage
-      const address = Address.fromString(predeploys.L2ToL1MessagePasser)
-      const account = Account.fromAccountData({
-        nonce: 0,
-        balance: 0,
-        stateRoot: storage.root,
-      })
-
-      const world = new SecureTrie()
-      await world.put(address.toBuffer(), account.serialize())
-
-      const proof = await SecureTrie.createProof(storage, toBuffer(key))
-
-      const outputRoot = hashOutputRootProof({
-        version: constants.HashZero,
-        stateRoot: bufferToHex(world.root),
-        messagePasserStorageRoot: bufferToHex(storage.root),
-        latestBlockhash: constants.HashZero,
-      })
-
-      const output = utils.defaultAbiCoder.encode(
-        ['bytes32', 'bytes32', 'bytes32', 'bytes32', 'bytes[]'],
-        [world.root, storage.root, outputRoot, withdrawalHash, proof]
-      )
-      process.stdout.write(output)
-      break
-    }
-  }
-})().catch((err: Error) => {
-  console.error(err)
-  process.stdout.write('')
-})

packages/contracts-bedrock/scripts/differential-testing/differential-testing.go

+package main
+
+import (
+	"bytes"
+	"fmt"
+	"math/big"
+	"os"
+
+	"github.com/ethereum-optimism/optimism/op-bindings/predeploys"
+	"github.com/ethereum-optimism/optimism/op-chain-ops/crossdomain"
+	"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/core/rawdb"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/crypto"
+	"github.com/ethereum/go-ethereum/trie"
+)
+
+// ABI types
+var (
+	// Plain dynamic dynBytes type
+	dynBytes, _ = abi.NewType("bytes", "", nil)
+	bytesArgs   = abi.Arguments{
+		{Type: dynBytes},
+	}
+
+	// Plain fixed bytes32 type
+	fixedBytes, _  = abi.NewType("bytes32", "", nil)
+	fixedBytesArgs = abi.Arguments{
+		{Type: fixedBytes},
+	}
+
+	// Decoded nonce tuple (nonce, version)
+	decodedNonce, _ = abi.NewType("tuple", "DecodedNonce", []abi.ArgumentMarshaling{
+		{Name: "nonce", Type: "uint256"},
+		{Name: "version", Type: "uint256"},
+	})
+	decodedNonceArgs = abi.Arguments{
+		{Name: "encodedNonce", Type: decodedNonce},
+	}
+
+	// WithdrawalHash slot tuple (bytes32, bytes32)
+	withdrawalSlot, _ = abi.NewType("tuple", "SlotHash", []abi.ArgumentMarshaling{
+		{Name: "withdrawalHash", Type: "bytes32"},
+		{Name: "zeroPadding", Type: "bytes32"},
+	})
+	withdrawalSlotArgs = abi.Arguments{
+		{Name: "slotHash", Type: withdrawalSlot},
+	}
+
+	// Prove withdrawal inputs tuple (bytes32, bytes32, bytes32, bytes32, bytes[])
+	proveWithdrawalInputs, _ = abi.NewType("tuple", "ProveWithdrawalInputs", []abi.ArgumentMarshaling{
+		{Name: "worldRoot", Type: "bytes32"},
+		{Name: "stateRoot", Type: "bytes32"},
+		{Name: "outputRoot", Type: "bytes32"},
+		{Name: "withdrawalHash", Type: "bytes32"},
+		{Name: "proof", Type: "bytes[]"},
+	})
+	proveWithdrawalInputsArgs = abi.Arguments{
+		{Name: "inputs", Type: proveWithdrawalInputs},
+	}
+)
+
+func main() {
+	args := os.Args[1:]
+
+	// This command requires arguments
+	if len(args) == 0 {
+		panic("Error: No arguments provided")
+	}
+
+	switch args[0] {
+	case "decodeVersionedNonce":
+		// Parse input arguments
+		input, ok := new(big.Int).SetString(args[1], 10)
+		checkOk(ok)
+
+		// Decode versioned nonce
+		nonce, version := crossdomain.DecodeVersionedNonce(input)
+
+		// ABI encode output
+		packArgs := struct {
+			Nonce   *big.Int
+			Version *big.Int
+		}{
+			nonce,
+			version,
+		}
+		packed, err := decodedNonceArgs.Pack(&packArgs)
+		checkErr(err, "Error encoding output")
+
+		fmt.Print(hexutil.Encode(packed))
+	case "encodeCrossDomainMessage":
+		// Parse input arguments
+		nonce, ok := new(big.Int).SetString(args[1], 10)
+		checkOk(ok)
+		sender := common.HexToAddress(args[2])
+		target := common.HexToAddress(args[3])
+		value, ok := new(big.Int).SetString(args[4], 10)
+		checkOk(ok)
+		gasLimit, ok := new(big.Int).SetString(args[5], 10)
+		checkOk(ok)
+		data := common.FromHex(args[6])
+
+		// Encode cross domain message
+		encoded, err := encodeCrossDomainMessage(nonce, sender, target, value, gasLimit, data)
+		checkErr(err, "Error encoding cross domain message")
+
+		// Pack encoded cross domain message
+		packed, err := bytesArgs.Pack(&encoded)
+		checkErr(err, "Error encoding output")
+
+		fmt.Print(hexutil.Encode(packed))
+	case "hashCrossDomainMessage":
+		// Parse input arguments
+		nonce, ok := new(big.Int).SetString(args[1], 10)
+		checkOk(ok)
+		sender := common.HexToAddress(args[2])
+		target := common.HexToAddress(args[3])
+		value, ok := new(big.Int).SetString(args[4], 10)
+		checkOk(ok)
+		gasLimit, ok := new(big.Int).SetString(args[5], 10)
+		checkOk(ok)
+		data := common.FromHex(args[6])
+
+		// Encode cross domain message
+		encoded, err := encodeCrossDomainMessage(nonce, sender, target, value, gasLimit, data)
+		checkErr(err, "Error encoding cross domain message")
+
+		// Hash encoded cross domain message
+		hash := crypto.Keccak256Hash(encoded)
+
+		// Pack hash
+		packed, err := fixedBytesArgs.Pack(&hash)
+		checkErr(err, "Error encoding output")
+
+		fmt.Print(hexutil.Encode(packed))
+	case "hashDepositTransaction":
+		// Parse input arguments
+		l1BlockHash := common.HexToHash(args[1])
+		logIndex, ok := new(big.Int).SetString(args[2], 10)
+		checkOk(ok)
+		from := common.HexToAddress(args[3])
+		to := common.HexToAddress(args[4])
+		mint, ok := new(big.Int).SetString(args[5], 10)
+		checkOk(ok)
+		value, ok := new(big.Int).SetString(args[6], 10)
+		checkOk(ok)
+		gasLimit, ok := new(big.Int).SetString(args[7], 10)
+		checkOk(ok)
+		data := common.FromHex(args[8])
+
+		// Create deposit transaction
+		depositTx := makeDepositTx(from, to, value, mint, gasLimit, false, data, l1BlockHash, logIndex)
+
+		// RLP encode deposit transaction
+		encoded, err := types.NewTx(&depositTx).MarshalBinary()
+		checkErr(err, "Error encoding deposit transaction")
+
+		// Hash encoded deposit transaction
+		hash := crypto.Keccak256Hash(encoded)
+
+		// Pack hash
+		packed, err := fixedBytesArgs.Pack(&hash)
+		checkErr(err, "Error encoding output")
+
+		fmt.Print(hexutil.Encode(packed))
+	case "encodeDepositTransaction":
+		// Parse input arguments
+		from := common.HexToAddress(args[1])
+		to := common.HexToAddress(args[2])
+		value, ok := new(big.Int).SetString(args[3], 10)
+		checkOk(ok)
+		mint, ok := new(big.Int).SetString(args[4], 10)
+		checkOk(ok)
+		gasLimit, ok := new(big.Int).SetString(args[5], 10)
+		checkOk(ok)
+		isCreate := args[6] == "true"
+		data := common.FromHex(args[7])
+		l1BlockHash := common.HexToHash(args[8])
+		logIndex, ok := new(big.Int).SetString(args[9], 10)
+		checkOk(ok)
+
+		depositTx := makeDepositTx(from, to, value, mint, gasLimit, isCreate, data, l1BlockHash, logIndex)
+
+		// RLP encode deposit transaction
+		encoded, err := types.NewTx(&depositTx).MarshalBinary()
+		checkErr(err, "Failed to RLP encode deposit transaction")
+		// Pack rlp encoded deposit transaction
+		packed, err := bytesArgs.Pack(&encoded)
+		checkErr(err, "Error encoding output")
+
+		fmt.Print(hexutil.Encode(packed))
+	case "hashWithdrawal":
+		// Parse input arguments
+		nonce, ok := new(big.Int).SetString(args[1], 10)
+		checkOk(ok)
+		sender := common.HexToAddress(args[2])
+		target := common.HexToAddress(args[3])
+		value, ok := new(big.Int).SetString(args[4], 10)
+		checkOk(ok)
+		gasLimit, ok := new(big.Int).SetString(args[5], 10)
+		checkOk(ok)
+		data := common.FromHex(args[6])
+
+		// Hash withdrawal
+		hash, err := hashWithdrawal(nonce, sender, target, value, gasLimit, data)
+		checkErr(err, "Error hashing withdrawal")
+
+		// Pack hash
+		packed, err := fixedBytesArgs.Pack(&hash)
+		checkErr(err, "Error encoding output")
+
+		fmt.Print(hexutil.Encode(packed))
+	case "hashOutputRootProof":
+		// Parse input arguments
+		version := common.HexToHash(args[1])
+		stateRoot := common.HexToHash(args[2])
+		messagePasserStorageRoot := common.HexToHash(args[3])
+		latestBlockHash := common.HexToHash(args[4])
+
+		// Hash the output root proof
+		hash, err := hashOutputRootProof(version, stateRoot, messagePasserStorageRoot, latestBlockHash)
+		checkErr(err, "Error hashing output root proof")
+
+		// Pack hash
+		packed, err := fixedBytesArgs.Pack(&hash)
+		checkErr(err, "Error encoding output")
+
+		fmt.Print(hexutil.Encode(packed))
+	case "getProveWithdrawalTransactionInputs":
+		// Parse input arguments
+		nonce, ok := new(big.Int).SetString(args[1], 10)
+		checkOk(ok)
+		sender := common.HexToAddress(args[2])
+		target := common.HexToAddress(args[3])
+		value, ok := new(big.Int).SetString(args[4], 10)
+		checkOk(ok)
+		gasLimit, ok := new(big.Int).SetString(args[5], 10)
+		checkOk(ok)
+		data := common.FromHex(args[6])
+
+		wdHash, err := hashWithdrawal(nonce, sender, target, value, gasLimit, data)
+		checkErr(err, "Error hashing withdrawal")
+
+		// Compute the storage slot the withdrawalHash will be stored in
+		slot := struct {
+			WithdrawalHash common.Hash
+			ZeroPadding    common.Hash
+		}{
+			WithdrawalHash: wdHash,
+			ZeroPadding:    common.Hash{},
+		}
+		packed, err := withdrawalSlotArgs.Pack(&slot)
+		checkErr(err, "Error packing withdrawal slot")
+
+		// Compute the storage slot the withdrawalHash will be stored in
+		hash := crypto.Keccak256Hash(packed)
+
+		// Create a secure trie for state
+		state, err := trie.NewStateTrie(
+			trie.TrieID(types.EmptyRootHash),
+			trie.NewDatabase(rawdb.NewMemoryDatabase()),
+		)
+		checkErr(err, "Error creating secure trie")
+
+		// Put a "true" bool in the storage slot
+		state.Update(hash.Bytes(), []byte{0x01})
+
+		// Create a secure trie for the world state
+		world, err := trie.NewStateTrie(
+			trie.TrieID(types.EmptyRootHash),
+			trie.NewDatabase(rawdb.NewMemoryDatabase()),
+		)
+		checkErr(err, "Error creating secure trie")
+
+		// Put the put the rlp encoded account in the world trie
+		account := types.StateAccount{
+			Nonce:   0,
+			Balance: big.NewInt(0),
+			Root:    state.Hash(),
+		}
+		writer := new(bytes.Buffer)
+		checkErr(account.EncodeRLP(writer), "Error encoding account")
+		world.Update(predeploys.L2ToL1MessagePasserAddr.Bytes(), writer.Bytes())
+
+		// Get the proof
+		var proof proofList
+		checkErr(state.Prove(predeploys.L2ToL1MessagePasserAddr.Bytes(), 0, &proof), "Error getting proof")
+
+		// Get the output root
+		outputRoot, err := hashOutputRootProof(common.Hash{}, world.Hash(), state.Hash(), common.Hash{})
+		checkErr(err, "Error hashing output root proof")
+
+		// Pack the output
+		output := struct {
+			WorldRoot      common.Hash
+			StateRoot      common.Hash
+			OutputRoot     common.Hash
+			WithdrawalHash common.Hash
+			Proof          proofList
+		}{
+			WorldRoot:      world.Hash(),
+			StateRoot:      state.Hash(),
+			OutputRoot:     outputRoot,
+			WithdrawalHash: wdHash,
+			Proof:          proof,
+		}
+		packed, err = proveWithdrawalInputsArgs.Pack(&output)
+		checkErr(err, "Error encoding output")
+
+		// Print the output
+		fmt.Print(hexutil.Encode(packed[32:]))
+	default:
+		panic(fmt.Errorf("Unknown command: %s", args[0]))
+	}
+}

packages/contracts-bedrock/scripts/differential-testing/utils.go

+package main
+
+import (
+	"errors"
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum-optimism/optimism/op-chain-ops/crossdomain"
+	"github.com/ethereum-optimism/optimism/op-node/rollup"
+	"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+)
+
+var UnknownNonceVersion = errors.New("Unknown nonce version")
+
+// checkOk checks if ok is false, and panics if so.
+// Shorthand to ease go's god awful error handling
+func checkOk(ok bool) {
+	if !ok {
+		panic(fmt.Errorf("checkOk failed"))
+	}
+}
+
+// checkErr checks if err is not nil, and throws if so.
+// Shorthand to ease go's god awful error handling
+func checkErr(err error, failReason string) {
+	if err != nil {
+		panic(fmt.Errorf("%s: %s", failReason, err))
+	}
+}
+
+// encodeCrossDomainMessage encodes a versioned cross domain message into a byte array.
+func encodeCrossDomainMessage(nonce *big.Int, sender common.Address, target common.Address, value *big.Int, gasLimit *big.Int, data []byte) ([]byte, error) {
+	_, version := crossdomain.DecodeVersionedNonce(nonce)
+
+	var encoded []byte
+	var err error
+	if version.Cmp(big.NewInt(0)) == 0 {
+		// Encode cross domain message V0
+		encoded, err = crossdomain.EncodeCrossDomainMessageV0(target, sender, data, nonce)
+	} else if version.Cmp(big.NewInt(1)) == 0 {
+		// Encode cross domain message V1
+		encoded, err = crossdomain.EncodeCrossDomainMessageV1(nonce, sender, target, value, gasLimit, data)
+	} else {
+		return nil, UnknownNonceVersion
+	}
+
+	return encoded, err
+}
+
+// hashWithdrawal hashes a withdrawal transaction.
+func hashWithdrawal(nonce *big.Int, sender common.Address, target common.Address, value *big.Int, gasLimit *big.Int, data []byte) (common.Hash, error) {
+	wd := crossdomain.Withdrawal{
+		Nonce:    nonce,
+		Sender:   &sender,
+		Target:   &target,
+		Value:    value,
+		GasLimit: gasLimit,
+		Data:     data,
+	}
+	return wd.Hash()
+}
+
+// hashOutputRootProof hashes an output root proof.
+func hashOutputRootProof(version common.Hash, stateRoot common.Hash, messagePasserStorageRoot common.Hash, latestBlockHash common.Hash) (common.Hash, error) {
+	hash, err := rollup.ComputeL2OutputRoot(&bindings.TypesOutputRootProof{
+		Version:                  version,
+		StateRoot:                stateRoot,
+		MessagePasserStorageRoot: messagePasserStorageRoot,
+		LatestBlockhash:          latestBlockHash,
+	})
+	if err != nil {
+		return common.Hash{}, err
+	}
+	return common.Hash(hash), nil
+}
+
+// makeDepositTx creates a deposit transaction type.
+func makeDepositTx(
+	from common.Address,
+	to common.Address,
+	value *big.Int,
+	mint *big.Int,
+	gasLimit *big.Int,
+	isCreate bool,
+	data []byte,
+	l1BlockHash common.Hash,
+	logIndex *big.Int,
+) types.DepositTx {
+	// Create deposit transaction source
+	udp := derive.UserDepositSource{
+		L1BlockHash: l1BlockHash,
+		LogIndex:    logIndex.Uint64(),
+	}
+
+	// Create deposit transaction
+	depositTx := types.DepositTx{
+		SourceHash:          udp.SourceHash(),
+		From:                from,
+		Value:               value,
+		Gas:                 gasLimit.Uint64(),
+		IsSystemTransaction: false, // This will never be a system transaction in the tests.
+		Data:                data,
+	}
+
+	// Fill optional fields
+	if mint.Cmp(big.NewInt(0)) == 1 {
+		depositTx.Mint = mint
+	}
+	if !isCreate {
+		depositTx.To = &to
+	}
+
+	return depositTx
+}
+
+// Custom type to write the generated proof to
+type proofList [][]byte
+
+func (n *proofList) Put(key []byte, value []byte) error {
+	*n = append(*n, value)
+	return nil
+}
+
+func (n *proofList) Delete(key []byte) error {
+	panic("not supported")
+}

packages/contracts-periphery/package.json

@@ -53,7 +53,7 @@
     "url": "https://github.com/ethereum-optimism/optimism.git"
   },
   "devDependencies": {
-    "@eth-optimism/contracts-bedrock": "0.13.0",
+    "@eth-optimism/contracts-bedrock": "0.13.1",
     "@eth-optimism/core-utils": "^0.12.0",
     "@eth-optimism/hardhat-deploy-config": "^0.2.5",
     "@ethersproject/hardware-wallets": "^5.7.0",

packages/data-transport-layer/CHANGELOG.md

 # data transport layer
 
+## 0.5.54
+
+### Patch Changes
+
+- Updated dependencies [fecd42d67]
+  - @eth-optimism/common-ts@0.8.1
+
 ## 0.5.53
 
 ### Patch Changes

packages/data-transport-layer/package.json

 {
   "private": true,
   "name": "@eth-optimism/data-transport-layer",
-  "version": "0.5.53",
+  "version": "0.5.54",
   "description": "[Optimism] Service for shuttling data from L1 into L2",
   "main": "dist/index",
   "types": "dist/index",
@@ -36,7 +36,7 @@
     "url": "https://github.com/ethereum-optimism/optimism.git"
   },
   "dependencies": {
-    "@eth-optimism/common-ts": "0.8.0",
+    "@eth-optimism/common-ts": "0.8.1",
     "@eth-optimism/contracts": "0.5.40",
     "@eth-optimism/core-utils": "0.12.0",
     "@ethersproject/providers": "^5.7.0",

packages/fault-detector/CHANGELOG.md

 # @eth-optimism/fault-detector
 
+## 0.6.2
+
+### Patch Changes
+
+- f9b579d55: Fixes a bug that would cause the fault detector to error out if no outputs had been proposed yet.
+- Updated dependencies [fecd42d67]
+- Updated dependencies [66cafc00a]
+  - @eth-optimism/common-ts@0.8.1
+  - @eth-optimism/sdk@2.0.1
+
 ## 0.6.1
 
 ### Patch Changes

packages/fault-detector/package.json

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

packages/message-relayer/CHANGELOG.md

 # @eth-optimism/message-relayer
 
+## 0.5.32
+
+### Patch Changes
+
+- Updated dependencies [fecd42d67]
+- Updated dependencies [66cafc00a]
+  - @eth-optimism/common-ts@0.8.1
+  - @eth-optimism/sdk@2.0.1
+
 ## 0.5.31
 
 ### Patch Changes

packages/message-relayer/package.json

 {
   "private": true,
   "name": "@eth-optimism/message-relayer",
-  "version": "0.5.31",
+  "version": "0.5.32",
   "description": "[Optimism] Service for automatically relaying L2 to L1 transactions",
   "main": "dist/index",
   "types": "dist/index",
@@ -31,9 +31,9 @@
     "url": "https://github.com/ethereum-optimism/optimism.git"
   },
   "dependencies": {
-    "@eth-optimism/common-ts": "0.8.0",
+    "@eth-optimism/common-ts": "0.8.1",
     "@eth-optimism/core-utils": "0.12.0",
-    "@eth-optimism/sdk": "2.0.0",
+    "@eth-optimism/sdk": "2.0.1",
     "ethers": "^5.7.0"
   },
   "devDependencies": {

packages/replica-healthcheck/CHANGELOG.md

 # @eth-optimism/replica-healthcheck
 
+## 1.2.3
+
+### Patch Changes
+
+- Updated dependencies [fecd42d67]
+  - @eth-optimism/common-ts@0.8.1
+
 ## 1.2.2
 
 ### Patch Changes

packages/replica-healthcheck/package.json

 {
   "private": true,
   "name": "@eth-optimism/replica-healthcheck",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "[Optimism] Service for monitoring the health of replica nodes",
   "main": "dist/index",
   "types": "dist/index",
@@ -32,7 +32,7 @@
     "url": "https://github.com/ethereum-optimism/optimism.git"
   },
   "dependencies": {
-    "@eth-optimism/common-ts": "0.8.0",
+    "@eth-optimism/common-ts": "0.8.1",
     "@eth-optimism/core-utils": "0.12.0",
     "@ethersproject/abstract-provider": "^5.7.0"
   },

packages/sdk/CHANGELOG.md

 # @eth-optimism/sdk
 
+## 2.0.1
+
+### Patch Changes
+
+- 66cafc00a: Update migrated withdrawal gaslimit calculation
+- Updated dependencies [22c3885f5]
+- Updated dependencies [f52c07529]
+  - @eth-optimism/contracts-bedrock@0.13.1
+
 ## 2.0.0
 
 ### Major Changes

packages/sdk/package.json

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

packages/two-step-monitor/.depcheckrc

-ignores: [
-  "@babel/eslint-parser",
-  "@typescript-eslint/parser",
-  "eslint-plugin-import",
-  "eslint-plugin-unicorn",
-  "eslint-plugin-jsdoc",
-  "eslint-plugin-prefer-arrow",
-  "eslint-plugin-react",
-  "@typescript-eslint/eslint-plugin",
-  "eslint-config-prettier",
-  "eslint-plugin-prettier",
-  "chai"
-]

packages/two-step-monitor/.env.example

-# URL for an L1 RPC provider, used to query L2 output proposals
-TWO_STEP_MONITOR__L1_RPC_PROVIDER=
-
-# URL for an L2 RPC provider, used to query canonical L2 state
-TWO_STEP_MONITOR__L2_RPC_PROVIDER=
-
-TWO_STEP_MONITOR__HOSTNAME=
-TWO_STEP_MONITOR__PORT=
-
-TWO_STEP_MONITOR__START_BATCH_INDEX=
-TWO_STEP_MONITOR__LOOP_INTERVAL_MS=

packages/two-step-monitor/.eslintrc.js

-module.exports = {
-  extends: '../../.eslintrc.js',
-}

packages/two-step-monitor/.gitignore

-node_modules/
-build/

packages/two-step-monitor/.lintstagedrc.yml

-"*.{ts,js}":
-  - eslint

packages/two-step-monitor/.prettierrc.js

-module.exports = {
-  ...require('../../.prettierrc.js'),
-};

packages/two-step-monitor/LICENSE

-(The MIT License)
-
-Copyright 2020-2021 Optimism
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/two-step-monitor/README.md

-# @eth-optimism/two-step-monitor
-
-[![codecov](https://codecov.io/gh/ethereum-optimism/optimism/branch/develop/graph/badge.svg?token=0VTG7PG7YR&flag=two-step-monitor-tests)](https://codecov.io/gh/ethereum-optimism/optimism)
-
-The `two-step-monitor` is a simple service for detecting discrepancies between withdrawals created on L2, and
-withdrawals proven on L1.
-
-## Installation
-
-Clone, install, and build the Optimism monorepo:
-
-```
-git clone https://github.com/ethereum-optimism/optimism.git
-yarn install
-yarn build
-```
-
-## Running the service
-
-Copy `.env.example` into a new file named `.env`, then set the environment variables listed there.
-Once your environment variables have been set, run the service via:
-
-```
-yarn start
-```
-
-## Ports
-
-- API is exposed at `$TWO_STEP_MONITOR__HOSTNAME:$TWO_STEP_MONITOR__PORT/api`
-- Metrics are exposed at `$TWO_STEP_MONITOR__HOSTNAME:$TWO_STEP_MONITOR__PORT/metrics`
-- `$TWO_STEP_MONITOR__HOSTNAME` defaults to `0.0.0.0`
-- `$TWO_STEP_MONITOR__PORT` defaults to `7300`
-
-## What this service does
-
-The `two-step-monitor` detects when a withdrawal is proven on L1, and verifies that a corresponding withdrawal
-has been created on L2.
-
-We export a series of Prometheus metrics that you can use to trigger alerting when issues are detected.
-Check the list of available metrics via `yarn start --help`:
-
-```sh
-> yarn start --help
-yarn run v1.22.19
-$ ts-node ./src/service.ts --help
-Usage: service [options]
-
-Options:
-  --l1rpcprovider    Provider for interacting with L1 (env: TWO_STEP_MONITOR__L1_RPC_PROVIDER)
-  --l2rpcprovider    Provider for interacting with L2 (env: TWO_STEP_MONITOR__L2_RPC_PROVIDER)
-  --port             Port for the app server (env: TWO_STEP_MONITOR__PORT)
-  --hostname         Hostname for the app server (env: TWO_STEP_MONITOR__HOSTNAME)
-  -h, --help         display help for command
-
-Metrics:
-  l1_node_connection_failures   Number of times L1 node connection has failed (type: Gauge)
-  l2_node_connection_failures   Number of times L2 node connection has failed (type: Gauge)
-  metadata                      Service metadata (type: Gauge)
-  unhandled_errors              Unhandled errors (type: Counter)
-
-Done in 2.19s.
-```

packages/two-step-monitor/hardhat.config.ts

-import { HardhatUserConfig } from 'hardhat/types'
-
-// Hardhat plugins
-import '@nomiclabs/hardhat-ethers'
-import '@nomiclabs/hardhat-waffle'
-
-const config: HardhatUserConfig = {
-  mocha: {
-    timeout: 50000,
-  },
-}
-
-export default config

packages/two-step-monitor/package.json

-{
-  "private": true,
-  "name": "@eth-optimism/two-step-monitor",
-  "version": "0.5.0",
-  "description": "[Optimism] Service for detecting faulty L2 output proposals",
-  "main": "dist/index",
-  "types": "dist/index",
-  "files": [
-    "dist/*"
-  ],
-  "scripts": {
-    "start": "ts-node ./src/service.ts",
-    "test": "hardhat test",
-    "test:coverage": "nyc hardhat test && nyc merge .nyc_output coverage.json",
-    "build": "tsc -p tsconfig.json",
-    "clean": "rimraf dist/ ./tsconfig.tsbuildinfo",
-    "lint": "yarn lint:fix && yarn lint:check",
-    "pre-commit": "lint-staged",
-    "lint:fix": "yarn lint:check --fix",
-    "lint:check": "eslint . --max-warnings=0"
-  },
-  "keywords": [
-    "optimism",
-    "ethereum",
-    "fault",
-    "detector"
-  ],
-  "homepage": "https://github.com/ethereum-optimism/optimism/tree/develop/packages/two-step-monitor#readme",
-  "license": "MIT",
-  "author": "Optimism PBC",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/ethereum-optimism/optimism.git"
-  },
-  "devDependencies": {
-    "@nomiclabs/hardhat-ethers": "^2.0.6",
-    "@nomiclabs/hardhat-waffle": "^2.0.3",
-    "@types/chai": "^4.3.1",
-    "chai-as-promised": "^7.1.1",
-    "ethers": "^5.7.0",
-    "hardhat": "^2.9.6",
-    "ts-node": "^10.9.1"
-  }
-}

packages/two-step-monitor/src/index.ts

-export * from './service'

packages/two-step-monitor/src/service.ts

-export const todo = 'implement me'