Merge branch 'develop' into feat/tx-bundle-builder

CONTRIBUTING.md

@@ -119,7 +119,7 @@ Note that these environment variables significantly speed up build time.
 cd ops-bedrock
 export COMPOSE_DOCKER_CLI_BUILD=1
 export DOCKER_BUILDKIT=1
-docker-compose build
+docker compose build
 ```
 
 Source code changes can have an impact on more than one container.
@@ -127,9 +127,9 @@ Source code changes can have an impact on more than one container.
 
 ```bash
 cd ops-bedrock
-docker-compose down
-docker-compose build
-docker-compose up
+docker compose down
+docker compose build
+docker compose up
 ```
 
 **If a node process exits with exit code: 137** you may need to increase the default memory limit of docker containers
@@ -141,18 +141,18 @@ cd optimism
 pnpm clean
 pnpm build
 cd ops
-docker-compose down -v
-docker-compose build
-docker-compose up
+docker compose down -v
+docker compose build
+docker compose up
 ```
 
 #### Viewing docker container logs
 
-By default, the `docker-compose up` command will show logs from all services, and that
+By default, the `docker compose up` command will show logs from all services, and that
 can be hard to filter through. In order to view the logs from a specific service, you can run:
 
 ```bash
-docker-compose logs --follow <service name>
+docker compose logs --follow <service name>
 ```
 
 ### Running tests

Makefile

@@ -101,13 +101,13 @@ devnet-test:
 .PHONY: devnet-test
 
 devnet-down:
-	@(cd ./ops-bedrock && GENESIS_TIMESTAMP=$(shell date +%s) docker-compose stop)
+	@(cd ./ops-bedrock && GENESIS_TIMESTAMP=$(shell date +%s) docker compose stop)
 .PHONY: devnet-down
 
 devnet-clean:
 	rm -rf ./packages/contracts-bedrock/deployments/devnetL1
 	rm -rf ./.devnet
-	cd ./ops-bedrock && docker-compose down
+	cd ./ops-bedrock && docker compose down
 	docker image ls 'ops-bedrock*' --format='{{.Repository}}' | xargs -r docker rmi
 	docker volume ls --filter name=ops-bedrock --format='{{.Name}}' | xargs -r docker volume rm
 .PHONY: devnet-clean
@@ -116,7 +116,7 @@ devnet-allocs:
 	PYTHONPATH=./bedrock-devnet python3 ./bedrock-devnet/main.py --monorepo-dir=. --allocs
 
 devnet-logs:
-	@(cd ./ops-bedrock && docker-compose logs -f)
+	@(cd ./ops-bedrock && docker compose logs -f)
 	.PHONY: devnet-logs
 
 test-unit:

bedrock-devnet/devnet/__init__.py

@@ -93,7 +93,7 @@ def main():
         return
 
     log.info('Building docker images')
-    run_command(['docker-compose', 'build', '--progress', 'plain'], cwd=paths.ops_bedrock_dir, env={
+    run_command(['docker', 'compose', 'build', '--progress', 'plain'], cwd=paths.ops_bedrock_dir, env={
         'PWD': paths.ops_bedrock_dir
     })
 
@@ -173,7 +173,7 @@ def devnet_deploy(paths):
         ], cwd=paths.op_node_dir)
 
     log.info('Starting L1.')
-    run_command(['docker-compose', 'up', '-d', 'l1'], cwd=paths.ops_bedrock_dir, env={
+    run_command(['docker', 'compose', 'up', '-d', 'l1'], cwd=paths.ops_bedrock_dir, env={
         'PWD': paths.ops_bedrock_dir
     })
     wait_up(8545)
@@ -196,7 +196,7 @@ def devnet_deploy(paths):
     addresses = read_json(paths.addresses_json_path)
 
     log.info('Bringing up L2.')
-    run_command(['docker-compose', 'up', '-d', 'l2'], cwd=paths.ops_bedrock_dir, env={
+    run_command(['docker', 'compose', 'up', '-d', 'l2'], cwd=paths.ops_bedrock_dir, env={
         'PWD': paths.ops_bedrock_dir
     })
     wait_up(9545)
@@ -208,7 +208,7 @@ def devnet_deploy(paths):
     log.info(f'Using batch inbox {batch_inbox_address}')
 
     log.info('Bringing up everything else.')
-    run_command(['docker-compose', 'up', '-d', 'op-node', 'op-proposer', 'op-batcher'], cwd=paths.ops_bedrock_dir, env={
+    run_command(['docker', 'compose', 'up', '-d', 'op-node', 'op-proposer', 'op-batcher'], cwd=paths.ops_bedrock_dir, env={
         'PWD': paths.ops_bedrock_dir,
         'L2OO_ADDRESS': l2_output_oracle,
         'SEQUENCER_BATCH_INBOX_ADDRESS': batch_inbox_address

endpoint-monitor/Dockerfile

-FROM golang:1.19.9-alpine3.16 as builder
+FROM golang:1.20.7-alpine3.18 as builder
 
 RUN apk --no-cache add make jq bash git alpine-sdk
 
@@ -16,7 +16,7 @@ RUN go mod download
 
 RUN make build
 
-FROM alpine:3.16
+FROM alpine:3.18
 RUN apk --no-cache add ca-certificates
 
 RUN addgroup -S app && adduser -S app -G app

go.mod

 module github.com/ethereum-optimism/optimism
 
-go 1.19
+go 1.20
 
 require (
 	github.com/BurntSushi/toml v1.3.2

indexer/.gitignore

 docker-compose.dev.yml
 .env
-indexer
-
+/indexer

indexer/Dockerfile

-FROM --platform=$BUILDPLATFORM golang:1.19.9-alpine3.16 as builder
+FROM --platform=$BUILDPLATFORM golang:1.20.7-alpine3.18 as builder
 
 RUN apk add --no-cache make gcc musl-dev linux-headers git jq bash
 
@@ -18,7 +18,7 @@ RUN go mod download
 
 RUN make indexer
 
-FROM alpine:3.16
+FROM alpine:3.18
 
 COPY --from=builder /app/indexer/indexer /usr/local/bin
 

indexer/README.md

@@ -16,7 +16,7 @@ All tests can be ran by running `make test` from the `/indexer` directory.  This
 - install docker
 - `cp example.env .env`
 - fill in .env
-- run `docker-compose up` to start the indexer vs optimism goerli network
+- run `docker compose up` to start the indexer vs optimism goerli network
 
 ### Run indexer with go
 

indexer/api/api.go

 package api
 
 import (
+	"context"
 	"fmt"
 	"net/http"
 
 	"github.com/ethereum-optimism/optimism/indexer/api/routes"
 	"github.com/ethereum-optimism/optimism/indexer/database"
+	"github.com/ethereum-optimism/optimism/op-service/httputil"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/go-chi/chi/v5"
 )
@@ -13,25 +15,29 @@ import (
 const ethereumAddressRegex = `^0x[a-fA-F0-9]{40}$`
 
 type Api struct {
+	log    log.Logger
 	Router *chi.Mux
 }
 
-func NewApi(bv database.BridgeTransfersView, logger log.Logger) *Api {
-	logger.Info("Initializing API...")
-
+func NewApi(logger log.Logger, bv database.BridgeTransfersView) *Api {
 	r := chi.NewRouter()
-
 	h := routes.NewRoutes(logger, bv, r)
 
-	api := &Api{Router: r}
-
 	r.Get("/healthz", h.HealthzHandler)
 	r.Get(fmt.Sprintf("/api/v0/deposits/{address:%s}", ethereumAddressRegex), h.L1DepositsHandler)
 	r.Get(fmt.Sprintf("/api/v0/withdrawals/{address:%s}", ethereumAddressRegex), h.L2WithdrawalsHandler)
-
-	return api
+	return &Api{log: logger, Router: r}
 }
 
-func (a *Api) Listen(port string) error {
-	return http.ListenAndServe(port, a.Router)
+func (a *Api) Listen(ctx context.Context, port int) error {
+	a.log.Info("starting api server", "port", port)
+	server := http.Server{Addr: fmt.Sprintf(":%d", port), Handler: a.Router}
+	err := httputil.ListenAndServeContext(ctx, &server)
+	if err != nil {
+		a.log.Error("api server shutdown", "err", err)
+	} else {
+		a.log.Info("api server shutdown")
+	}
+
+	return err
 }

indexer/api/api_test.go

@@ -77,7 +77,7 @@ func (mbv *MockBridgeTransfersView) L2BridgeWithdrawalsByAddress(address common.
 }
 func TestHealthz(t *testing.T) {
 	logger := testlog.Logger(t, log.LvlInfo)
-	api := NewApi(&MockBridgeTransfersView{}, logger)
+	api := NewApi(logger, &MockBridgeTransfersView{})
 	request, err := http.NewRequest("GET", "/healthz", nil)
 	assert.Nil(t, err)
 
@@ -89,7 +89,7 @@ func TestHealthz(t *testing.T) {
 
 func TestL1BridgeDepositsHandler(t *testing.T) {
 	logger := testlog.Logger(t, log.LvlInfo)
-	api := NewApi(&MockBridgeTransfersView{}, logger)
+	api := NewApi(logger, &MockBridgeTransfersView{})
 	request, err := http.NewRequest("GET", fmt.Sprintf("/api/v0/deposits/%s", mockAddress), nil)
 	assert.Nil(t, err)
 
@@ -101,7 +101,7 @@ func TestL1BridgeDepositsHandler(t *testing.T) {
 
 func TestL2BridgeWithdrawalsByAddressHandler(t *testing.T) {
 	logger := testlog.Logger(t, log.LvlInfo)
-	api := NewApi(&MockBridgeTransfersView{}, logger)
+	api := NewApi(logger, &MockBridgeTransfersView{})
 	request, err := http.NewRequest("GET", fmt.Sprintf("/api/v0/withdrawals/%s", mockAddress), nil)
 	assert.Nil(t, err)
 

indexer/cli/cli.go → indexer/cmd/indexer/cli.go

-package cli
+package main
 
 import (
 	"context"
-	"fmt"
-	"strconv"
 
 	"github.com/ethereum-optimism/optimism/indexer"
 	"github.com/ethereum-optimism/optimism/indexer/api"
@@ -16,26 +14,25 @@ import (
 	"github.com/urfave/cli/v2"
 )
 
-type Cli struct {
-	GitVersion string
-	GitCommit  string
-	GitDate    string
-	app        *cli.App
-	Flags      []cli.Flag
-}
+var (
+	ConfigFlag = &cli.StringFlag{
+		Name:    "config",
+		Value:   "./indexer.toml",
+		Aliases: []string{"c"},
+		Usage:   "path to config file",
+		EnvVars: []string{"INDEXER_CONFIG"},
+	}
+)
 
 func runIndexer(ctx *cli.Context) error {
 	logger := log.NewLogger(log.ReadCLIConfig(ctx))
-
-	configPath := ctx.String(ConfigFlag.Name)
-	cfg, err := config.LoadConfig(logger, configPath)
+	cfg, err := config.LoadConfig(logger, ctx.String(ConfigFlag.Name))
 	if err != nil {
 		logger.Error("failed to load config", "err", err)
 		return err
 	}
 
 	db, err := database.NewDB(cfg.DB)
-
 	if err != nil {
 		return err
 	}
@@ -48,6 +45,7 @@ func runIndexer(ctx *cli.Context) error {
 	indexerCtx, indexerCancel := context.WithCancel(context.Background())
 	go func() {
 		opio.BlockOnInterrupts()
+		logger.Error("caught interrupt, shutting down...")
 		indexerCancel()
 	}()
 
@@ -56,47 +54,35 @@ func runIndexer(ctx *cli.Context) error {
 
 func runApi(ctx *cli.Context) error {
 	logger := log.NewLogger(log.ReadCLIConfig(ctx))
-
-	configPath := ctx.String(ConfigFlag.Name)
-	cfg, err := config.LoadConfig(logger, configPath)
+	cfg, err := config.LoadConfig(logger, ctx.String(ConfigFlag.Name))
 	if err != nil {
 		logger.Error("failed to load config", "err", err)
 		return err
 	}
 
 	db, err := database.NewDB(cfg.DB)
-
 	if err != nil {
 		logger.Crit("Failed to connect to database", "err", err)
 	}
 
-	server := api.NewApi(db.BridgeTransfers, logger)
-
-	return server.Listen(strconv.Itoa(cfg.API.Port))
-}
-
-var (
-	ConfigFlag = &cli.StringFlag{
-		Name:    "config",
-		Value:   "./indexer.toml",
-		Aliases: []string{"c"},
-		Usage:   "path to config file",
-		EnvVars: []string{"INDEXER_CONFIG"},
-	}
-)
+	apiCtx, apiCancel := context.WithCancel(context.Background())
+	api := api.NewApi(logger, db.BridgeTransfers)
+	go func() {
+		opio.BlockOnInterrupts()
+		logger.Error("caught interrupt, shutting down...")
+		apiCancel()
+	}()
 
-// make a instance method on Cli called Run that runs cli
-// and returns an error
-func (c *Cli) Run(args []string) error {
-	return c.app.Run(args)
+	return api.Listen(apiCtx, cfg.API.Port)
 }
 
-func NewCli(GitVersion string, GitCommit string, GitDate string) *Cli {
+func newCli(GitCommit string, GitDate string) *cli.App {
 	flags := []cli.Flag{ConfigFlag}
 	flags = append(flags, log.CLIFlags("INDEXER")...)
-	app := &cli.App{
-		Version:     fmt.Sprintf("%s-%s", GitVersion, params.VersionWithCommit(GitCommit, GitDate)),
-		Description: "An indexer of all optimism events with a serving api layer",
+	return &cli.App{
+		Version:              params.VersionWithCommit(GitCommit, GitDate),
+		Description:          "An indexer of all optimism events with a serving api layer",
+		EnableBashCompletion: true,
 		Commands: []*cli.Command{
 			{
 				Name:        "api",
@@ -110,11 +96,14 @@ func NewCli(GitVersion string, GitCommit string, GitDate string) *Cli {
 				Description: "Runs the indexing service",
 				Action:      runIndexer,
 			},
+			{
+				Name:        "version",
+				Description: "print version",
+				Action: func(ctx *cli.Context) error {
+					cli.ShowVersion(ctx)
+					return nil
+				},
+			},
 		},
 	}
-
-	return &Cli{
-		app:   app,
-		Flags: flags,
-	}
 }

indexer/cmd/indexer/main.go

@@ -3,20 +3,17 @@ package main
 import (
 	"os"
 
-	"github.com/ethereum-optimism/optimism/indexer/cli"
 	"github.com/ethereum/go-ethereum/log"
 )
 
 var (
-	GitVersion = ""
-	GitCommit  = ""
-	GitDate    = ""
+	GitCommit = ""
+	GitDate   = ""
 )
 
 func main() {
-	app := cli.NewCli(GitVersion, GitCommit, GitDate)
-
+	app := newCli(GitCommit, GitDate)
 	if err := app.Run(os.Args); err != nil {
-		log.Crit("Application failed", "message", err)
+		log.Crit("application failed", "err", err)
 	}
 }

indexer/config/config.go

@@ -99,20 +99,18 @@ type MetricsConfig struct {
 
 // LoadConfig loads the `indexer.toml` config file from a given path
 func LoadConfig(logger geth_log.Logger, path string) (Config, error) {
-	logger.Info("Loading config file", "path", path)
-	var conf Config
+	logger.Debug("loading config", "path", path)
 
+	var conf Config
 	data, err := os.ReadFile(path)
 	if err != nil {
 		return conf, err
 	}
 
 	data = []byte(os.ExpandEnv(string(data)))
-
-	logger.Debug("Decoding config file", "data", string(data))
-
+	logger.Debug("parsed config file", "data", string(data))
 	if _, err := toml.Decode(string(data), &conf); err != nil {
-		logger.Info("Failed to decode config file", "message", err)
+		logger.Info("failed to decode config file", "err", err)
 		return conf, err
 	}
 
@@ -125,7 +123,6 @@ func LoadConfig(logger geth_log.Logger, path string) (Config, error) {
 		}
 	}
 
-	logger.Debug("Loaded config file", conf)
-
+	logger.Info("loaded config")
 	return conf, nil
 }

indexer/migrations/20230523_create_schema.sql

@@ -8,10 +8,10 @@ CREATE DOMAIN UINT256 AS NUMERIC
 
 CREATE TABLE IF NOT EXISTS l1_block_headers (
     -- Searchable fields
-	hash        VARCHAR NOT NULL PRIMARY KEY,
-	parent_hash VARCHAR NOT NULL,
-	number      UINT256 NOT NULL,
-	timestamp   INTEGER NOT NULL CHECK (timestamp > 0),
+    hash        VARCHAR PRIMARY KEY,
+    parent_hash VARCHAR NOT NULL UNIQUE,
+    number      UINT256 NOT NULL UNIQUE,
+    timestamp   INTEGER NOT NULL UNIQUE CHECK (timestamp > 0),
 
     -- Raw Data
     rlp_bytes VARCHAR NOT NULL
@@ -19,10 +19,10 @@ CREATE TABLE IF NOT EXISTS l1_block_headers (
 
 CREATE TABLE IF NOT EXISTS l2_block_headers (
     -- Searchable fields
-	hash                     VARCHAR NOT NULL PRIMARY KEY,
-	parent_hash              VARCHAR NOT NULL,
-	number                   UINT256 NOT NULL,
-	timestamp                INTEGER NOT NULL CHECK (timestamp > 0),
+    hash        VARCHAR PRIMARY KEY,
+    parent_hash VARCHAR NOT NULL UNIQUE,
+    number      UINT256 NOT NULL UNIQUE,
+    timestamp   INTEGER NOT NULL UNIQUE CHECK (timestamp > 0),
 
     -- Raw Data
     rlp_bytes VARCHAR NOT NULL
@@ -34,8 +34,8 @@ CREATE TABLE IF NOT EXISTS l2_block_headers (
 
 CREATE TABLE IF NOT EXISTS l1_contract_events (
     -- Searchable fields
-    guid             VARCHAR NOT NULL PRIMARY KEY,
-	block_hash       VARCHAR NOT NULL REFERENCES l1_block_headers(hash),
+    guid             VARCHAR PRIMARY KEY,
+    block_hash       VARCHAR NOT NULL REFERENCES l1_block_headers(hash) ON DELETE CASCADE,
     contract_address VARCHAR NOT NULL,
     transaction_hash VARCHAR NOT NULL,
     log_index        INTEGER NOT NULL,
@@ -48,8 +48,8 @@ CREATE TABLE IF NOT EXISTS l1_contract_events (
 
 CREATE TABLE IF NOT EXISTS l2_contract_events (
     -- Searchable fields
-    guid             VARCHAR NOT NULL PRIMARY KEY,
-	block_hash       VARCHAR NOT NULL REFERENCES l2_block_headers(hash),
+    guid             VARCHAR PRIMARY KEY,
+    block_hash       VARCHAR NOT NULL REFERENCES l2_block_headers(hash) ON DELETE CASCADE,
     contract_address VARCHAR NOT NULL,
     transaction_hash VARCHAR NOT NULL,
     log_index        INTEGER NOT NULL,
@@ -63,58 +63,52 @@ CREATE TABLE IF NOT EXISTS l2_contract_events (
 -- Tables that index finalization markers for L2 blocks.
 
 CREATE TABLE IF NOT EXISTS legacy_state_batches (
-	index         INTEGER NOT NULL PRIMARY KEY,
-	root          VARCHAR NOT NULL,
-	size          INTEGER NOT NULL,
-	prev_total    INTEGER NOT NULL,
+    index      INTEGER PRIMARY KEY,
+    root       VARCHAR NOT NULL UNIQUE,
+    size       INTEGER NOT NULL,
+    prev_total INTEGER NOT NULL,
 
-    l1_contract_event_guid VARCHAR REFERENCES l1_contract_events(guid)
+    state_batch_appended_guid VARCHAR NOT NULL UNIQUE REFERENCES l1_contract_events(guid) ON DELETE CASCADE
 );
 
 CREATE TABLE IF NOT EXISTS output_proposals (
-    output_root     VARCHAR NOT NULL PRIMARY KEY,
+    output_root     VARCHAR PRIMARY KEY,
+    l2_output_index UINT256 NOT NULL UNIQUE,
+    l2_block_number UINT256 NOT NULL UNIQUE,
 
-    l2_output_index UINT256 NOT NULL,
-    l2_block_number UINT256 NOT NULL,
-
-    l1_contract_event_guid VARCHAR REFERENCES l1_contract_events(guid)
+    output_proposed_guid VARCHAR NOT NULL UNIQUE REFERENCES l1_contract_events(guid) ON DELETE CASCADE
 );
 
 /**
  * BRIDGING DATA
  */
 
- /**
- * TOKEN DATA
- */
-
--- L1 Token table
+-- Bridged L1/L2 Tokens
 CREATE TABLE IF NOT EXISTS l1_tokens (
-    address   VARCHAR PRIMARY KEY,
-    bridge_address  VARCHAR NOT NULL,
-    l2_token_address VARCHAR NOT NULL,
-    name            VARCHAR NOT NULL,
-    symbol          VARCHAR NOT NULL,
-    decimals        INTEGER NOT NULL CHECK (decimals >= 0 AND decimals <= 18)
-);
+    address        VARCHAR PRIMARY KEY,
+    bridge_address VARCHAR NOT NULL,
 
--- L2 Token table
-CREATE TABLE IF NOT EXISTS l2_tokens (
-    address   VARCHAR PRIMARY KEY,
-    bridge_address  VARCHAR NOT NULL,
-    l1_token_address VARCHAR REFERENCES l1_tokens(address),
-    name            VARCHAR NOT NULL,
-    symbol          VARCHAR NOT NULL,
-    decimals        INTEGER NOT NULL CHECK (decimals >= 0 AND decimals <= 18)
+    name     VARCHAR NOT NULL,
+    symbol   VARCHAR NOT NULL,
+    decimals INTEGER NOT NULL CHECK (decimals >= 0 AND decimals <= 18)
 );
+CREATE TABLE IF NOT EXISTS l2_tokens (
+    address        VARCHAR PRIMARY KEY,
+    bridge_address VARCHAR NOT NULL,
+
+    -- L1-L2 relationship is 1 to many so this is not necessarily unique
+    l1_token_address VARCHAR REFERENCES l1_tokens(address) ON DELETE CASCADE,
 
+    name     VARCHAR NOT NULL,
+    symbol   VARCHAR NOT NULL,
+    decimals INTEGER NOT NULL CHECK (decimals >= 0 AND decimals <= 18)
+);
 
 -- OptimismPortal/L2ToL1MessagePasser
 CREATE TABLE IF NOT EXISTS l1_transaction_deposits (
-    source_hash         VARCHAR NOT NULL PRIMARY KEY,
-    l2_transaction_hash VARCHAR NOT NULL,
-
-    initiated_l1_event_guid VARCHAR NOT NULL REFERENCES l1_contract_events(guid),
+    source_hash             VARCHAR PRIMARY KEY,
+    l2_transaction_hash     VARCHAR NOT NULL UNIQUE,
+    initiated_l1_event_guid VARCHAR NOT NULL UNIQUE REFERENCES l1_contract_events(guid) ON DELETE CASCADE,
 
     -- transaction data
     from_address VARCHAR NOT NULL,
@@ -125,18 +119,15 @@ CREATE TABLE IF NOT EXISTS l1_transaction_deposits (
     timestamp    INTEGER NOT NULL CHECK (timestamp > 0)
 );
 CREATE TABLE IF NOT EXISTS l2_transaction_withdrawals (
-    withdrawal_hash VARCHAR NOT NULL PRIMARY KEY,
-
-    initiated_l2_event_guid VARCHAR NOT NULL REFERENCES l2_contract_events(guid),
+    withdrawal_hash         VARCHAR PRIMARY KEY,
+    nonce                   UINT256 NOT NULL UNIQUE,
+    initiated_l2_event_guid VARCHAR NOT NULL UNIQUE REFERENCES l2_contract_events(guid) ON DELETE CASCADE,
 
     -- Multistep (bedrock) process of a withdrawal
-    proven_l1_event_guid    VARCHAR REFERENCES l1_contract_events(guid),
-    finalized_l1_event_guid VARCHAR REFERENCES l1_contract_events(guid),
+    proven_l1_event_guid    VARCHAR UNIQUE REFERENCES l1_contract_events(guid) ON DELETE CASCADE,
+    finalized_l1_event_guid VARCHAR UNIQUE REFERENCES l1_contract_events(guid) ON DELETE CASCADE,
     succeeded               BOOLEAN,
 
-    -- L2ToL1MessagePasser specific
-    nonce UINT256 UNIQUE,
-
     -- transaction data
     from_address VARCHAR NOT NULL,
     to_address   VARCHAR NOT NULL,
@@ -148,13 +139,12 @@ CREATE TABLE IF NOT EXISTS l2_transaction_withdrawals (
 
 -- CrossDomainMessenger
 CREATE TABLE IF NOT EXISTS l1_bridge_messages(
-    message_hash            VARCHAR NOT NULL PRIMARY KEY,
+    message_hash            VARCHAR PRIMARY KEY,
     nonce                   UINT256 NOT NULL UNIQUE,
+    transaction_source_hash VARCHAR NOT NULL UNIQUE REFERENCES l1_transaction_deposits(source_hash) ON DELETE CASCADE,
 
-    transaction_source_hash VARCHAR NOT NULL UNIQUE REFERENCES l1_transaction_deposits(source_hash),
-
-    sent_message_event_guid    VARCHAR NOT NULL UNIQUE REFERENCES l1_contract_events(guid),
-    relayed_message_event_guid VARCHAR UNIQUE REFERENCES l2_contract_events(guid),
+    sent_message_event_guid    VARCHAR NOT NULL UNIQUE REFERENCES l1_contract_events(guid) ON DELETE CASCADE,
+    relayed_message_event_guid VARCHAR UNIQUE REFERENCES l2_contract_events(guid) ON DELETE CASCADE,
 
     -- sent message
     from_address VARCHAR NOT NULL,
@@ -165,13 +155,12 @@ CREATE TABLE IF NOT EXISTS l1_bridge_messages(
     timestamp    INTEGER NOT NULL CHECK (timestamp > 0)
 );
 CREATE TABLE IF NOT EXISTS l2_bridge_messages(
-    message_hash                VARCHAR NOT NULL PRIMARY KEY,
+    message_hash                VARCHAR PRIMARY KEY,
     nonce                       UINT256 NOT NULL UNIQUE,
+    transaction_withdrawal_hash VARCHAR NOT NULL UNIQUE REFERENCES l2_transaction_withdrawals(withdrawal_hash) ON DELETE CASCADE,
 
-    transaction_withdrawal_hash VARCHAR NOT NULL UNIQUE REFERENCES l2_transaction_withdrawals(withdrawal_hash),
-
-    sent_message_event_guid    VARCHAR NOT NULL UNIQUE REFERENCES l2_contract_events(guid),
-    relayed_message_event_guid VARCHAR UNIQUE REFERENCES l1_contract_events(guid),
+    sent_message_event_guid    VARCHAR NOT NULL UNIQUE REFERENCES l2_contract_events(guid) ON DELETE CASCADE,
+    relayed_message_event_guid VARCHAR UNIQUE REFERENCES l1_contract_events(guid) ON DELETE CASCADE,
 
     -- sent message
     from_address VARCHAR NOT NULL,
@@ -184,28 +173,28 @@ CREATE TABLE IF NOT EXISTS l2_bridge_messages(
 
 -- StandardBridge
 CREATE TABLE IF NOT EXISTS l1_bridge_deposits (
-    transaction_source_hash   VARCHAR PRIMARY KEY REFERENCES l1_transaction_deposits(source_hash),
-    cross_domain_message_hash VARCHAR NOT NULL UNIQUE REFERENCES l1_bridge_messages(message_hash),
+    transaction_source_hash   VARCHAR PRIMARY KEY REFERENCES l1_transaction_deposits(source_hash) ON DELETE CASCADE,
+    cross_domain_message_hash VARCHAR NOT NULL UNIQUE REFERENCES l1_bridge_messages(message_hash) ON DELETE CASCADE,
 
     -- Deposit information
-	from_address         VARCHAR NOT NULL,
-	to_address           VARCHAR NOT NULL,
-	local_token_address  VARCHAR NOT NULL, -- REFERENCES l1_tokens(address), uncomment me in future pr
-	remote_token_address VARCHAR NOT NULL, -- REFERENCES l2_tokens(address), uncomment me in future pr
-	amount               UINT256 NOT NULL,
-	data                 VARCHAR NOT NULL,
+    from_address         VARCHAR NOT NULL,
+    to_address           VARCHAR NOT NULL,
+    local_token_address  VARCHAR NOT NULL, -- REFERENCES l1_tokens(address), uncomment me in future pr
+    remote_token_address VARCHAR NOT NULL, -- REFERENCES l2_tokens(address), uncomment me in future pr
+    amount               UINT256 NOT NULL,
+    data                 VARCHAR NOT NULL,
     timestamp            INTEGER NOT NULL CHECK (timestamp > 0)
 );
 CREATE TABLE IF NOT EXISTS l2_bridge_withdrawals (
-    transaction_withdrawal_hash VARCHAR PRIMARY KEY REFERENCES l2_transaction_withdrawals(withdrawal_hash),
-    cross_domain_message_hash   VARCHAR NOT NULL UNIQUE REFERENCES l2_bridge_messages(message_hash),
+    transaction_withdrawal_hash VARCHAR PRIMARY KEY REFERENCES l2_transaction_withdrawals(withdrawal_hash) ON DELETE CASCADE,
+    cross_domain_message_hash   VARCHAR NOT NULL UNIQUE REFERENCES l2_bridge_messages(message_hash) ON DELETE CASCADE,
 
     -- Withdrawal information
-	from_address         VARCHAR NOT NULL,
-	to_address           VARCHAR NOT NULL,
-	local_token_address  VARCHAR NOT NULL, -- REFERENCES l2_tokens(address), uncomment me in future pr
-	remote_token_address VARCHAR NOT NULL, -- REFERENCES l1_tokens(address), uncomment me in future pr
-	amount               UINT256 NOT NULL,
-	data                 VARCHAR NOT NULL,
+    from_address         VARCHAR NOT NULL,
+    to_address           VARCHAR NOT NULL,
+    local_token_address  VARCHAR NOT NULL, -- REFERENCES l2_tokens(address), uncomment me in future pr
+    remote_token_address VARCHAR NOT NULL, -- REFERENCES l1_tokens(address), uncomment me in future pr
+    amount               UINT256 NOT NULL,
+    data                 VARCHAR NOT NULL,
     timestamp            INTEGER NOT NULL CHECK (timestamp > 0)
 );

indexer/ui/README.md

@@ -7,7 +7,7 @@ A simple UI for exploring the indexer DB using [Prisma studio](https://www.prism
 Included in the docker-compose file as `ui` service
 
 ```bash
-docker-compose up
+docker compose up
 ```
 
 Prisma can be viewed at [localhost:5555](http://localhost:5555)

op-batcher/Dockerfile

-FROM --platform=$BUILDPLATFORM golang:1.19.9-alpine3.16 as builder
+FROM --platform=$BUILDPLATFORM golang:1.20.7-alpine3.18 as builder
 
 ARG VERSION=v0.0.0
 
@@ -23,7 +23,7 @@ ARG TARGETOS TARGETARCH
 
 RUN make op-batcher VERSION="$VERSION" GOOS=$TARGETOS GOARCH=$TARGETARCH
 
-FROM alpine:3.16
+FROM alpine:3.18
 
 COPY --from=builder /app/op-batcher/bin/op-batcher /usr/local/bin
 

op-batcher/compressor/shadow_compressor_test.go

@@ -3,8 +3,8 @@ package compressor_test
 import (
 	"bytes"
 	"compress/zlib"
+	"crypto/rand"
 	"io"
-	"math/rand"
 	"testing"
 
 	"github.com/ethereum-optimism/optimism/op-batcher/compressor"

op-chain-ops/state/memory_db_test.go

 package state_test
 
 import (
+	crand "crypto/rand"
 	"math/big"
 	"math/rand"
 	"testing"
@@ -47,7 +48,8 @@ func TestCode(t *testing.T) {
 		require.Nil(t, pre)
 
 		code := make([]byte, rand.Intn(1024))
-		rand.Read(code)
+		_, err := crand.Read(code)
+		require.NoError(t, err)
 
 		db.SetCode(addr, code)
 

op-challenger/Dockerfile

-FROM --platform=$BUILDPLATFORM golang:1.19.0-alpine3.15 as builder
+FROM --platform=$BUILDPLATFORM golang:1.20.7-alpine3.18 as builder
 
 ARG VERSION=v0.0.0
 
@@ -27,7 +27,7 @@ ARG TARGETOS TARGETARCH
 
 RUN make op-challenger VERSION="$VERSION" GOOS=$TARGETOS GOARCH=$TARGETARCH
 
-FROM alpine:3.15
+FROM alpine:3.18
 
 COPY --from=builder /app/op-challenger/bin/op-challenger /usr/local/bin
 

op-challenger/fault/cannon/provider.go

@@ -50,7 +50,7 @@ type CannonTraceProvider struct {
 	lastProof *proofData
 }
 
-func NewTraceProvider(ctx context.Context, logger log.Logger, cfg *config.Config, l1Client bind.ContractCaller, gameAddr common.Address) (*CannonTraceProvider, error) {
+func NewTraceProvider(ctx context.Context, logger log.Logger, cfg *config.Config, l1Client bind.ContractCaller, dir string, gameAddr common.Address) (*CannonTraceProvider, error) {
 	l2Client, err := ethclient.DialContext(ctx, cfg.CannonL2)
 	if err != nil {
 		return nil, fmt.Errorf("dial l2 client %v: %w", cfg.CannonL2, err)
@@ -64,11 +64,10 @@ func NewTraceProvider(ctx context.Context, logger log.Logger, cfg *config.Config
 	if err != nil {
 		return nil, fmt.Errorf("fetch local game inputs: %w", err)
 	}
-	return NewTraceProviderFromInputs(logger, cfg, gameAddr.Hex(), localInputs), nil
+	return NewTraceProviderFromInputs(logger, cfg, localInputs, dir), nil
 }
 
-func NewTraceProviderFromInputs(logger log.Logger, cfg *config.Config, gameDirName string, localInputs LocalGameInputs) *CannonTraceProvider {
-	dir := filepath.Join(cfg.Datadir, gameDirName)
+func NewTraceProviderFromInputs(logger log.Logger, cfg *config.Config, localInputs LocalGameInputs, dir string) *CannonTraceProvider {
 	return &CannonTraceProvider{
 		logger:    logger,
 		dir:       dir,
@@ -118,10 +117,6 @@ func (p *CannonTraceProvider) AbsolutePreState(ctx context.Context) ([]byte, err
 	return state.EncodeWitness(), nil
 }
 
-func (p *CannonTraceProvider) Cleanup() error {
-	return os.RemoveAll(p.dir)
-}
-
 // loadProof will attempt to load or generate the proof data at the specified index
 // If the requested index is beyond the end of the actual trace it is extended with no-op instructions.
 func (p *CannonTraceProvider) loadProof(ctx context.Context, i uint64) (*proofData, error) {

op-challenger/fault/cannon/provider_test.go

@@ -11,7 +11,6 @@ import (
 	"testing"
 
 	"github.com/ethereum-optimism/optimism/cannon/mipsevm"
-	"github.com/ethereum-optimism/optimism/op-challenger/config"
 	"github.com/ethereum-optimism/optimism/op-challenger/fault/types"
 	"github.com/ethereum-optimism/optimism/op-node/testlog"
 	"github.com/ethereum/go-ethereum/common"
@@ -189,29 +188,6 @@ func TestAbsolutePreState(t *testing.T) {
 	})
 }
 
-func TestUseGameSpecificSubdir(t *testing.T) {
-	tempDir := t.TempDir()
-	dataDir := filepath.Join(tempDir, "data")
-	setupPreState(t, tempDir, "state.json")
-	logger := testlog.Logger(t, log.LvlInfo)
-	cfg := &config.Config{
-		CannonAbsolutePreState: filepath.Join(tempDir, "state.json"),
-		Datadir:                dataDir,
-	}
-	gameDirName := "gameSubdir"
-	localInputs := LocalGameInputs{}
-	provider := NewTraceProviderFromInputs(logger, cfg, gameDirName, localInputs)
-	require.Equal(t, filepath.Join(dataDir, gameDirName), provider.dir, "should use game specific subdir")
-}
-
-func TestCleanup(t *testing.T) {
-	dataDir, prestate := setupTestData(t)
-	provider, _ := setupWithTestData(t, dataDir, prestate)
-	require.NoError(t, provider.Cleanup())
-	_, err := os.Stat(dataDir)
-	require.ErrorIs(t, err, os.ErrNotExist)
-}
-
 func setupPreState(t *testing.T, dataDir string, filename string) {
 	srcDir := filepath.Join("test_data")
 	path := filepath.Join(srcDir, filename)

op-challenger/fault/disk.go

+package fault
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/ethereum/go-ethereum/common"
+	"golang.org/x/exp/slices"
+)
+
+const gameDirPrefix = "game-"
+
+// diskManager coordinates the storage of game data on disk.
+type diskManager struct {
+	datadir string
+}
+
+func newDiskManager(dir string) *diskManager {
+	return &diskManager{datadir: dir}
+}
+
+func (d *diskManager) DirForGame(addr common.Address) string {
+	return filepath.Join(d.datadir, gameDirPrefix+addr.Hex())
+}
+
+func (d *diskManager) RemoveAllExcept(keep []common.Address) error {
+	entries, err := os.ReadDir(d.datadir)
+	if err != nil {
+		return fmt.Errorf("failed to list directory: %w", err)
+	}
+	var errs []error
+	for _, entry := range entries {
+		if !entry.IsDir() || !strings.HasPrefix(entry.Name(), gameDirPrefix) {
+			// Skip files and directories that don't have the game directory prefix.
+			// While random content shouldn't be in our datadir, we want to avoid
+			// deleting things like OS generated files.
+			continue
+		}
+		name := entry.Name()[len(gameDirPrefix):]
+		addr := common.HexToAddress(name)
+		if addr == (common.Address{}) {
+			// Ignore directories with non-address names.
+			continue
+		}
+		if slices.Contains(keep, addr) {
+			// Preserve data for games we should keep.
+			continue
+		}
+		errs = append(errs, os.RemoveAll(filepath.Join(d.datadir, entry.Name())))
+	}
+	return errors.Join(errs...)
+}

op-challenger/fault/disk_test.go

+package fault
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/stretchr/testify/require"
+)
+
+func TestDiskManager_DirForGame(t *testing.T) {
+	baseDir := t.TempDir()
+	addr := common.Address{0x53}
+	disk := newDiskManager(baseDir)
+	result := disk.DirForGame(addr)
+	require.Equal(t, filepath.Join(baseDir, gameDirPrefix+addr.Hex()), result)
+}
+
+func TestDiskManager_RemoveAllExcept(t *testing.T) {
+	baseDir := t.TempDir()
+	keep := common.Address{0x53}
+	delete := common.Address{0xaa}
+	disk := newDiskManager(baseDir)
+	keepDir := disk.DirForGame(keep)
+	deleteDir := disk.DirForGame(delete)
+
+	unexpectedFile := filepath.Join(baseDir, "file.txt")
+	require.NoError(t, os.WriteFile(unexpectedFile, []byte("test"), 0644))
+	unexpectedDir := filepath.Join(baseDir, "notagame")
+	require.NoError(t, os.MkdirAll(unexpectedDir, 0777))
+	invalidHexDir := filepath.Join(baseDir, gameDirPrefix+"0xNOPE")
+	require.NoError(t, os.MkdirAll(invalidHexDir, 0777))
+
+	populateDir := func(dir string) []string {
+		require.NoError(t, os.MkdirAll(dir, 0777))
+		file1 := filepath.Join(dir, "test.txt")
+		require.NoError(t, os.WriteFile(file1, []byte("foo"), 0644))
+		nestedDirs := filepath.Join(dir, "subdir", "deep")
+		require.NoError(t, os.MkdirAll(nestedDirs, 0777))
+		file2 := filepath.Join(nestedDirs, ".foo.txt")
+		require.NoError(t, os.WriteFile(file2, []byte("foo"), 0644))
+		return []string{file1, file2}
+	}
+
+	keepFiles := populateDir(keepDir)
+	populateDir(deleteDir)
+
+	require.NoError(t, disk.RemoveAllExcept([]common.Address{keep}))
+	require.NoDirExists(t, deleteDir, "should have deleted directory")
+	for _, file := range keepFiles {
+		require.FileExists(t, file, "should have kept file for active game")
+	}
+	require.FileExists(t, unexpectedFile, "should not delete unexpected file")
+	require.DirExists(t, unexpectedDir, "should not delete unexpected dir")
+	require.DirExists(t, invalidHexDir, "should not delete dir with invalid address")
+}

op-challenger/fault/monitor.go

@@ -13,10 +13,9 @@ import (
 
 type gamePlayer interface {
 	ProgressGame(ctx context.Context) bool
-	Cleanup() error
 }
 
-type playerCreator func(address common.Address) (gamePlayer, error)
+type playerCreator func(address common.Address, dir string) (gamePlayer, error)
 type blockNumberFetcher func(ctx context.Context) (uint64, error)
 
 // gameSource loads information about the games available to play
@@ -24,9 +23,15 @@ type gameSource interface {
 	FetchAllGamesAtBlock(ctx context.Context, earliest uint64, blockNumber *big.Int) ([]FaultDisputeGame, error)
 }
 
+type gameDiskAllocator interface {
+	DirForGame(common.Address) string
+	RemoveAllExcept([]common.Address) error
+}
+
 type gameMonitor struct {
 	logger           log.Logger
 	clock            clock.Clock
+	diskManager      gameDiskAllocator
 	source           gameSource
 	gameWindow       time.Duration
 	createPlayer     playerCreator
@@ -35,10 +40,20 @@ type gameMonitor struct {
 	players          map[common.Address]gamePlayer
 }
 
-func newGameMonitor(logger log.Logger, gameWindow time.Duration, cl clock.Clock, fetchBlockNumber blockNumberFetcher, allowedGames []common.Address, source gameSource, createGame playerCreator) *gameMonitor {
+func newGameMonitor(
+	logger log.Logger,
+	gameWindow time.Duration,
+	cl clock.Clock,
+	disk gameDiskAllocator,
+	fetchBlockNumber blockNumberFetcher,
+	allowedGames []common.Address,
+	source gameSource,
+	createGame playerCreator,
+) *gameMonitor {
 	return &gameMonitor{
 		logger:           logger,
 		clock:            cl,
+		diskManager:      disk,
 		source:           source,
 		gameWindow:       gameWindow,
 		createPlayer:     createGame,
@@ -82,6 +97,7 @@ func (m *gameMonitor) progressGames(ctx context.Context) error {
 		return fmt.Errorf("failed to load games: %w", err)
 	}
 	requiredGames := make(map[common.Address]bool)
+	var keepGameData []common.Address
 	for _, game := range games {
 		if !m.allowedGame(game.Proxy) {
 			m.logger.Debug("Skipping game not on allow list", "game", game.Proxy)
@@ -94,15 +110,17 @@ func (m *gameMonitor) progressGames(ctx context.Context) error {
 			continue
 		}
 		done := player.ProgressGame(ctx)
-		if done {
-			// Remove resources on disk as soon as the game is complete to save disk space.
+		if !done {
+			// We only keep resources on disk for games that are incomplete.
+			// Games that are complete have their data removed as soon as possible to save disk space.
 			// We keep the player in memory to avoid recreating it on every update but will no longer
 			// need the resources on disk because there are no further actions required on the game.
-			if err := player.Cleanup(); err != nil {
-				m.logger.Error("Unable to cleanup player data", "err", err)
-			}
+			keepGameData = append(keepGameData, game.Proxy)
 		}
 	}
+	if err := m.diskManager.RemoveAllExcept(keepGameData); err != nil {
+		m.logger.Error("Unable to cleanup game data", "err", err)
+	}
 	// Remove the player for any game that's no longer being returned from the list of active games
 	for addr := range m.players {
 		if _, ok := requiredGames[addr]; ok {
@@ -118,7 +136,7 @@ func (m *gameMonitor) fetchOrCreateGamePlayer(gameData FaultDisputeGame) (gamePl
 	if player, ok := m.players[gameData.Proxy]; ok {
 		return player, nil
 	}
-	player, err := m.createPlayer(gameData.Proxy)
+	player, err := m.createPlayer(gameData.Proxy, m.diskManager.DirForGame(gameData.Proxy))
 	if err != nil {
 		return nil, fmt.Errorf("failed to create game player %v: %w", gameData.Proxy, err)
 	}

op-challenger/fault/monitor_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/stretchr/testify/require"
+	"golang.org/x/exp/slices"
 
 	"github.com/ethereum-optimism/optimism/op-node/testlog"
 )
@@ -18,20 +19,20 @@ func TestMonitorMinGameTimestamp(t *testing.T) {
 	t.Parallel()
 
 	t.Run("zero game window returns zero", func(t *testing.T) {
-		monitor, _, _ := setupMonitorTest(t, []common.Address{})
+		monitor, _, _, _ := setupMonitorTest(t, []common.Address{})
 		monitor.gameWindow = time.Duration(0)
 		require.Equal(t, monitor.minGameTimestamp(), uint64(0))
 	})
 
 	t.Run("non-zero game window with zero clock", func(t *testing.T) {
-		monitor, _, _ := setupMonitorTest(t, []common.Address{})
+		monitor, _, _, _ := setupMonitorTest(t, []common.Address{})
 		monitor.gameWindow = time.Minute
 		monitor.clock = clock.NewDeterministicClock(time.Unix(0, 0))
 		require.Equal(t, monitor.minGameTimestamp(), uint64(0))
 	})
 
 	t.Run("minimum computed correctly", func(t *testing.T) {
-		monitor, _, _ := setupMonitorTest(t, []common.Address{})
+		monitor, _, _, _ := setupMonitorTest(t, []common.Address{})
 		monitor.gameWindow = time.Minute
 		frozen := time.Unix(int64(time.Hour.Seconds()), 0)
 		monitor.clock = clock.NewDeterministicClock(frozen)
@@ -41,7 +42,7 @@ func TestMonitorMinGameTimestamp(t *testing.T) {
 }
 
 func TestMonitorExitsWhenContextDone(t *testing.T) {
-	monitor, _, _ := setupMonitorTest(t, []common.Address{common.Address{}})
+	monitor, _, _, _ := setupMonitorTest(t, []common.Address{{}})
 	ctx, cancel := context.WithCancel(context.Background())
 	cancel()
 	err := monitor.MonitorGames(ctx)
@@ -49,7 +50,7 @@ func TestMonitorExitsWhenContextDone(t *testing.T) {
 }
 
 func TestMonitorCreateAndProgressGameAgents(t *testing.T) {
-	monitor, source, games := setupMonitorTest(t, []common.Address{})
+	monitor, source, games, _ := setupMonitorTest(t, []common.Address{})
 
 	addr1 := common.Address{0xaa}
 	addr2 := common.Address{0xbb}
@@ -82,7 +83,7 @@ func TestMonitorCreateAndProgressGameAgents(t *testing.T) {
 func TestMonitorOnlyCreateSpecifiedGame(t *testing.T) {
 	addr1 := common.Address{0xaa}
 	addr2 := common.Address{0xbb}
-	monitor, source, games := setupMonitorTest(t, []common.Address{addr2})
+	monitor, source, games, _ := setupMonitorTest(t, []common.Address{addr2})
 
 	source.games = []FaultDisputeGame{
 		{
@@ -107,7 +108,7 @@ func TestMonitorOnlyCreateSpecifiedGame(t *testing.T) {
 func TestDeletePlayersWhenNoLongerInListOfGames(t *testing.T) {
 	addr1 := common.Address{0xaa}
 	addr2 := common.Address{0xbb}
-	monitor, source, games := setupMonitorTest(t, nil)
+	monitor, source, games, _ := setupMonitorTest(t, nil)
 
 	allGames := []FaultDisputeGame{
 		{
@@ -147,13 +148,19 @@ func TestDeletePlayersWhenNoLongerInListOfGames(t *testing.T) {
 }
 
 func TestCleanupResourcesOfCompletedGames(t *testing.T) {
-	monitor, source, games := setupMonitorTest(t, []common.Address{})
-	games.createCompleted = true
-
 	addr1 := common.Address{0xaa}
+	addr2 := common.Address{0xbb}
+
+	monitor, source, games, disk := setupMonitorTest(t, []common.Address{})
+	games.createCompleted = addr1
+
 	source.games = []FaultDisputeGame{
 		{
 			Proxy:     addr1,
+			Timestamp: 1999,
+		},
+		{
+			Proxy:     addr2,
 			Timestamp: 9999,
 		},
 	}
@@ -161,13 +168,19 @@ func TestCleanupResourcesOfCompletedGames(t *testing.T) {
 	err := monitor.progressGames(context.Background())
 	require.NoError(t, err)
 
-	require.Len(t, games.created, 1, "should create game agents")
+	require.Len(t, games.created, 2, "should create game agents")
 	require.Contains(t, games.created, addr1)
+	require.Contains(t, games.created, addr2)
 	require.Equal(t, 1, games.created[addr1].progressCount)
-	require.Equal(t, 1, games.created[addr1].cleanupCount, "should clean up once game is done")
+	require.Equal(t, 1, games.created[addr2].progressCount)
+	require.Contains(t, disk.gameDirExists, addr1, "should have allocated a game dir for game 1")
+	require.False(t, disk.gameDirExists[addr1], "should have then deleted the game 1 dir")
+
+	require.Contains(t, disk.gameDirExists, addr2, "should have allocated a game dir for game 2")
+	require.True(t, disk.gameDirExists[addr2], "should not have deleted the game 2 dir")
 }
 
-func setupMonitorTest(t *testing.T, allowedGames []common.Address) (*gameMonitor, *stubGameSource, *createdGames) {
+func setupMonitorTest(t *testing.T, allowedGames []common.Address) (*gameMonitor, *stubGameSource, *createdGames, *stubDiskManager) {
 	logger := testlog.Logger(t, log.LvlDebug)
 	source := &stubGameSource{}
 	games := &createdGames{
@@ -177,8 +190,11 @@ func setupMonitorTest(t *testing.T, allowedGames []common.Address) (*gameMonitor
 	fetchBlockNum := func(ctx context.Context) (uint64, error) {
 		return 1234, nil
 	}
-	monitor := newGameMonitor(logger, time.Duration(0), clock.SystemClock, fetchBlockNum, allowedGames, source, games.CreateGame)
-	return monitor, source, games
+	disk := &stubDiskManager{
+		gameDirExists: make(map[common.Address]bool),
+	}
+	monitor := newGameMonitor(logger, time.Duration(0), clock.SystemClock, disk, fetchBlockNum, allowedGames, source, games.CreateGame)
+	return monitor, source, games, disk
 }
 
 type stubGameSource struct {
@@ -192,8 +208,8 @@ func (s *stubGameSource) FetchAllGamesAtBlock(ctx context.Context, earliest uint
 type stubGame struct {
 	addr          common.Address
 	progressCount int
-	cleanupCount  int
 	done          bool
+	dir           string
 }
 
 func (g *stubGame) ProgressGame(ctx context.Context) bool {
@@ -201,22 +217,37 @@ func (g *stubGame) ProgressGame(ctx context.Context) bool {
 	return g.done
 }
 
-func (g *stubGame) Cleanup() error {
-	g.cleanupCount++
-	return nil
-}
-
 type createdGames struct {
 	t               *testing.T
-	createCompleted bool
+	createCompleted common.Address
 	created         map[common.Address]*stubGame
 }
 
-func (c *createdGames) CreateGame(addr common.Address) (gamePlayer, error) {
+func (c *createdGames) CreateGame(addr common.Address, dir string) (gamePlayer, error) {
 	if _, exists := c.created[addr]; exists {
 		c.t.Fatalf("game %v already exists", addr)
 	}
-	game := &stubGame{addr: addr, done: c.createCompleted}
+	game := &stubGame{
+		addr: addr,
+		done: addr == c.createCompleted,
+		dir:  dir,
+	}
 	c.created[addr] = game
 	return game, nil
 }
+
+type stubDiskManager struct {
+	gameDirExists map[common.Address]bool
+}
+
+func (s *stubDiskManager) DirForGame(addr common.Address) string {
+	s.gameDirExists[addr] = true
+	return addr.Hex()
+}
+
+func (s *stubDiskManager) RemoveAllExcept(addrs []common.Address) error {
+	for address := range s.gameDirExists {
+		s.gameDirExists[address] = slices.Contains(addrs, address)
+	}
+	return nil
+}

op-challenger/fault/player.go

@@ -29,7 +29,6 @@ type GamePlayer struct {
 	agreeWithProposedOutput bool
 	caller                  GameInfo
 	logger                  log.Logger
-	cleanup                 func() error
 
 	completed bool
 }
@@ -38,6 +37,7 @@ func NewGamePlayer(
 	ctx context.Context,
 	logger log.Logger,
 	cfg *config.Config,
+	dir string,
 	addr common.Address,
 	txMgr txmgr.TxManager,
 	client bind.ContractCaller,
@@ -57,14 +57,12 @@ func NewGamePlayer(
 
 	var provider types.TraceProvider
 	var updater types.OracleUpdater
-	var cleanup func() error
 	switch cfg.TraceType {
 	case config.TraceTypeCannon:
-		cannonProvider, err := cannon.NewTraceProvider(ctx, logger, cfg, client, addr)
+		cannonProvider, err := cannon.NewTraceProvider(ctx, logger, cfg, client, dir, addr)
 		if err != nil {
 			return nil, fmt.Errorf("create cannon trace provider: %w", err)
 		}
-		cleanup = cannonProvider.Cleanup
 		provider = cannonProvider
 		updater, err = cannon.NewOracleUpdater(ctx, logger, txMgr, addr, client)
 		if err != nil {
@@ -72,7 +70,6 @@ func NewGamePlayer(
 		}
 	case config.TraceTypeAlphabet:
 		provider = alphabet.NewTraceProvider(cfg.AlphabetTrace, gameDepth)
-		cleanup = func() error { return nil }
 		updater = alphabet.NewOracleUpdater(logger)
 	default:
 		return nil, fmt.Errorf("unsupported trace type: %v", cfg.TraceType)
@@ -97,7 +94,6 @@ func NewGamePlayer(
 		agreeWithProposedOutput: cfg.AgreeWithProposedOutput,
 		caller:                  caller,
 		logger:                  logger,
-		cleanup:                 cleanup,
 	}, nil
 }
 
@@ -143,7 +139,3 @@ func (g *GamePlayer) logGameStatus(ctx context.Context, status types.GameStatus)
 		g.logger.Error("Game lost", "status", status)
 	}
 }
-
-func (g *GamePlayer) Cleanup() error {
-	return g.cleanup()
-}

op-challenger/fault/player_test.go

@@ -27,24 +27,6 @@ func TestProgressGame_LogErrorFromAct(t *testing.T) {
 	require.Equal(t, uint64(1), msg.GetContextValue("claims"))
 }
 
-func TestCleanup(t *testing.T) {
-	t.Run("default cleanup", func(t *testing.T) {
-		game := &GamePlayer{
-			cleanup: func() error { return nil },
-		}
-		require.NoError(t, game.Cleanup())
-	})
-
-	t.Run("cleanup bubbles up error", func(t *testing.T) {
-		err := errors.New("wassie")
-		game := &GamePlayer{
-			cleanup: func() error { return err },
-		}
-		require.Error(t, err, game.Cleanup())
-	})
-
-}
-
 func TestProgressGame_LogGameStatus(t *testing.T) {
 	tests := []struct {
 		name            string

op-challenger/fault/service.go

@@ -73,9 +73,18 @@ func NewService(ctx context.Context, logger log.Logger, cfg *config.Config) (*se
 	}
 	loader := NewGameLoader(factory)
 
-	monitor := newGameMonitor(logger, cfg.GameWindow, cl, client.BlockNumber, cfg.GameAllowlist, loader, func(addr common.Address) (gamePlayer, error) {
-		return NewGamePlayer(ctx, logger, cfg, addr, txMgr, client)
-	})
+	disk := newDiskManager(cfg.Datadir)
+	monitor := newGameMonitor(
+		logger,
+		cfg.GameWindow,
+		cl,
+		disk,
+		client.BlockNumber,
+		cfg.GameAllowlist,
+		loader,
+		func(addr common.Address, dir string) (gamePlayer, error) {
+			return NewGamePlayer(ctx, logger, cfg, dir, addr, txMgr, client)
+		})
 
 	m.RecordInfo(version.SimpleWithMeta)
 	m.RecordUp()

op-e2e/e2eutils/challenger/helper.go

@@ -179,5 +179,5 @@ func (h *Helper) VerifyNoGameDataExists(games ...GameAddr) {
 }
 
 func (h *Helper) gameDataDir(addr common.Address) string {
-	return filepath.Join(h.dir, addr.Hex())
+	return filepath.Join(h.dir, "game-"+addr.Hex())
 }

op-e2e/e2eutils/disputegame/cannon_helper.go

@@ -2,6 +2,7 @@ package disputegame
 
 import (
 	"context"
+	"path/filepath"
 
 	"github.com/ethereum-optimism/optimism/op-challenger/fault/cannon"
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/challenger"
@@ -38,7 +39,8 @@ func (g *CannonGameHelper) CreateHonestActor(ctx context.Context, rollupCfg *rol
 	}
 	opts = append(opts, options...)
 	cfg := challenger.NewChallengerConfig(g.t, l1Endpoint, opts...)
-	provider, err := cannon.NewTraceProvider(ctx, testlog.Logger(g.t, log.LvlInfo).New("role", "CorrectTrace"), cfg, l1Client, g.addr)
+	logger := testlog.Logger(g.t, log.LvlInfo).New("role", "CorrectTrace")
+	provider, err := cannon.NewTraceProvider(ctx, logger, cfg, l1Client, filepath.Join(cfg.Datadir, "honest"), g.addr)
 	g.require.NoError(err, "create cannon trace provider")
 
 	return &HonestHelper{

op-e2e/e2eutils/disputegame/helper.go

@@ -175,7 +175,7 @@ func (h *FactoryHelper) StartCannonGameWithCorrectRoot(ctx context.Context, roll
 		L2Claim:       challengedOutput.OutputRoot,
 		L2BlockNumber: challengedOutput.L2BlockNumber,
 	}
-	provider := cannon.NewTraceProviderFromInputs(testlog.Logger(h.t, log.LvlInfo).New("role", "CorrectTrace"), cfg, "correct", inputs)
+	provider := cannon.NewTraceProviderFromInputs(testlog.Logger(h.t, log.LvlInfo).New("role", "CorrectTrace"), cfg, inputs, cfg.Datadir)
 	rootClaim, err := provider.Get(ctx, math.MaxUint64)
 	h.require.NoError(err, "Compute correct root hash")
 

op-exporter/Dockerfile

-FROM golang:1.19.9-alpine3.16 as builder
+FROM golang:1.20.7-alpine3.18 as builder
 
 # build from root of repo
 COPY ./op-exporter /app
@@ -7,7 +7,7 @@ WORKDIR /app/
 RUN apk --no-cache add make bash jq git
 RUN make build
 
-FROM alpine:3.16
+FROM alpine:3.18
 RUN apk --no-cache add ca-certificates
 WORKDIR /root/
 COPY --from=builder /app/op-exporter /usr/local/bin/

op-exporter/go.mod

 module github.com/ethereum-optimism/optimism/op-exporter
 
-go 1.18
+go 1.20
 
 require (
 	github.com/ethereum/go-ethereum v1.10.17

op-heartbeat/Dockerfile

-FROM golang:1.19.9-alpine3.16 as builder
+FROM golang:1.20.7-alpine3.18 as builder
 
 RUN apk add --no-cache make gcc musl-dev linux-headers git jq bash
 
@@ -15,7 +15,7 @@ WORKDIR /app/op-heartbeat
 
 RUN make op-heartbeat
 
-FROM alpine:3.16
+FROM alpine:3.18
 
 COPY --from=builder /app/op-heartbeat/bin/op-heartbeat /usr/local/bin
 

op-node/Dockerfile

-FROM --platform=$BUILDPLATFORM golang:1.19.9-alpine3.16 as builder
+FROM --platform=$BUILDPLATFORM golang:1.20.7-alpine3.18 as builder
 
 ARG VERSION=v0.0.0
 
@@ -21,7 +21,7 @@ ARG TARGETOS TARGETARCH
 
 RUN make op-node VERSION="$VERSION" GOOS=$TARGETOS GOARCH=$TARGETARCH
 
-FROM alpine:3.16
+FROM alpine:3.18
 
 COPY --from=builder /app/op-node/bin/op-node /usr/local/bin
 

op-node/rollup/derive/l1_block_info_test.go

 package derive
 
 import (
+	crand "crypto/rand"
 	"math/big"
 	"math/rand"
 	"testing"
@@ -97,7 +98,7 @@ func TestParseL1InfoDepositTxData(t *testing.T) {
 		info := testutils.MakeBlockInfo(nil)(rng)
 		depTx, err := L1InfoDeposit(randomSeqNr(rng), info, randomL1Cfg(rng, info), false)
 		require.NoError(t, err)
-		_, err = rand.Read(depTx.Data[0:4])
+		_, err = crand.Read(depTx.Data[0:4])
 		require.NoError(t, err)
 		_, err = L1InfoDepositTxData(depTx.Data)
 		require.ErrorContains(t, err, "function signature")

op-node/sources/eth_client_test.go

@@ -2,8 +2,8 @@ package sources
 
 import (
 	"context"
+	crand "crypto/rand"
 	"math/big"
-	"math/rand"
 	"testing"
 
 	"github.com/stretchr/testify/mock"
@@ -56,7 +56,7 @@ var testEthClientConfig = &EthClientConfig{
 }
 
 func randHash() (out common.Hash) {
-	rand.Read(out[:])
+	_, _ = crand.Read(out[:])
 	return out
 }
 

op-program/Dockerfile

-FROM --platform=$BUILDPLATFORM golang:1.19.9-alpine3.16 as builder
+FROM --platform=$BUILDPLATFORM golang:1.20.7-alpine3.18 as builder
 
 ARG VERSION=v0.0.0
 
@@ -23,7 +23,7 @@ ARG TARGETOS TARGETARCH
 
 RUN make op-program VERSION="$VERSION" GOOS=$TARGETOS GOARCH=$TARGETARCH
 
-FROM alpine:3.16
+FROM alpine:3.18
 
 COPY --from=builder /app/op-program/bin/op-program /usr/local/bin
 

op-proposer/Dockerfile

-FROM --platform=$BUILDPLATFORM golang:1.19.9-alpine3.16 as builder
+FROM --platform=$BUILDPLATFORM golang:1.20.7-alpine3.18 as builder
 
 ARG VERSION=v0.0.0
 
@@ -22,7 +22,7 @@ ARG TARGETOS TARGETARCH
 
 RUN make op-proposer VERSION="$VERSION" GOOS=$TARGETOS GOARCH=$TARGETARCH
 
-FROM alpine:3.16
+FROM alpine:3.18
 
 COPY --from=builder /app/op-proposer/bin/op-proposer /usr/local/bin
 

op-wheel/Dockerfile

-FROM golang:1.19.9-alpine3.16 as builder
+FROM golang:1.20.7-alpine3.18 as builder
 
 RUN apk add --no-cache make gcc musl-dev linux-headers
 
@@ -14,7 +14,7 @@ WORKDIR /app/op-wheel
 
 RUN go build -o op-wheel ./cmd/main.go
 
-FROM alpine:3.16
+FROM alpine:3.18
 
 COPY --from=builder /app/op-wheel/op-wheel /usr/local/bin
 

package.json

@@ -64,7 +64,7 @@
     "husky": "^8.0.3",
     "lerna": "^7.1.5",
     "lint-staged": "14.0.1",
-    "markdownlint": "^0.24.0",
+    "markdownlint": "^0.30.0",
     "markdownlint-cli2": "0.4.0",
     "mkdirp": "^1.0.4",
     "mocha": "^10.2.0",

packages/contracts-bedrock/test-case-generator/go.mod

 module github.com/ethereum-optimism/optimism/packages/contracts-bedrock/ctb-test-case-generator
 
-go 1.19
+go 1.20
 
 require github.com/ethereum/go-ethereum v1.10.26
 

pnpm-lock.yaml

@@ -13,7 +13,7 @@ importers:
         version: 2.26.0
       '@codechecks/client':
         specifier: ^0.1.11
-        version: 0.1.11(typescript@5.1.6)
+        version: 0.1.12(typescript@5.1.6)
     devDependencies:
       '@babel/eslint-parser':
         specifier: ^7.18.2
@@ -97,8 +97,8 @@ importers:
         specifier: 14.0.1
         version: 14.0.1
       markdownlint:
-        specifier: ^0.24.0
-        version: 0.24.0
+        specifier: ^0.30.0
+        version: 0.30.0
       markdownlint-cli2:
         specifier: 0.4.0
         version: 0.4.0
@@ -184,7 +184,7 @@ importers:
         version: 2.9.6(chai@4.3.7)
       ts-node:
         specifier: ^10.9.1
-        version: 10.9.1(@types/node@20.5.0)(typescript@5.1.6)
+        version: 10.9.1(@types/node@20.5.3)(typescript@5.1.6)
       tsx:
         specifier: ^3.12.7
         version: 3.12.7
@@ -1204,8 +1204,8 @@ packages:
       prettier: 2.8.8
     dev: false
 
-  /@codechecks/client@0.1.11(typescript@5.1.6):
-    resolution: {integrity: sha512-dSIzHnGNcXxDZtnVQEXWQHXH2v9KrpnK4mDGDxdwSu3l00rOIVwJcttj0wzx0bC0Q6gs65VsQdZH4gkanLdXOA==}
+  /@codechecks/client@0.1.12(typescript@5.1.6):
+    resolution: {integrity: sha512-2GHHvhO3kaOyxFXxOaiznlY8ARmz33/p+WQdhc2y6wzWw5eOl2wSwg1eZxx3LsWlAnB963Y4bd1YjZcGIhKRzA==}
     engines: {node: '>=6'}
     hasBin: true
     dependencies:
@@ -1221,7 +1221,7 @@ packages:
       lodash: 4.17.21
       marked: 0.7.0
       marked-terminal: 3.3.0(marked@0.7.0)
-      mkdirp: 0.5.5
+      mkdirp: 0.5.6
       ms: 2.1.3
       promise: 8.1.0
       request: 2.88.2
@@ -10985,6 +10985,12 @@ packages:
       uc.micro: 1.0.6
     dev: true
 
+  /linkify-it@4.0.1:
+    resolution: {integrity: sha512-C7bfi1UZmoj8+PQx22XyeXCuBlokoyWQL5pWSP+EI6nzRylyThouddufc2c1NDIcP9k5agmN9fLpA7VNJfIiqw==}
+    dependencies:
+      uc.micro: 1.0.6
+    dev: true
+
   /lint-staged@14.0.1:
     resolution: {integrity: sha512-Mw0cL6HXnHN1ag0mN/Dg4g6sr8uf8sn98w2Oc1ECtFto9tvRF7nkXGJRbx8gPlHyoR0pLyBr2lQHbWwmUHe1Sw==}
     engines: {node: ^16.14.0 || >=18.0.0}
@@ -11315,8 +11321,8 @@ packages:
     resolution: {integrity: sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ==}
     engines: {node: '>=8'}
 
-  /markdown-it@12.2.0:
-    resolution: {integrity: sha512-Wjws+uCrVQRqOoJvze4HCqkKl1AsSh95iFAeQDwnyfxM09divCBSXlDR1uTvyUP3Grzpn4Ru8GeCxYPM8vkCQg==}
+  /markdown-it@12.3.2:
+    resolution: {integrity: sha512-TchMembfxfNVpHkbtriWltGWc+m3xszaRD0CZup7GFFhzIgQqxIfn3eGj1yZpfuflzPvfkt611B2Q/Bsk1YnGg==}
     hasBin: true
     dependencies:
       argparse: 2.0.1
@@ -11326,13 +11332,13 @@ packages:
       uc.micro: 1.0.6
     dev: true
 
-  /markdown-it@12.3.2:
-    resolution: {integrity: sha512-TchMembfxfNVpHkbtriWltGWc+m3xszaRD0CZup7GFFhzIgQqxIfn3eGj1yZpfuflzPvfkt611B2Q/Bsk1YnGg==}
+  /markdown-it@13.0.1:
+    resolution: {integrity: sha512-lTlxriVoy2criHP0JKRhO2VDG9c2ypWCsT237eDiLqi09rmbKoUetyGHq2uOIRoRS//kfoJckS0eUzzkDR+k2Q==}
     hasBin: true
     dependencies:
       argparse: 2.0.1
-      entities: 2.1.0
-      linkify-it: 3.0.3
+      entities: 3.0.1
+      linkify-it: 4.0.1
       mdurl: 1.0.1
       uc.micro: 1.0.6
     dev: true
@@ -11365,15 +11371,13 @@ packages:
       yaml: 1.10.2
     dev: true
 
-  /markdownlint-rule-helpers@0.16.0:
-    resolution: {integrity: sha512-oEacRUVeTJ5D5hW1UYd2qExYI0oELdYK72k1TKGvIeYJIbqQWAz476NAc7LNixSySUhcNl++d02DvX0ccDk9/w==}
+  /markdownlint-micromark@0.1.7:
+    resolution: {integrity: sha512-BbRPTC72fl5vlSKv37v/xIENSRDYL/7X/XoFzZ740FGEbs9vZerLrIkFRY0rv7slQKxDczToYuMmqQFN61fi4Q==}
+    engines: {node: '>=16'}
     dev: true
 
-  /markdownlint@0.24.0:
-    resolution: {integrity: sha512-OJIGsGFV/rC9irI5E1FMy6v9hdACSwaa+EN3224Y5KG8zj2EYzdHOw0pOJovIYmjNfEZ9BtxUY4P7uYHTSNnbQ==}
-    engines: {node: '>=10'}
-    dependencies:
-      markdown-it: 12.2.0
+  /markdownlint-rule-helpers@0.16.0:
+    resolution: {integrity: sha512-oEacRUVeTJ5D5hW1UYd2qExYI0oELdYK72k1TKGvIeYJIbqQWAz476NAc7LNixSySUhcNl++d02DvX0ccDk9/w==}
     dev: true
 
   /markdownlint@0.25.1:
@@ -11383,6 +11387,14 @@ packages:
       markdown-it: 12.3.2
     dev: true
 
+  /markdownlint@0.30.0:
+    resolution: {integrity: sha512-nInuFvI/rEzanAOArW5490Ez4EYpB5ODqVM0mcDYCPx9DKJWCQqCgejjiCvbSeE7sjbDscVtZmwr665qpF5xGA==}
+    engines: {node: '>=16'}
+    dependencies:
+      markdown-it: 13.0.1
+      markdownlint-micromark: 0.1.7
+    dev: true
+
   /marked-terminal@3.3.0(marked@0.7.0):
     resolution: {integrity: sha512-+IUQJ5VlZoAFsM5MHNT7g3RHSkA3eETqhRCdXv4niUMAKHQ7lb1yvAcuGPmm4soxhmtX13u4Li6ZToXtvSEH+A==}
     peerDependencies:
@@ -11904,19 +11916,11 @@ packages:
     engines: {node: '>= 8.0.0'}
     dev: false
 
-  /mkdirp@0.5.5:
-    resolution: {integrity: sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ==}
-    hasBin: true
-    dependencies:
-      minimist: 1.2.8
-    dev: false
-
   /mkdirp@0.5.6:
     resolution: {integrity: sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==}
     hasBin: true
     dependencies:
       minimist: 1.2.8
-    dev: true
 
   /mkdirp@1.0.4:
     resolution: {integrity: sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==}
@@ -15236,6 +15240,37 @@ packages:
       yn: 3.1.1
     dev: true
 
+  /ts-node@10.9.1(@types/node@20.5.3)(typescript@5.1.6):
+    resolution: {integrity: sha512-NtVysVPkxxrwFGUUxGYhfux8k78pQB3JqYBXlLRZgdGUqTO5wU/UyHop5p70iEbGhB7q5KmiZiU0Y3KlJrScEw==}
+    hasBin: true
+    peerDependencies:
+      '@swc/core': '>=1.2.50'
+      '@swc/wasm': '>=1.2.50'
+      '@types/node': '*'
+      typescript: '>=2.7'
+    peerDependenciesMeta:
+      '@swc/core':
+        optional: true
+      '@swc/wasm':
+        optional: true
+    dependencies:
+      '@cspotcode/source-map-support': 0.8.1
+      '@tsconfig/node10': 1.0.9
+      '@tsconfig/node12': 1.0.11
+      '@tsconfig/node14': 1.0.3
+      '@tsconfig/node16': 1.0.4
+      '@types/node': 20.5.3
+      acorn: 8.10.0
+      acorn-walk: 8.2.0
+      arg: 4.1.3
+      create-require: 1.1.1
+      diff: 4.0.2
+      make-error: 1.3.6
+      typescript: 5.1.6
+      v8-compile-cache-lib: 3.0.1
+      yn: 3.1.1
+    dev: true
+
   /ts-node@7.0.1:
     resolution: {integrity: sha512-BVwVbPJRspzNh2yfslyT1PSbl5uIk03EZlb493RKHN4qej/D06n1cEhjlOJG69oFsE7OT8XjpTUcYf6pKTLMhw==}
     engines: {node: '>=4.2.0'}

proxyd/go.mod

 module github.com/ethereum-optimism/optimism/proxyd
 
-go 1.18
+go 1.20
 
 require (
 	github.com/BurntSushi/toml v1.2.0

specs/meta/devnet.md

@@ -9,9 +9,9 @@
 
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 
-You can spin up a local devnet via `docker-compose`.
+You can spin up a local devnet via `docker compose`.
 For convenience, we have defined `make` targets to start and stop the devnet with a single command.
-To run the devnet, you will need `docker` and `docker-compose` installed.
+To run the devnet, you will need `docker` installed.
 Then, as a precondition, make sure that you have compiled the contracts by `cd`ing into `packages/contracts`
 and running `pnpm i` followed by `pnpm build`. You'll only need to do this if you change the contracts in the future.