Merge branch 'develop' into indexer.fetcher

op-chain-ops/ether/migrate.go

@@ -182,7 +182,7 @@ func doMigration(mutableDB *state.StateDB, dbFactory util.DBFactory, addresses [
 			if noCheck {
 				log.Error("unknown slot type", "slot", key, "type", slotType)
 			} else {
-				log.Crit("unknown slot type %d, should never happen", slotType)
+				log.Crit("unknown slot type, should never happen", "type", slotType)
 			}
 		}
 
@@ -209,10 +209,10 @@ func doMigration(mutableDB *state.StateDB, dbFactory util.DBFactory, addresses [
 
 	// Print first 10 accounts without balance
 	aleft := 10
-	log.Info("Listing first %d accounts without balance", aleft)
+	log.Info("Listing first accounts without balance", "num", aleft)
 	for i, a := range addresses {
 		if !seenAccounts[a] {
-			log.Info("Account[%d] without balance", i, "addr", a)
+			log.Info("Account without balance", "idx", i, "addr", a)
 			aleft--
 		}
 		if aleft == 0 {

op-challenger/challenger/challenger.go

@@ -54,6 +54,33 @@ type Challenger struct {
 	networkTimeout time.Duration
 }
 
+// From returns the address of the account used to send transactions.
+func (c *Challenger) From() common.Address {
+	return c.txMgr.From()
+}
+
+// Client returns the client for the settlement layer.
+func (c *Challenger) Client() *ethclient.Client {
+	return c.l1Client
+}
+
+func (c *Challenger) NewOracleSubscription() (*Subscription, error) {
+	query, err := BuildOutputLogFilter(c.l2ooABI)
+	if err != nil {
+		return nil, err
+	}
+	return NewSubscription(query, c.Client(), c.log), nil
+}
+
+// NewFactorySubscription creates a new [Subscription] listening to the DisputeGameFactory contract.
+func (c *Challenger) NewFactorySubscription() (*Subscription, error) {
+	query, err := BuildDisputeGameLogFilter(c.dgfABI)
+	if err != nil {
+		return nil, err
+	}
+	return NewSubscription(query, c.Client(), c.log), nil
+}
+
 // NewChallenger creates a new Challenger
 func NewChallenger(cfg config.Config, l log.Logger, m metrics.Metricer) (*Challenger, error) {
 	ctx, cancel := context.WithCancel(context.Background())

op-challenger/challenger/factory.go

+package challenger
+
+import (
+	"errors"
+
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/common"
+)
+
+var ErrMissingFactoryEvent = errors.New("missing factory event")
+
+// BuildDisputeGameLogFilter creates a filter query for the DisputeGameFactory contract.
+//
+// The `DisputeGameCreated` event is encoded as:
+// 0: address indexed disputeProxy,
+// 1: GameType indexed gameType,
+// 2: Claim indexed rootClaim,
+func BuildDisputeGameLogFilter(contract *abi.ABI) (ethereum.FilterQuery, error) {
+	event := contract.Events["DisputeGameCreated"]
+
+	if event.ID == (common.Hash{}) {
+		return ethereum.FilterQuery{}, ErrMissingFactoryEvent
+	}
+
+	query := ethereum.FilterQuery{
+		Topics: [][]common.Hash{
+			{event.ID},
+		},
+	}
+
+	return query, nil
+}

op-challenger/challenger/factory_test.go

+package challenger
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	eth "github.com/ethereum/go-ethereum"
+	abi "github.com/ethereum/go-ethereum/accounts/abi"
+	common "github.com/ethereum/go-ethereum/common"
+)
+
+// TestBuildDisputeGameLogFilter_Succeeds tests that the DisputeGame
+// Log Filter is built correctly.
+func TestBuildDisputeGameLogFilter_Succeeds(t *testing.T) {
+	event := abi.Event{
+		ID: [32]byte{0x01},
+	}
+
+	filterQuery := eth.FilterQuery{
+		Topics: [][]common.Hash{
+			{event.ID},
+		},
+	}
+
+	dgfABI := abi.ABI{
+		Events: map[string]abi.Event{
+			"DisputeGameCreated": event,
+		},
+	}
+
+	query, err := BuildDisputeGameLogFilter(&dgfABI)
+	require.Equal(t, filterQuery, query)
+	require.NoError(t, err)
+}
+
+// TestBuildDisputeGameLogFilter_Fails tests that the DisputeGame
+// Log Filter fails when the event definition is missing.
+func TestBuildDisputeGameLogFilter_Fails(t *testing.T) {
+	dgfABI := abi.ABI{
+		Events: map[string]abi.Event{},
+	}
+
+	_, err := BuildDisputeGameLogFilter(&dgfABI)
+	require.ErrorIs(t, ErrMissingFactoryEvent, err)
+}

op-challenger/challenger/subscription.go

@@ -61,6 +61,11 @@ func (s *Subscription) Started() bool {
 	return s.started
 }
 
+// Logs returns the log channel.
+func (s *Subscription) Logs() <-chan types.Log {
+	return s.logs
+}
+
 // Subscribe constructs the subscription.
 func (s *Subscription) Subscribe() error {
 	s.log.Info("Subscribing to", "query", s.query.Topics, "id", s.id)

op-challenger/challenger/entrypoint.go → op-challenger/cmd/entrypoint.go

-package challenger
+package main
 
 import (
 	"context"
@@ -10,8 +10,11 @@ import (
 	"github.com/ethereum-optimism/optimism/op-challenger/config"
 	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
 	"github.com/ethereum-optimism/optimism/op-service/opio"
-	oppprof "github.com/ethereum-optimism/optimism/op-service/pprof"
-	oprpc "github.com/ethereum-optimism/optimism/op-service/rpc"
+
+	"github.com/ethereum-optimism/optimism/op-challenger/challenger"
+
+	"github.com/ethereum-optimism/optimism/op-service/pprof"
+	"github.com/ethereum-optimism/optimism/op-service/rpc"
 )
 
 // Main is the entrypoint into the Challenger. This method executes the
@@ -24,7 +27,7 @@ func Main(logger log.Logger, version string, cfg *config.Config) error {
 	m := metrics.NewMetrics("default")
 	logger.Info("Initializing Challenger")
 
-	challenger, err := NewChallenger(*cfg, logger, m)
+	service, err := challenger.NewChallenger(*cfg, logger, m)
 	if err != nil {
 		logger.Error("Unable to create the Challenger", "error", err)
 		return err
@@ -32,19 +35,19 @@ func Main(logger log.Logger, version string, cfg *config.Config) error {
 
 	logger.Info("Starting Challenger")
 	ctx, cancel := context.WithCancel(context.Background())
-	if err := challenger.Start(); err != nil {
+	if err := service.Start(); err != nil {
 		cancel()
 		logger.Error("Unable to start Challenger", "error", err)
 		return err
 	}
-	defer challenger.Stop()
+	defer service.Stop()
 
 	logger.Info("Challenger started")
 	pprofConfig := cfg.PprofConfig
 	if pprofConfig.Enabled {
 		logger.Info("starting pprof", "addr", pprofConfig.ListenAddr, "port", pprofConfig.ListenPort)
 		go func() {
-			if err := oppprof.ListenAndServe(ctx, pprofConfig.ListenAddr, pprofConfig.ListenPort); err != nil {
+			if err := pprof.ListenAndServe(ctx, pprofConfig.ListenAddr, pprofConfig.ListenPort); err != nil {
 				logger.Error("error starting pprof", "err", err)
 			}
 		}()
@@ -58,11 +61,11 @@ func Main(logger log.Logger, version string, cfg *config.Config) error {
 				logger.Error("error starting metrics server", err)
 			}
 		}()
-		m.StartBalanceMetrics(ctx, logger, challenger.l1Client, challenger.txMgr.From())
+		m.StartBalanceMetrics(ctx, logger, service.Client(), service.From())
 	}
 
 	rpcCfg := cfg.RPCConfig
-	server := oprpc.NewServer(rpcCfg.ListenAddr, rpcCfg.ListenPort, version, oprpc.WithLogger(logger))
+	server := rpc.NewServer(rpcCfg.ListenAddr, rpcCfg.ListenPort, version, rpc.WithLogger(logger))
 	if err := server.Start(); err != nil {
 		cancel()
 		return fmt.Errorf("error starting RPC server: %w", err)

op-challenger/cmd/main.go

 package main
 
 import (
-	"fmt"
 	"os"
 
-	challenger "github.com/ethereum-optimism/optimism/op-challenger/challenger"
+	log "github.com/ethereum/go-ethereum/log"
+	cli "github.com/urfave/cli"
+
+	watch "github.com/ethereum-optimism/optimism/op-challenger/cmd/watch"
 	config "github.com/ethereum-optimism/optimism/op-challenger/config"
 	flags "github.com/ethereum-optimism/optimism/op-challenger/flags"
 	version "github.com/ethereum-optimism/optimism/op-challenger/version"
 
-	log "github.com/ethereum/go-ethereum/log"
-	cli "github.com/urfave/cli"
-
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
 )
 
@@ -37,7 +36,7 @@ var VersionWithMeta = func() string {
 
 func main() {
 	args := os.Args
-	if err := run(args, challenger.Main); err != nil {
+	if err := run(args, Main); err != nil {
 		log.Crit("Application failed", "err", err)
 	}
 }
@@ -59,7 +58,7 @@ func run(args []string, action ConfigAction) error {
 	app.Usage = "Challenge Invalid L2OutputOracle Outputs"
 	app.Description = "A modular op-stack challenge agent for dispute games written in golang."
 	app.Action = func(ctx *cli.Context) error {
-		logger, err := setupLogging(ctx)
+		logger, err := config.LoggerFromCLI(ctx)
 		if err != nil {
 			return err
 		}
@@ -71,15 +70,12 @@ func run(args []string, action ConfigAction) error {
 		}
 		return action(logger, VersionWithMeta, cfg)
 	}
+	app.Commands = []cli.Command{
+		{
+			Name:        "watch",
+			Subcommands: watch.Subcommands,
+		},
+	}
 
 	return app.Run(args)
 }
-
-func setupLogging(ctx *cli.Context) (log.Logger, error) {
-	logCfg := oplog.ReadCLIConfig(ctx)
-	if err := logCfg.Check(); err != nil {
-		return nil, fmt.Errorf("log config error: %w", err)
-	}
-	logger := oplog.NewLogger(logCfg)
-	return logger, nil
-}

op-challenger/cmd/watch/cmd.go

+package watch
+
+import (
+	"github.com/urfave/cli"
+
+	"github.com/ethereum-optimism/optimism/op-challenger/config"
+)
+
+var Subcommands = cli.Commands{
+	{
+		Name:  "oracle",
+		Usage: "Watches the L2OutputOracle for new output proposals",
+		Action: func(ctx *cli.Context) error {
+			logger, err := config.LoggerFromCLI(ctx)
+			if err != nil {
+				return err
+			}
+			logger.Info("Listening for new output proposals")
+
+			cfg, err := config.NewConfigFromCLI(ctx)
+			if err != nil {
+				return err
+			}
+
+			return Oracle(logger, cfg)
+		},
+	},
+	{
+		Name:  "factory",
+		Usage: "Watches the DisputeGameFactory for new dispute games",
+		Action: func(ctx *cli.Context) error {
+			logger, err := config.LoggerFromCLI(ctx)
+			if err != nil {
+				return err
+			}
+			logger.Info("Listening for new dispute games")
+
+			cfg, err := config.NewConfigFromCLI(ctx)
+			if err != nil {
+				return err
+			}
+
+			return Factory(logger, cfg)
+		},
+	},
+}

op-challenger/cmd/watch/factory.go

+package watch
+
+import (
+	"fmt"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"github.com/ethereum/go-ethereum/log"
+
+	"github.com/ethereum-optimism/optimism/op-challenger/challenger"
+	"github.com/ethereum-optimism/optimism/op-challenger/config"
+	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
+)
+
+// Factory listens to the DisputeGameFactory for newly created dispute games.
+func Factory(logger log.Logger, cfg *config.Config) error {
+	if err := cfg.Check(); err != nil {
+		return fmt.Errorf("invalid config: %w", err)
+	}
+
+	m := metrics.NewMetrics("default")
+
+	service, err := challenger.NewChallenger(*cfg, logger, m)
+	if err != nil {
+		logger.Error("Unable to create the Challenger", "error", err)
+		return err
+	}
+
+	logger.Info("Listening for DisputeGameCreated events from the DisputeGameFactory contract", "dgf", cfg.DGFAddress.String())
+
+	subscription, err := service.NewFactorySubscription()
+	if err != nil {
+		logger.Error("Unable to create the subscription", "error", err)
+		return err
+	}
+
+	err = subscription.Subscribe()
+	if err != nil {
+		logger.Error("Unable to subscribe to the DisputeGameFactory contract", "error", err)
+		return err
+	}
+
+	defer subscription.Quit()
+
+	interruptChannel := make(chan os.Signal, 1)
+	signal.Notify(interruptChannel, []os.Signal{
+		os.Interrupt,
+		os.Kill,
+		syscall.SIGTERM,
+		syscall.SIGQUIT,
+	}...)
+
+	for {
+		select {
+		case log := <-subscription.Logs():
+			logger.Info("Received log", "log", log)
+		case <-interruptChannel:
+			logger.Info("Received interrupt signal, exiting...")
+		}
+	}
+}

op-challenger/cmd/watch/oracle.go

+package watch
+
+import (
+	"fmt"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"github.com/ethereum/go-ethereum/log"
+
+	"github.com/ethereum-optimism/optimism/op-challenger/challenger"
+	"github.com/ethereum-optimism/optimism/op-challenger/config"
+	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
+)
+
+// Oracle listens to the L2OutputOracle for newly proposed outputs.
+func Oracle(logger log.Logger, cfg *config.Config) error {
+	if err := cfg.Check(); err != nil {
+		return fmt.Errorf("invalid config: %w", err)
+	}
+
+	m := metrics.NewMetrics("default")
+
+	service, err := challenger.NewChallenger(*cfg, logger, m)
+	if err != nil {
+		logger.Error("Unable to create the Challenger", "error", err)
+		return err
+	}
+
+	logger.Info("Listening for OutputProposed events from the L2OutputOracle contract", "l2oo", cfg.L2OOAddress.String())
+
+	subscription, err := service.NewOracleSubscription()
+	if err != nil {
+		logger.Error("Unable to create the subscription", "error", err)
+		return err
+	}
+
+	err = subscription.Subscribe()
+	if err != nil {
+		logger.Error("Unable to subscribe to the L2OutputOracle contract", "error", err)
+		return err
+	}
+
+	defer subscription.Quit()
+
+	interruptChannel := make(chan os.Signal, 1)
+	signal.Notify(interruptChannel, []os.Signal{
+		os.Interrupt,
+		os.Kill,
+		syscall.SIGTERM,
+		syscall.SIGQUIT,
+	}...)
+
+	for {
+		select {
+		case log := <-subscription.Logs():
+			logger.Info("Received log", "log", log)
+		case <-interruptChannel:
+			logger.Info("Received interrupt signal, exiting...")
+		}
+	}
+}

op-challenger/config/logging.go

+package config
+
+import (
+	"fmt"
+
+	log "github.com/ethereum/go-ethereum/log"
+	cli "github.com/urfave/cli"
+
+	oplog "github.com/ethereum-optimism/optimism/op-service/log"
+)
+
+// LoggerFromCLI creates a [log.Logger] from the
+// supplied [cli.Context].
+func LoggerFromCLI(ctx *cli.Context) (log.Logger, error) {
+	logCfg := oplog.ReadCLIConfig(ctx)
+	if err := logCfg.Check(); err != nil {
+		return nil, fmt.Errorf("log config error: %w", err)
+	}
+	logger := oplog.NewLogger(logCfg)
+	return logger, nil
+}

packages/contracts-bedrock/foundry.toml

@@ -22,6 +22,7 @@ no_match_contract = 'EchidnaFuzz'
 
 fs_permissions = [
   { 'access'='read-write', 'path'='./.resource-metering.csv' },
+  { 'access'='read', 'path'='./deployments/' },
 ]
 
 [profile.ci]

packages/contracts-bedrock/scripts/multisig/README.md

+## Multisig Operation Scripts
+
+A collection of scripts used by multisig signers to verify the
+integrity of the transactions to be signed.
+
+
+### Contract Verification for Bedrock Migration
+
+[CheckForBedrockMigration.s.sol](./CheckForBedrockMigration.s.sol) is
+a script used by the Bedrock migration signers before the migration,
+to verify the contracts affected by the migration are always under the
+control of the multisig, and security critical configurations are
+correctly initialized.
+
+Example usage:
+
+``` bash
+git clone git@github.com:ethereum-optimism/optimism.git
+cd optimism/
+git pull
+git checkout develop
+nvm use
+yarn install
+yarn clean
+yarn build
+cd packages/contracts-bedrock
+export L1_UPGRADE_KEY=0x9BA6e03D8B90dE867373Db8cF1A58d2F7F006b3A
+export BEDROCK_JSON_DIR=deployments/mainnet
+forge script scripts/multisig/CheckForBedrockMigration.s.sol --rpc-url <TRUSTWORTHY_L1_RPC_URL>
+```
+
+Expected output:
+
+``` bash
+Script ran successfully.
+
+  BEDROCK_JSON_DIR = deployments/mainnet
+  Checking AddressManager 0xdE1FCfB0851916CA5101820A69b13a4E276bd81F
+    -- Success: 0x9BA6e03D8B90dE867373Db8cF1A58d2F7F006b3A == 0xdE1FCfB0851916CA5101820A69b13a4E276bd81F.owner().
+  Checking L1CrossDomainMessenger 0x2150Bc3c64cbfDDbaC9815EF615D6AB8671bfe43
+    -- Success: 0xbEb5Fc579115071764c7423A4f12eDde41f106Ed == 0x2150Bc3c64cbfDDbaC9815EF615D6AB8671bfe43.PORTAL().
+  Checking L1CrossDomainMessengerProxy 0x25ace71c97B33Cc4729CF772ae268934F7ab5fA1
+    -- Success: 0x9BA6e03D8B90dE867373Db8cF1A58d2F7F006b3A == 0x25ace71c97B33Cc4729CF772ae268934F7ab5fA1.owner().
+    -- Success: 0xdE1FCfB0851916CA5101820A69b13a4E276bd81F == 0x25ace71c97B33Cc4729CF772ae268934F7ab5fA1.libAddressManager().
+  Checking L1ERC721Bridge 0x4afDD3A48E13B305e98D9EEad67B1b5867E370DF
+    -- Success: 0x25ace71c97B33Cc4729CF772ae268934F7ab5fA1 == 0x4afDD3A48E13B305e98D9EEad67B1b5867E370DF.messenger().
+  Checking L1ERC721BridgeProxy 0x5a7749f83b81B301cAb5f48EB8516B986DAef23D
+    -- Success: 0x9BA6e03D8B90dE867373Db8cF1A58d2F7F006b3A == 0x5a7749f83b81B301cAb5f48EB8516B986DAef23D.admin().
+    -- Success: 0x25ace71c97B33Cc4729CF772ae268934F7ab5fA1 == 0x5a7749f83b81B301cAb5f48EB8516B986DAef23D.messenger().
+  Checking L1ProxyAdmin 0x543bA4AADBAb8f9025686Bd03993043599c6fB04
+    -- Success: 0xB4453CEb33d2e67FA244A24acf2E50CEF31F53cB == 0x543bA4AADBAb8f9025686Bd03993043599c6fB04.owner().
+  Checking L1StandardBridge 0xBFB731Cd36D26c2a7287716DE857E4380C73A64a
+    -- Success: 0x25ace71c97B33Cc4729CF772ae268934F7ab5fA1 == 0xBFB731Cd36D26c2a7287716DE857E4380C73A64a.messenger().
+  Checking L1StandardBridgeProxy 0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1
+    -- Success: 0x9BA6e03D8B90dE867373Db8cF1A58d2F7F006b3A == 0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1.getOwner().
+    -- Success: 0x25ace71c97B33Cc4729CF772ae268934F7ab5fA1 == 0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1.messenger().
+  Checking L1UpgradeKeyAddress 0x9BA6e03D8B90dE867373Db8cF1A58d2F7F006b3A
+  Checking L2OutputOracle 0xd2E67B6a032F0A9B1f569E63ad6C38f7342c2e00
+    -- Success: 0x9BA6e03D8B90dE867373Db8cF1A58d2F7F006b3A == 0xd2E67B6a032F0A9B1f569E63ad6C38f7342c2e00.CHALLENGER().
+    -- Success: 0x0000000000000000000000000000000000093A80 == 0xd2E67B6a032F0A9B1f569E63ad6C38f7342c2e00.FINALIZATION_PERIOD_SECONDS().
+  Checking L2OutputOracleProxy 0xdfe97868233d1aa22e815a266982f2cf17685a27
+    -- Success: 0x543bA4AADBAb8f9025686Bd03993043599c6fB04 == 0xdfe97868233d1aa22e815a266982f2cf17685a27.admin().
+  Checking OptimismMintableERC20Factory 0xaE849EFA4BcFc419593420e14707996936E365E2
+    -- Success: 0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1 == 0xaE849EFA4BcFc419593420e14707996936E365E2.BRIDGE().
+  Checking OptimismMintableERC20FactoryProxy 0x75505a97BD334E7BD3C476893285569C4136Fa0F
+    -- Success: 0x543bA4AADBAb8f9025686Bd03993043599c6fB04 == 0x75505a97BD334E7BD3C476893285569C4136Fa0F.admin().
+  Checking OptimismPortal 0x28a55488fef40005309e2DA0040DbE9D300a64AB
+    -- Success: 0xdfe97868233d1aa22e815a266982f2cf17685a27 == 0x28a55488fef40005309e2DA0040DbE9D300a64AB.L2_ORACLE().
+  Checking OptimismPortalProxy 0xbEb5Fc579115071764c7423A4f12eDde41f106Ed
+    -- Success: 0x543bA4AADBAb8f9025686Bd03993043599c6fB04 == 0xbEb5Fc579115071764c7423A4f12eDde41f106Ed.admin().
+  Checking PortalSender 0x0A893d9576b9cFD9EF78595963dc973238E78210
+    -- Success: 0xbEb5Fc579115071764c7423A4f12eDde41f106Ed == 0x0A893d9576b9cFD9EF78595963dc973238E78210.PORTAL().
+  Checking SystemConfigProxy 0x229047fed2591dbec1eF1118d64F7aF3dB9EB290
+    -- Success: 0x543bA4AADBAb8f9025686Bd03993043599c6fB04 == 0x229047fed2591dbec1eF1118d64F7aF3dB9EB290.admin().
+  Checking SystemDictator 0x09E040a72FD3492355C5aEEdbC3154075f83488a
+    -- Success: 0x0000000000000000000000000000000000000000 == 0x09E040a72FD3492355C5aEEdbC3154075f83488a.owner().
+  Checking SystemDictatorProxy 0xB4453CEb33d2e67FA244A24acf2E50CEF31F53cB
+    -- Success: 0x09E040a72FD3492355C5aEEdbC3154075f83488a == 0xB4453CEb33d2e67FA244A24acf2E50CEF31F53cB.implementation().
+    -- Success: 0x9BA6e03D8B90dE867373Db8cF1A58d2F7F006b3A == 0xB4453CEb33d2e67FA244A24acf2E50CEF31F53cB.owner().
+    -- Success: 0x9BA6e03D8B90dE867373Db8cF1A58d2F7F006b3A == 0xB4453CEb33d2e67FA244A24acf2E50CEF31F53cB.admin().
+```

packages/contracts-bedrock/scripts/multisig/json/mainnet-migration/b1.json

+{
+  "version": "1.0",
+  "chainId": "1",
+  "meta": {
+    "name": "batch1",
+    "description": "ProxyAdmin.transferOwnership, AddressManager.transferOwnership, L1StandardBridgeProxy.setOwner, L1ERC721BridgeProxy.changeAdmin, and SystemDictatorProxy.phase1.",
+    "txBuilderVersion": "1.13.3"
+  },
+  "transactions": [
+    {
+      "to": "0x543bA4AADBAb8f9025686Bd03993043599c6fB04",
+      "value": "0",
+      "data": null,
+      "contractMethod": {
+        "inputs": [
+          {
+          "internalType": "address",
+          "name": "newOwner",
+          "type": "address"
+        }
+        ],
+        "name": "transferOwnership",
+        "payable": false
+      },
+      "contractInputsValues": {
+        "newOwner": "0xB4453CEb33d2e67FA244A24acf2E50CEF31F53cB"
+      }
+    },
+    {
+      "to": "0xdE1FCfB0851916CA5101820A69b13a4E276bd81F",
+      "value": "0",
+      "data": null,
+      "contractMethod": {
+        "inputs": [
+          {
+            "internalType": "address",
+            "name": "newOwner",
+            "type": "address"
+          }
+        ],
+        "name": "transferOwnership",
+        "payable": false
+      },
+      "contractInputsValues": {
+        "newOwner": "0xB4453CEb33d2e67FA244A24acf2E50CEF31F53cB"
+      }
+    },
+    {
+      "to": "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1",
+      "value": "0",
+      "data": null,
+      "contractMethod": {
+        "inputs": [
+          {
+            "internalType": "address",
+            "name": "_owner",
+            "type": "address"
+          }
+        ],
+        "name": "setOwner",
+        "payable": false
+      },
+      "contractInputsValues": {
+        "_owner": "0xB4453CEb33d2e67FA244A24acf2E50CEF31F53cB"
+      }
+    },
+    {
+      "to": "0x5a7749f83b81B301cAb5f48EB8516B986DAef23D",
+      "value": "0",
+      "data": null,
+      "contractMethod": {
+        "inputs": [
+          {
+            "internalType": "address",
+            "name": "_admin",
+            "type": "address"
+          }
+        ],
+        "name": "changeAdmin",
+        "payable": false
+      },
+      "contractInputsValues": {
+        "_admin": "0xB4453CEb33d2e67FA244A24acf2E50CEF31F53cB"
+      }
+    },
+    {
+      "to": "0xB4453CEb33d2e67FA244A24acf2E50CEF31F53cB",
+      "value": "0",
+      "data": null,
+      "contractMethod": {
+        "inputs": [],
+        "name": "phase1",
+        "payable": false
+      },
+      "contractInputsValues": {}
+    }
+  ]
+}

packages/contracts-bedrock/scripts/multisig/json/mainnet-migration/b2.json

+{
+  "version": "1.0",
+  "chainId": "1",
+  "meta": {
+    "name": "batch2",
+    "description": "SystemDictatorProxy.updateDynamicConfig.",
+    "txBuilderVersion": "1.13.3"
+  },
+  "transactions": [
+    {
+      "to": "0xB4453CEb33d2e67FA244A24acf2E50CEF31F53cB",
+      "value": "0",
+      "data": null,
+      "contractMethod": {
+        "inputs": [
+          {
+            "components": [
+              {
+                "internalType": "uint256",
+                "name": "l2OutputOracleStartingBlockNumber",
+                "type": "uint256"
+              },
+              {
+                "internalType": "uint256",
+                "name": "l2OutputOracleStartingTimestamp",
+                "type": "uint256"
+              }
+            ],
+            "internalType": "struct SystemDictator.L2OutputOracleDynamicConfig",
+            "name": "_l2OutputOracleDynamicConfig",
+            "type": "tuple"
+          },
+          {
+            "internalType": "bool",
+            "name": "_optimismPortalDynamicConfig",
+            "type": "bool"
+          }
+        ],
+        "name": "updateDynamicConfig",
+        "payable": false
+      },
+      "contractInputsValues": {
+        "_l2OutputOracleDynamicConfig": "[TBD, TBD]",
+        "_optimismPortalDynamicConfig": "true"
+      }
+    }
+  ]
+}

packages/contracts-bedrock/scripts/multisig/json/mainnet-migration/b3.json

+{
+  "version": "1.0",
+  "chainId": "1",
+  "meta": {
+    "name": "batch3",
+    "description": "SystemDictatorProxy.phase2 and OptimismPortalProxy.unpause.",
+    "txBuilderVersion": "1.13.3"
+  },
+  "transactions": [
+    {
+      "to": "0xB4453CEb33d2e67FA244A24acf2E50CEF31F53cB",
+      "value": "0",
+      "data": null,
+      "contractMethod": {
+        "inputs": [],
+        "name": "phase2",
+        "payable": false
+      },
+      "contractInputsValues": {}
+    },
+    {
+      "to": "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed",
+      "value": "0",
+      "data": null,
+      "contractMethod": {
+        "inputs": [],
+        "name": "unpause",
+        "payable": false
+      },
+      "contractInputsValues": {}
+    }
+  ]
+}

packages/contracts-bedrock/scripts/multisig/json/mainnet-migration/escapeHatch.json

+{
+  "version": "1.0",
+  "chainId": "1",
+  "meta": {
+    "name": "EscapeHatch",
+    "description": "SystemDictatorProxy.exit1 and finalize.",
+    "txBuilderVersion": "1.14.1"
+  },
+  "transactions": [
+    {
+    "to": "0xB4453CEb33d2e67FA244A24acf2E50CEF31F53cB",
+    "value": "0",
+    "data": null,
+    "contractMethod": {
+      "inputs": [],
+      "name": "exit1",
+      "payable": false
+    },
+    "contractInputsValues": null
+  },
+    {
+    "to": "0xB4453CEb33d2e67FA244A24acf2E50CEF31F53cB",
+    "value": "0",
+    "data": null,
+    "contractMethod": {
+      "inputs": [],
+      "name": "finalize",
+      "payable": false
+    },
+    "contractInputsValues": null
+  }
+  ]
+}

specs/glossary.md

@@ -160,7 +160,7 @@ Different transaction types can contain different payloads, and be handled diffe
 
 [fork-choice-rule]: glossary.md#fork-choice-rule
 
-The fork choice rule is the rule used to determined which block is to be considered as the head of a blockchain. On L1,
+The fork choice rule is the rule used to determine which block is to be considered as the head of a blockchain. On L1,
 this is determined by the proof of stake rules.
 
 L2 also has a fork choice rule, although the rules vary depending on whether we want the [safe L2 head][safe-l2-head],
@@ -591,8 +591,8 @@ In the current implementation, this is the L1 block number at which the output o
 
 [safe-l2-block]: glossary.md#safe-l2-block
 
-A safe L2 block is an L2 block can be derived entirely from L1 by a [rollup node][rollup-node]. This can vary between
-different nodes, based on their view of the L1 chain.
+A safe L2 block is an L2 block that can be derived entirely from L1 by a [rollup node][rollup-node]. This can vary
+between different nodes, based on their view of the L1 chain.
 
 ## Safe L2 Head