Merge branch 'develop' into 09-15-feat_indexer_Enable_devnet_indexer_as_a_preset

.circleci/config.yml

@@ -887,6 +887,10 @@ jobs:
           name: Build
           command: make indexer
           working_directory: indexer
+      - run:
+          name: Install node_modules
+          command: pnpm install --frozen-lockfile --prefer-offline
+          working_directory: indexer/api-ts
       - run:
           name: Install tygo
           command: go install github.com/gzuidhof/tygo@latest

.gitmodules

@@ -13,3 +13,10 @@
 [submodule "packages/contracts-bedrock/lib/forge-std"]
 	path = packages/contracts-bedrock/lib/forge-std
 	url = https://github.com/foundry-rs/forge-std
+[submodule "packages/contracts-bedrock/lib/safe-contracts"]
+	path = packages/contracts-bedrock/lib/safe-contracts
+	url = https://github.com/safe-global/safe-contracts
+	branch = v1.4.0
+
+
+

.semgrepignore

@@ -18,7 +18,7 @@ tests/
 # Semgrep-action log folder
 .semgrep_logs/
 
-op-bindings/bindings
+op-bindings/bindings/
 
 packages/*/node_modules
 packages/*/test

Makefile

@@ -89,10 +89,8 @@ devnet-up:
 	@if [ ! -e op-program/bin ]; then \
 		make cannon-prestate; \
 	fi
-	$(shell ./ops/scripts/newer-file.sh .devnet/allocs-l1.json ./packages/contracts-bedrock)
-	if [ $(.SHELLSTATUS) -ne 0 ]; then \
-		make devnet-allocs; \
-	fi
+	./ops/scripts/newer-file.sh .devnet/allocs-l1.json ./packages/contracts-bedrock \
+		|| make devnet-allocs
 	PYTHONPATH=./bedrock-devnet python3 ./bedrock-devnet/main.py --monorepo-dir=.
 .PHONY: devnet-up
 

indexer/api-ts/generated.ts

@@ -8,12 +8,12 @@ export interface DepositItem {
   from: string;
   to: string;
   timestamp: number /* uint64 */;
-  L1TxHash: string;
-  L2TxHash: string;
-  Block: string;
+  l1BlockHash: string;
+  l1TxHash: string;
+  l2TxHash: string;
   amount: string;
-  l1Token: string;
-  l2Token: string;
+  l1TokenAddress: string;
+  l2TokenAddress: string;
 }
 export interface DepositResponse {
   cursor: string;
@@ -41,10 +41,10 @@ export interface WithdrawalItem {
   timestamp: number /* uint64 */;
   l2BlockHash: string;
   amount: string;
-  proof: string;
-  claim: string;
-  l1Token: string;
-  l2Token: string;
+  proofTransactionHash: string;
+  claimTransactionHash: string;
+  l1TokenAddress: string;
+  l2TokenAddress: string;
 }
 export interface WithdrawalResponse {
   cursor: string;

indexer/api-ts/indexer.cjs

@@ -38,10 +38,10 @@ var createQueryString = ({ cursor, limit }) => {
   return `?${queries.join("&")}`;
 };
 var depositEndpoint = ({ baseUrl = "", address, cursor, limit }) => {
-  return [baseUrl, "deposits", address, createQueryString({ cursor, limit })].join("/");
+  return [baseUrl, "deposits", `${address}${createQueryString({ cursor, limit })}`].join("/");
 };
 var withdrawalEndoint = ({ baseUrl = "", address, cursor, limit }) => {
-  return [baseUrl, "withdrawals", address, createQueryString({ cursor, limit })].join("/");
+  return [baseUrl, "withdrawals", `${address}${createQueryString({ cursor, limit })}`].join("/");
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

indexer/api-ts/indexer.cjs.map

-{"version":3,"sources":["indexer.ts"],"sourcesContent":["export * from './generated'\n\ntype PaginationOptions = {\n  limit?: number\n  cursor?: string\n}\n\ntype Options = {\n  baseUrl?: string\n  address: `0x${string}`\n} & PaginationOptions\n\nconst createQueryString = ({ cursor, limit }: PaginationOptions): string => {\n  if (cursor === undefined && limit === undefined) {\n    return ''\n  }\n  const queries: string[] = []\n  if (cursor) {\n    queries.push(`cursor=${cursor}`)\n  }\n  if (limit) {\n    queries.push(`limit=${limit}`)\n  }\n  return `?${queries.join('&')}`\n}\n\nexport const depositEndpoint = ({ baseUrl = '', address, cursor, limit }: Options): string => {\n  return [baseUrl, 'deposits', address, createQueryString({ cursor, limit })].join('/')\n}\n\nexport const withdrawalEndoint = ({ baseUrl = '', address, cursor, limit }: Options): string => {\n  return [baseUrl, 'withdrawals', address, createQueryString({ cursor, limit })].join('/')\n}\n\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAYA,IAAM,oBAAoB,CAAC,EAAE,QAAQ,MAAM,MAAiC;AAC1E,MAAI,WAAW,UAAa,UAAU,QAAW;AAC/C,WAAO;AAAA,EACT;AACA,QAAM,UAAoB,CAAC;AAC3B,MAAI,QAAQ;AACV,YAAQ,KAAK,UAAU,MAAM,EAAE;AAAA,EACjC;AACA,MAAI,OAAO;AACT,YAAQ,KAAK,SAAS,KAAK,EAAE;AAAA,EAC/B;AACA,SAAO,IAAI,QAAQ,KAAK,GAAG,CAAC;AAC9B;AAEO,IAAM,kBAAkB,CAAC,EAAE,UAAU,IAAI,SAAS,QAAQ,MAAM,MAAuB;AAC5F,SAAO,CAAC,SAAS,YAAY,SAAS,kBAAkB,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG;AACtF;AAEO,IAAM,oBAAoB,CAAC,EAAE,UAAU,IAAI,SAAS,QAAQ,MAAM,MAAuB;AAC9F,SAAO,CAAC,SAAS,eAAe,SAAS,kBAAkB,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG;AACzF;","names":[]}
+{"version":3,"sources":["indexer.ts"],"sourcesContent":["export * from './generated'\n\ntype PaginationOptions = {\n  limit?: number\n  cursor?: string\n}\n\ntype Options = {\n  baseUrl?: string\n  address: `0x${string}`\n} & PaginationOptions\n\nconst createQueryString = ({ cursor, limit }: PaginationOptions): string => {\n  if (cursor === undefined && limit === undefined) {\n    return ''\n  }\n  const queries: string[] = []\n  if (cursor) {\n    queries.push(`cursor=${cursor}`)\n  }\n  if (limit) {\n    queries.push(`limit=${limit}`)\n  }\n  return `?${queries.join('&')}`\n}\n\nexport const depositEndpoint = ({ baseUrl = '', address, cursor, limit }: Options): string => {\n  return [baseUrl, 'deposits', `${address}${createQueryString({ cursor, limit })}`].join('/')\n}\n\nexport const withdrawalEndoint = ({ baseUrl = '', address, cursor, limit }: Options): string => {\n  return [baseUrl, 'withdrawals', `${address}${createQueryString({ cursor, limit })}`].join('/')\n}\n\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAYA,IAAM,oBAAoB,CAAC,EAAE,QAAQ,MAAM,MAAiC;AAC1E,MAAI,WAAW,UAAa,UAAU,QAAW;AAC/C,WAAO;AAAA,EACT;AACA,QAAM,UAAoB,CAAC;AAC3B,MAAI,QAAQ;AACV,YAAQ,KAAK,UAAU,MAAM,EAAE;AAAA,EACjC;AACA,MAAI,OAAO;AACT,YAAQ,KAAK,SAAS,KAAK,EAAE;AAAA,EAC/B;AACA,SAAO,IAAI,QAAQ,KAAK,GAAG,CAAC;AAC9B;AAEO,IAAM,kBAAkB,CAAC,EAAE,UAAU,IAAI,SAAS,QAAQ,MAAM,MAAuB;AAC5F,SAAO,CAAC,SAAS,YAAY,GAAG,OAAO,GAAG,kBAAkB,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,EAAE,KAAK,GAAG;AAC5F;AAEO,IAAM,oBAAoB,CAAC,EAAE,UAAU,IAAI,SAAS,QAAQ,MAAM,MAAuB;AAC9F,SAAO,CAAC,SAAS,eAAe,GAAG,OAAO,GAAG,kBAAkB,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,EAAE,KAAK,GAAG;AAC/F;","names":[]}
\ No newline at end of file

indexer/api-ts/indexer.js

@@ -13,10 +13,10 @@ var createQueryString = ({ cursor, limit }) => {
   return `?${queries.join("&")}`;
 };
 var depositEndpoint = ({ baseUrl = "", address, cursor, limit }) => {
-  return [baseUrl, "deposits", address, createQueryString({ cursor, limit })].join("/");
+  return [baseUrl, "deposits", `${address}${createQueryString({ cursor, limit })}`].join("/");
 };
 var withdrawalEndoint = ({ baseUrl = "", address, cursor, limit }) => {
-  return [baseUrl, "withdrawals", address, createQueryString({ cursor, limit })].join("/");
+  return [baseUrl, "withdrawals", `${address}${createQueryString({ cursor, limit })}`].join("/");
 };
 export {
   depositEndpoint,

indexer/api-ts/indexer.js.map

-{"version":3,"sources":["indexer.ts"],"sourcesContent":["export * from './generated'\n\ntype PaginationOptions = {\n  limit?: number\n  cursor?: string\n}\n\ntype Options = {\n  baseUrl?: string\n  address: `0x${string}`\n} & PaginationOptions\n\nconst createQueryString = ({ cursor, limit }: PaginationOptions): string => {\n  if (cursor === undefined && limit === undefined) {\n    return ''\n  }\n  const queries: string[] = []\n  if (cursor) {\n    queries.push(`cursor=${cursor}`)\n  }\n  if (limit) {\n    queries.push(`limit=${limit}`)\n  }\n  return `?${queries.join('&')}`\n}\n\nexport const depositEndpoint = ({ baseUrl = '', address, cursor, limit }: Options): string => {\n  return [baseUrl, 'deposits', address, createQueryString({ cursor, limit })].join('/')\n}\n\nexport const withdrawalEndoint = ({ baseUrl = '', address, cursor, limit }: Options): string => {\n  return [baseUrl, 'withdrawals', address, createQueryString({ cursor, limit })].join('/')\n}\n\n"],"mappings":";AAYA,IAAM,oBAAoB,CAAC,EAAE,QAAQ,MAAM,MAAiC;AAC1E,MAAI,WAAW,UAAa,UAAU,QAAW;AAC/C,WAAO;AAAA,EACT;AACA,QAAM,UAAoB,CAAC;AAC3B,MAAI,QAAQ;AACV,YAAQ,KAAK,UAAU,MAAM,EAAE;AAAA,EACjC;AACA,MAAI,OAAO;AACT,YAAQ,KAAK,SAAS,KAAK,EAAE;AAAA,EAC/B;AACA,SAAO,IAAI,QAAQ,KAAK,GAAG,CAAC;AAC9B;AAEO,IAAM,kBAAkB,CAAC,EAAE,UAAU,IAAI,SAAS,QAAQ,MAAM,MAAuB;AAC5F,SAAO,CAAC,SAAS,YAAY,SAAS,kBAAkB,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG;AACtF;AAEO,IAAM,oBAAoB,CAAC,EAAE,UAAU,IAAI,SAAS,QAAQ,MAAM,MAAuB;AAC9F,SAAO,CAAC,SAAS,eAAe,SAAS,kBAAkB,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG;AACzF;","names":[]}
+{"version":3,"sources":["indexer.ts"],"sourcesContent":["export * from './generated'\n\ntype PaginationOptions = {\n  limit?: number\n  cursor?: string\n}\n\ntype Options = {\n  baseUrl?: string\n  address: `0x${string}`\n} & PaginationOptions\n\nconst createQueryString = ({ cursor, limit }: PaginationOptions): string => {\n  if (cursor === undefined && limit === undefined) {\n    return ''\n  }\n  const queries: string[] = []\n  if (cursor) {\n    queries.push(`cursor=${cursor}`)\n  }\n  if (limit) {\n    queries.push(`limit=${limit}`)\n  }\n  return `?${queries.join('&')}`\n}\n\nexport const depositEndpoint = ({ baseUrl = '', address, cursor, limit }: Options): string => {\n  return [baseUrl, 'deposits', `${address}${createQueryString({ cursor, limit })}`].join('/')\n}\n\nexport const withdrawalEndoint = ({ baseUrl = '', address, cursor, limit }: Options): string => {\n  return [baseUrl, 'withdrawals', `${address}${createQueryString({ cursor, limit })}`].join('/')\n}\n\n"],"mappings":";AAYA,IAAM,oBAAoB,CAAC,EAAE,QAAQ,MAAM,MAAiC;AAC1E,MAAI,WAAW,UAAa,UAAU,QAAW;AAC/C,WAAO;AAAA,EACT;AACA,QAAM,UAAoB,CAAC;AAC3B,MAAI,QAAQ;AACV,YAAQ,KAAK,UAAU,MAAM,EAAE;AAAA,EACjC;AACA,MAAI,OAAO;AACT,YAAQ,KAAK,SAAS,KAAK,EAAE;AAAA,EAC/B;AACA,SAAO,IAAI,QAAQ,KAAK,GAAG,CAAC;AAC9B;AAEO,IAAM,kBAAkB,CAAC,EAAE,UAAU,IAAI,SAAS,QAAQ,MAAM,MAAuB;AAC5F,SAAO,CAAC,SAAS,YAAY,GAAG,OAAO,GAAG,kBAAkB,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,EAAE,KAAK,GAAG;AAC5F;AAEO,IAAM,oBAAoB,CAAC,EAAE,UAAU,IAAI,SAAS,QAAQ,MAAM,MAAuB;AAC9F,SAAO,CAAC,SAAS,eAAe,GAAG,OAAO,GAAG,kBAAkB,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,EAAE,KAAK,GAAG;AAC/F;","names":[]}
\ No newline at end of file

indexer/api-ts/indexer.spec.ts

+import { test, expect } from 'vitest'
+import { depositEndpoint, withdrawalEndoint } from './indexer.ts'
+
+test(depositEndpoint.name, () => {
+  expect(depositEndpoint({ baseUrl: 'http://localhost:8080/api/v0', address: '0x1234', cursor: '0x1235', limit: 10 })).toMatchInlineSnapshot('"http://localhost:8080/api/v0/deposits/0x1234?cursor=0x1235&limit=10"')
+  expect(depositEndpoint({ baseUrl: 'http://localhost:8080/api/v0', address: '0x1234' })).toMatchInlineSnapshot('"http://localhost:8080/api/v0/deposits/0x1234"')
+})
+
+test(withdrawalEndoint.name, () => {
+  expect(withdrawalEndoint({ baseUrl: 'http://localhost:8080/api/v0', address: '0x1234', cursor: '0x1235', limit: 10 })).toMatchInlineSnapshot('"http://localhost:8080/api/v0/withdrawals/0x1234?cursor=0x1235&limit=10"')
+  expect(withdrawalEndoint({ baseUrl: 'http://localhost:8080/api/v0', address: '0x1234' })).toMatchInlineSnapshot('"http://localhost:8080/api/v0/withdrawals/0x1234"')
+})

indexer/api-ts/indexer.ts

@@ -25,10 +25,10 @@ const createQueryString = ({ cursor, limit }: PaginationOptions): string => {
 }
 
 export const depositEndpoint = ({ baseUrl = '', address, cursor, limit }: Options): string => {
-  return [baseUrl, 'deposits', address, createQueryString({ cursor, limit })].join('/')
+  return [baseUrl, 'deposits', `${address}${createQueryString({ cursor, limit })}`].join('/')
 }
 
 export const withdrawalEndoint = ({ baseUrl = '', address, cursor, limit }: Options): string => {
-  return [baseUrl, 'withdrawals', address, createQueryString({ cursor, limit })].join('/')
+  return [baseUrl, 'withdrawals', `${address}${createQueryString({ cursor, limit })}`].join('/')
 }
 

indexer/api-ts/package.json

 {
   "name": "@eth-optimism/indexer-api",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "[Optimism] typescript types for the indexer service",
   "main": "indexer.cjs",
   "module": "indexer.js",
@@ -17,7 +17,8 @@
   ],
   "scripts": {
     "clean": "rm -rf generated.ts indexer.cjs indexer.js",
-    "generate": "npm run clean && tygo generate && mv ../api/routes/index.ts generated.ts && npx tsup"
+    "generate": "npm run clean && tygo generate && mv ../api/routes/index.ts generated.ts && tsup",
+    "test": "vitest"
   },
   "keywords": [
     "optimism",
@@ -30,4 +31,9 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/ethereum-optimism/optimism.git"
-  }}
+  },
+  "devDependencies": {
+    "tsup": "^7.2.0",
+    "vitest": "^0.34.4"
+  }
+}

indexer/api-ts/tsconfig.json

@@ -4,7 +4,7 @@
     "strict": true,
     "skipLibCheck": true,
     "module": "ESNext",
-    "moduleResolution": "bundler",
+    "moduleResolution": "NodeNext",
     "jsx": "react",
     "target": "ESNext",
     "noEmit": true

indexer/api/routes/deposits.go

@@ -14,12 +14,12 @@ type DepositItem struct {
 	From           string `json:"from"`
 	To             string `json:"to"`
 	Timestamp      uint64 `json:"timestamp"`
-	L1TxHash       string `json:"L1TxHash"`
-	L2TxHash       string `json:"L2TxHash"`
-	L1BlockHash    string `json:"Block"`
+	L1BlockHash    string `json:"l1BlockHash"`
+	L1TxHash       string `json:"l1TxHash"`
+	L2TxHash       string `json:"l2TxHash"`
 	Amount         string `json:"amount"`
-	L1TokenAddress string `json:"l1Token"`
-	L2TokenAddress string `json:"l2Token"`
+	L1TokenAddress string `json:"l1TokenAddress"`
+	L2TokenAddress string `json:"l2TokenAddress"`
 }
 
 type DepositResponse struct {

indexer/api/routes/withdrawals.go

@@ -17,10 +17,10 @@ type WithdrawalItem struct {
 	Timestamp            uint64 `json:"timestamp"`
 	L2BlockHash          string `json:"l2BlockHash"`
 	Amount               string `json:"amount"`
-	ProofTransactionHash string `json:"proof"`
-	ClaimTransactionHash string `json:"claim"`
-	L1TokenAddress       string `json:"l1Token"`
-	L2TokenAddress       string `json:"l2Token"`
+	ProofTransactionHash string `json:"proofTransactionHash"`
+	ClaimTransactionHash string `json:"claimTransactionHash"`
+	L1TokenAddress       string `json:"l1TokenAddress"`
+	L2TokenAddress       string `json:"l2TokenAddress"`
 }
 
 type WithdrawalResponse struct {

indexer/database/db.go

@@ -2,10 +2,13 @@
 package database
 
 import (
+	"context"
 	"fmt"
 
 	"github.com/ethereum-optimism/optimism/indexer/config"
 	_ "github.com/ethereum-optimism/optimism/indexer/database/serializers"
+	"github.com/ethereum-optimism/optimism/op-service/retry"
+	"github.com/pkg/errors"
 
 	"gorm.io/driver/postgres"
 	"gorm.io/gorm"
@@ -31,6 +34,8 @@ type DB struct {
 }
 
 func NewDB(dbConfig config.DBConfig) (*DB, error) {
+	retryStrategy := &retry.ExponentialStrategy{Min: 1000, Max: 20_000, MaxJitter: 250}
+
 	dsn := fmt.Sprintf("host=%s port=%d dbname=%s sslmode=disable", dbConfig.Host, dbConfig.Port, dbConfig.Name)
 	if dbConfig.User != "" {
 		dsn += fmt.Sprintf(" user=%s", dbConfig.User)
@@ -38,17 +43,24 @@ func NewDB(dbConfig config.DBConfig) (*DB, error) {
 	if dbConfig.Password != "" {
 		dsn += fmt.Sprintf(" password=%s", dbConfig.Password)
 	}
-	gorm, err := gorm.Open(postgres.Open(dsn), &gorm.Config{
+
+	gormConfig := gorm.Config{
 		// The indexer will explicitly manage the transactions
 		SkipDefaultTransaction: true,
+		Logger:                 logger.Default.LogMode(logger.Silent),
+	}
+
+	gorm, err := retry.Do[*gorm.DB](context.Background(), 10, retryStrategy, func() (*gorm.DB, error) {
+		gorm, err := gorm.Open(postgres.Open(dsn), &gormConfig)
 
-		// We may choose to create an adapter such that the
-		// logger emits to the geth logger when on DEBUG mode
-		Logger: logger.Default.LogMode(logger.Silent),
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to connect to database")
+		}
+		return gorm, nil
 	})
 
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "failed to connect to database after multiple retries")
 	}
 
 	db := &DB{

op-bindings/artifacts.json

@@ -36,5 +36,8 @@
   "BlockOracle",
   "EAS",
   "SchemaRegistry",
-  "ProtocolVersions"
+  "ProtocolVersions",
+  "Safe",
+  "SafeProxyFactory",
+  "DelayedVetoable"
 ]

op-bindings/bindings/delayedvetoable_more.go

+// Code generated - DO NOT EDIT.
+// This file is a generated binding and any manual changes will be lost.
+
+package bindings
+
+import (
+	"encoding/json"
+
+	"github.com/ethereum-optimism/optimism/op-bindings/solc"
+)
+
+const DelayedVetoableStorageLayoutJSON = "{\"storage\":[{\"astId\":1000,\"contract\":\"src/L1/DelayedVetoable.sol:DelayedVetoable\",\"label\":\"_delay\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_uint256\"},{\"astId\":1001,\"contract\":\"src/L1/DelayedVetoable.sol:DelayedVetoable\",\"label\":\"_queuedAt\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_mapping(t_bytes32,t_uint256)\"}],\"types\":{\"t_bytes32\":{\"encoding\":\"inplace\",\"label\":\"bytes32\",\"numberOfBytes\":\"32\"},\"t_mapping(t_bytes32,t_uint256)\":{\"encoding\":\"mapping\",\"label\":\"mapping(bytes32 =\u003e uint256)\",\"numberOfBytes\":\"32\",\"key\":\"t_bytes32\",\"value\":\"t_uint256\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"}}}"
+
+var DelayedVetoableStorageLayout = new(solc.StorageLayout)
+
+var DelayedVetoableDeployedBin = "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"
+
+func init() {
+	if err := json.Unmarshal([]byte(DelayedVetoableStorageLayoutJSON), DelayedVetoableStorageLayout); err != nil {
+		panic(err)
+	}
+
+	layouts["DelayedVetoable"] = DelayedVetoableStorageLayout
+	deployedBytecodes["DelayedVetoable"] = DelayedVetoableDeployedBin
+}

op-bindings/bindings/safeproxyfactory_more.go

+// Code generated - DO NOT EDIT.
+// This file is a generated binding and any manual changes will be lost.
+
+package bindings
+
+import (
+	"encoding/json"
+
+	"github.com/ethereum-optimism/optimism/op-bindings/solc"
+)
+
+const SafeProxyFactoryStorageLayoutJSON = "{\"storage\":null,\"types\":{}}"
+
+var SafeProxyFactoryStorageLayout = new(solc.StorageLayout)
+
+var SafeProxyFactoryDeployedBin = "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"
+
+func init() {
+	if err := json.Unmarshal([]byte(SafeProxyFactoryStorageLayoutJSON), SafeProxyFactoryStorageLayout); err != nil {
+		panic(err)
+	}
+
+	layouts["SafeProxyFactory"] = SafeProxyFactoryStorageLayout
+	deployedBytecodes["SafeProxyFactory"] = SafeProxyFactoryDeployedBin
+}

op-bindings/bindings/weth9_more.go

@@ -13,7 +13,7 @@ const WETH9StorageLayoutJSON = "{\"storage\":[{\"astId\":1000,\"contract\":\"src
 
 var WETH9StorageLayout = new(solc.StorageLayout)
 
-var WETH9DeployedBin = "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"
+var WETH9DeployedBin = "0x6080604052600436106100bc5760003560e01c8063313ce56711610074578063a9059cbb1161004e578063a9059cbb146102cb578063d0e30db0146100bc578063dd62ed3e14610311576100bc565b8063313ce5671461024b57806370a082311461027657806395d89b41146102b6576100bc565b806318160ddd116100a557806318160ddd146101aa57806323b872dd146101d15780632e1a7d4d14610221576100bc565b806306fdde03146100c6578063095ea7b314610150575b6100c4610359565b005b3480156100d257600080fd5b506100db6103a8565b6040805160208082528351818301528351919283929083019185019080838360005b838110156101155781810151838201526020016100fd565b50505050905090810190601f1680156101425780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b34801561015c57600080fd5b506101966004803603604081101561017357600080fd5b5073ffffffffffffffffffffffffffffffffffffffff8135169060200135610454565b604080519115158252519081900360200190f35b3480156101b657600080fd5b506101bf6104c7565b60408051918252519081900360200190f35b3480156101dd57600080fd5b50610196600480360360608110156101f457600080fd5b5073ffffffffffffffffffffffffffffffffffffffff8135811691602081013590911690604001356104cb565b34801561022d57600080fd5b506100c46004803603602081101561024457600080fd5b503561066b565b34801561025757600080fd5b50610260610700565b6040805160ff9092168252519081900360200190f35b34801561028257600080fd5b506101bf6004803603602081101561029957600080fd5b503573ffffffffffffffffffffffffffffffffffffffff16610709565b3480156102c257600080fd5b506100db61071b565b3480156102d757600080fd5b50610196600480360360408110156102ee57600080fd5b5073ffffffffffffffffffffffffffffffffffffffff8135169060200135610793565b34801561031d57600080fd5b506101bf6004803603604081101561033457600080fd5b5073ffffffffffffffffffffffffffffffffffffffff813581169160200135166107a7565b33600081815260036020908152604091829020805434908101909155825190815291517fe1fffcc4923d04b559f4d29a8bfc6cda04eb5b0d3c460751c2402c5c5cc9109c9281900390910190a2565b6000805460408051602060026001851615610100027fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0190941693909304601f8101849004840282018401909252818152929183018282801561044c5780601f106104215761010080835404028352916020019161044c565b820191906000526020600020905b81548152906001019060200180831161042f57829003601f168201915b505050505081565b33600081815260046020908152604080832073ffffffffffffffffffffffffffffffffffffffff8716808552908352818420869055815186815291519394909390927f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925928290030190a350600192915050565b4790565b73ffffffffffffffffffffffffffffffffffffffff83166000908152600360205260408120548211156104fd57600080fd5b73ffffffffffffffffffffffffffffffffffffffff84163314801590610573575073ffffffffffffffffffffffffffffffffffffffff841660009081526004602090815260408083203384529091529020547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff14155b156105ed5773ffffffffffffffffffffffffffffffffffffffff841660009081526004602090815260408083203384529091529020548211156105b557600080fd5b73ffffffffffffffffffffffffffffffffffffffff841660009081526004602090815260408083203384529091529020805483900390555b73ffffffffffffffffffffffffffffffffffffffff808516600081815260036020908152604080832080548890039055938716808352918490208054870190558351868152935191937fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef929081900390910190a35060019392505050565b3360009081526003602052604090205481111561068757600080fd5b33600081815260036020526040808220805485900390555183156108fc0291849190818181858888f193505050501580156106c6573d6000803e3d6000fd5b5060408051828152905133917f7fcf532c15f0a6db0bd6d0e038bea71d30d808c7d98cb3bf7268a95bf5081b65919081900360200190a250565b60025460ff1681565b60036020526000908152604090205481565b60018054604080516020600284861615610100027fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0190941693909304601f8101849004840282018401909252818152929183018282801561044c5780601f106104215761010080835404028352916020019161044c565b60006107a03384846104cb565b9392505050565b60046020908152600092835260408084209091529082529020548156fea265627a7a723158203b5b5adf37f507cc9ca5ac0b72acf7873b794171cc0eeb888a5f850e69fe540d64736f6c63430005110032"
 
 func init() {
 	if err := json.Unmarshal([]byte(WETH9StorageLayoutJSON), WETH9StorageLayout); err != nil {

op-bootnode/Makefile

@@ -10,5 +10,17 @@ LDFLAGS := -ldflags "$(LDFLAGSSTRING)"
 op-bootnode:
 	env GO111MODULE=on GOOS=$(TARGETOS) GOARCH=$(TARGETARCH) go build -v $(LDFLAGS) -o ./bin/op-bootnode ./cmd
 
+clean:
+	rm -f bin/op-bootnode
+
+test:
+	go test -v ./...
+
 lint:
 	golangci-lint run -E goimports,sqlclosecheck,bodyclose,asciicheck,misspell,errorlint --timeout 5m -e "errors.As" -e "errors.Is" ./...
+
+.PHONY: \
+	op-bootnode \
+	clean \
+	test \
+	lint

op-bootnode/bootnode/entrypoint.go

@@ -18,6 +18,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
 	"github.com/ethereum-optimism/optimism/op-service/eth"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
+	opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics"
 	"github.com/ethereum-optimism/optimism/op-service/opio"
 )
 
@@ -69,6 +70,17 @@ func Main(cliCtx *cli.Context) error {
 
 	go p2pNode.DiscoveryProcess(ctx, logger, config, p2pConfig.TargetPeers())
 
+	metricsCfg := opmetrics.ReadCLIConfig(cliCtx)
+	if metricsCfg.Enabled {
+		log.Info("starting metrics server", "addr", metricsCfg.ListenAddr, "port", metricsCfg.ListenPort)
+		go func() {
+			if err := m.Serve(ctx, metricsCfg.ListenAddr, metricsCfg.ListenPort); err != nil {
+				log.Error("error starting metrics server", err)
+			}
+		}()
+		m.RecordUp()
+	}
+
 	opio.BlockOnInterrupts()
 
 	return nil

op-bootnode/cmd/main.go

@@ -3,21 +3,16 @@ package main
 import (
 	"os"
 
-	"github.com/ethereum-optimism/optimism/op-bootnode/bootnode"
-	"github.com/ethereum-optimism/optimism/op-bootnode/flags"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/urfave/cli/v2"
+
+	"github.com/ethereum-optimism/optimism/op-bootnode/bootnode"
+	"github.com/ethereum-optimism/optimism/op-bootnode/flags"
+	oplog "github.com/ethereum-optimism/optimism/op-service/log"
 )
 
 func main() {
-	// Set up logger with a default INFO level in case we fail to parse flags,
-	// otherwise the final critical log won't show what the parsing error was.
-	log.Root().SetHandler(
-		log.LvlFilterHandler(
-			log.LvlInfo,
-			log.StreamHandler(os.Stdout, log.TerminalFormat(true)),
-		),
-	)
+	oplog.SetupDefaults()
 
 	app := cli.NewApp()
 	app.Flags = flags.Flags

op-bootnode/flags/flags.go

@@ -8,6 +8,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-node/flags"
 	opservice "github.com/ethereum-optimism/optimism/op-service"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
+	opmetrics "github.com/ethereum-optimism/optimism/op-service/metrics"
 	"github.com/urfave/cli/v2"
 )
 
@@ -36,5 +37,7 @@ var Flags = []cli.Flag{
 }
 
 func init() {
+	Flags = append(Flags, flags.P2pFlags...)
+	Flags = append(Flags, opmetrics.CLIFlags(envVarPrefix)...)
 	Flags = append(Flags, oplog.CLIFlags(envVarPrefix)...)
 }

op-challenger/cmd/main_test.go

@@ -24,6 +24,7 @@ var (
 	cannonPreState          = "./pre.json"
 	datadir                 = "./test_data"
 	cannonL2                = "http://example.com:9545"
+	rollupRpc               = "http://example.com:8555"
 	alphabetTrace           = "abcdefghijz"
 	agreeWithProposedOutput = "true"
 )
@@ -249,6 +250,25 @@ func TestDataDir(t *testing.T) {
 	})
 }
 
+func TestRollupRpc(t *testing.T) {
+	t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) {
+		configForArgs(t, addRequiredArgsExcept(config.TraceTypeAlphabet, "--rollup-rpc"))
+	})
+
+	t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) {
+		configForArgs(t, addRequiredArgsExcept(config.TraceTypeCannon, "--rollup-rpc"))
+	})
+
+	t.Run("RequiredForOutputCannonTrace", func(t *testing.T) {
+		verifyArgsInvalid(t, "flag rollup-rpc is required", addRequiredArgsExcept(config.TraceTypeOutputCannon, "--rollup-rpc"))
+	})
+
+	t.Run("Valid", func(t *testing.T) {
+		cfg := configForArgs(t, addRequiredArgs(config.TraceTypeOutputCannon))
+		require.Equal(t, rollupRpc, cfg.RollupRpc)
+	})
+}
+
 func TestCannonL2(t *testing.T) {
 	t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) {
 		configForArgs(t, addRequiredArgsExcept(config.TraceTypeAlphabet, "--cannon-l2"))
@@ -422,13 +442,16 @@ func requiredArgs(traceType config.TraceType) map[string]string {
 	switch traceType {
 	case config.TraceTypeAlphabet:
 		args["--alphabet"] = alphabetTrace
-	case config.TraceTypeCannon:
+	case config.TraceTypeCannon, config.TraceTypeOutputCannon:
 		args["--cannon-network"] = cannonNetwork
 		args["--cannon-bin"] = cannonBin
 		args["--cannon-server"] = cannonServer
 		args["--cannon-prestate"] = cannonPreState
 		args["--cannon-l2"] = cannonL2
 	}
+	if traceType == config.TraceTypeOutputCannon {
+		args["--rollup-rpc"] = rollupRpc
+	}
 	return args
 }
 

op-challenger/config/config.go

@@ -32,13 +32,15 @@ var (
 	ErrCannonNetworkAndRollupConfig  = errors.New("only specify one of network or rollup config path")
 	ErrCannonNetworkAndL2Genesis     = errors.New("only specify one of network or l2 genesis path")
 	ErrCannonNetworkUnknown          = errors.New("unknown cannon network")
+	ErrMissingRollupRpc              = errors.New("missing rollup rpc url")
 )
 
 type TraceType string
 
 const (
-	TraceTypeAlphabet TraceType = "alphabet"
-	TraceTypeCannon   TraceType = "cannon"
+	TraceTypeAlphabet     TraceType = "alphabet"
+	TraceTypeCannon       TraceType = "cannon"
+	TraceTypeOutputCannon TraceType = "output_cannon"
 
 	// Mainnet games
 	CannonFaultGameID = 0
@@ -47,7 +49,7 @@ const (
 	AlphabetFaultGameID = 255
 )
 
-var TraceTypes = []TraceType{TraceTypeAlphabet, TraceTypeCannon}
+var TraceTypes = []TraceType{TraceTypeAlphabet, TraceTypeCannon, TraceTypeOutputCannon}
 
 // GameIdToString maps game IDs to their string representation.
 var GameIdToString = map[uint8]string{
@@ -106,6 +108,9 @@ type Config struct {
 	// Specific to the alphabet trace provider
 	AlphabetTrace string // String for the AlphabetTraceProvider
 
+	// Specific to the output cannon trace type
+	RollupRpc string
+
 	// Specific to the cannon trace provider
 	CannonBin              string // Path to the cannon executable to run when generating trace data
 	CannonServer           string // Path to the op-program executable that provides the pre-image oracle server
@@ -167,7 +172,12 @@ func (c Config) Check() error {
 	if c.MaxConcurrency == 0 {
 		return ErrMaxConcurrencyZero
 	}
-	if c.TraceType == TraceTypeCannon {
+	if c.TraceType == TraceTypeOutputCannon {
+		if c.RollupRpc == "" {
+			return ErrMissingRollupRpc
+		}
+	}
+	if c.TraceType == TraceTypeCannon || c.TraceType == TraceTypeOutputCannon {
 		if c.CannonBin == "" {
 			return ErrMissingCannonBin
 		}

op-challenger/config/config_test.go

@@ -20,6 +20,7 @@ var (
 	validCannonAbsolutPreState = "pre.json"
 	validDatadir               = "/tmp/data"
 	validCannonL2              = "http://localhost:9545"
+	validRollupRpc             = "http://localhost:8555"
 	agreeWithProposedOutput    = true
 )
 
@@ -28,13 +29,16 @@ func validConfig(traceType TraceType) Config {
 	switch traceType {
 	case TraceTypeAlphabet:
 		cfg.AlphabetTrace = validAlphabetTrace
-	case TraceTypeCannon:
+	case TraceTypeCannon, TraceTypeOutputCannon:
 		cfg.CannonBin = validCannonBin
 		cfg.CannonServer = validCannonOpProgramBin
 		cfg.CannonAbsolutePreState = validCannonAbsolutPreState
 		cfg.CannonL2 = validCannonL2
 		cfg.CannonNetwork = validCannonNetwork
 	}
+	if traceType == TraceTypeOutputCannon {
+		cfg.RollupRpc = validRollupRpc
+	}
 	return cfg
 }
 
@@ -125,6 +129,12 @@ func TestHttpPollInterval(t *testing.T) {
 	})
 }
 
+func TestRollupRpcRequired(t *testing.T) {
+	config := validConfig(TraceTypeOutputCannon)
+	config.RollupRpc = ""
+	require.ErrorIs(t, config.Check(), ErrMissingRollupRpc)
+}
+
 func TestCannonL2Required(t *testing.T) {
 	config := validConfig(TraceTypeCannon)
 	config.CannonL2 = ""

op-challenger/flags/flags.go

@@ -76,14 +76,22 @@ var (
 		EnvVars: prefixEnvVars("HTTP_POLL_INTERVAL"),
 		Value:   config.DefaultPollInterval,
 	}
+	RollupRpcFlag = &cli.StringFlag{
+		Name:    "rollup-rpc",
+		Usage:   "HTTP provider URL for the rollup node",
+		EnvVars: prefixEnvVars("ROLLUP_RPC"),
+	}
 	AlphabetFlag = &cli.StringFlag{
 		Name:    "alphabet",
 		Usage:   "Correct Alphabet Trace (alphabet trace type only)",
 		EnvVars: prefixEnvVars("ALPHABET"),
 	}
 	CannonNetworkFlag = &cli.StringFlag{
-		Name:    "cannon-network",
-		Usage:   fmt.Sprintf("Predefined network selection. Available networks: %s (cannon trace type only)", strings.Join(chaincfg.AvailableNetworks(), ", ")),
+		Name: "cannon-network",
+		Usage: fmt.Sprintf(
+			"Predefined network selection. Available networks: %s (cannon trace type only)",
+			strings.Join(chaincfg.AvailableNetworks(), ", "),
+		),
 		EnvVars: prefixEnvVars("CANNON_NETWORK"),
 	}
 	CannonRollupConfigFlag = &cli.StringFlag{
@@ -149,6 +157,7 @@ var requiredFlags = []cli.Flag{
 var optionalFlags = []cli.Flag{
 	MaxConcurrencyFlag,
 	HTTPPollInterval,
+	RollupRpcFlag,
 	AlphabetFlag,
 	GameAllowlistFlag,
 	CannonNetworkFlag,
@@ -175,6 +184,32 @@ func init() {
 // Flags contains the list of configuration options available to the binary.
 var Flags []cli.Flag
 
+func CheckCannonFlags(ctx *cli.Context) error {
+	if !ctx.IsSet(CannonNetworkFlag.Name) &&
+		!(ctx.IsSet(CannonRollupConfigFlag.Name) && ctx.IsSet(CannonL2GenesisFlag.Name)) {
+		return fmt.Errorf("flag %v or %v and %v is required",
+			CannonNetworkFlag.Name, CannonRollupConfigFlag.Name, CannonL2GenesisFlag.Name)
+	}
+	if ctx.IsSet(CannonNetworkFlag.Name) &&
+		(ctx.IsSet(CannonRollupConfigFlag.Name) || ctx.IsSet(CannonL2GenesisFlag.Name)) {
+		return fmt.Errorf("flag %v can not be used with %v and %v",
+			CannonNetworkFlag.Name, CannonRollupConfigFlag.Name, CannonL2GenesisFlag.Name)
+	}
+	if !ctx.IsSet(CannonBinFlag.Name) {
+		return fmt.Errorf("flag %s is required", CannonBinFlag.Name)
+	}
+	if !ctx.IsSet(CannonServerFlag.Name) {
+		return fmt.Errorf("flag %s is required", CannonServerFlag.Name)
+	}
+	if !ctx.IsSet(CannonPreStateFlag.Name) {
+		return fmt.Errorf("flag %s is required", CannonPreStateFlag.Name)
+	}
+	if !ctx.IsSet(CannonL2Flag.Name) {
+		return fmt.Errorf("flag %s is required", CannonL2Flag.Name)
+	}
+	return nil
+}
+
 func CheckRequired(ctx *cli.Context) error {
 	for _, f := range requiredFlags {
 		if !ctx.IsSet(f.Names()[0]) {
@@ -184,32 +219,20 @@ func CheckRequired(ctx *cli.Context) error {
 	gameType := config.TraceType(strings.ToLower(ctx.String(TraceTypeFlag.Name)))
 	switch gameType {
 	case config.TraceTypeCannon:
-		if !ctx.IsSet(CannonNetworkFlag.Name) &&
-			!(ctx.IsSet(CannonRollupConfigFlag.Name) && ctx.IsSet(CannonL2GenesisFlag.Name)) {
-			return fmt.Errorf("flag %v or %v and %v is required",
-				CannonNetworkFlag.Name, CannonRollupConfigFlag.Name, CannonL2GenesisFlag.Name)
-		}
-		if ctx.IsSet(CannonNetworkFlag.Name) &&
-			(ctx.IsSet(CannonRollupConfigFlag.Name) || ctx.IsSet(CannonL2GenesisFlag.Name)) {
-			return fmt.Errorf("flag %v can not be used with %v and %v",
-				CannonNetworkFlag.Name, CannonRollupConfigFlag.Name, CannonL2GenesisFlag.Name)
-		}
-		if !ctx.IsSet(CannonBinFlag.Name) {
-			return fmt.Errorf("flag %s is required", CannonBinFlag.Name)
-		}
-		if !ctx.IsSet(CannonServerFlag.Name) {
-			return fmt.Errorf("flag %s is required", CannonServerFlag.Name)
-		}
-		if !ctx.IsSet(CannonPreStateFlag.Name) {
-			return fmt.Errorf("flag %s is required", CannonPreStateFlag.Name)
-		}
-		if !ctx.IsSet(CannonL2Flag.Name) {
-			return fmt.Errorf("flag %s is required", CannonL2Flag.Name)
+		if err := CheckCannonFlags(ctx); err != nil {
+			return err
 		}
 	case config.TraceTypeAlphabet:
 		if !ctx.IsSet(AlphabetFlag.Name) {
 			return fmt.Errorf("flag %s is required", "alphabet")
 		}
+	case config.TraceTypeOutputCannon:
+		if err := CheckCannonFlags(ctx); err != nil {
+			return err
+		}
+		if !ctx.IsSet(RollupRpcFlag.Name) {
+			return fmt.Errorf("flag %s is required", RollupRpcFlag.Name)
+		}
 	default:
 		return fmt.Errorf("invalid trace type. must be one of %v", config.TraceTypes)
 	}
@@ -255,6 +278,7 @@ func NewConfigFromCLI(ctx *cli.Context) (*config.Config, error) {
 		GameWindow:              ctx.Duration(GameWindowFlag.Name),
 		MaxConcurrency:          maxConcurrency,
 		PollInterval:            ctx.Duration(HTTPPollInterval.Name),
+		RollupRpc:               ctx.String(RollupRpcFlag.Name),
 		AlphabetTrace:           ctx.String(AlphabetFlag.Name),
 		CannonNetwork:           ctx.String(CannonNetworkFlag.Name),
 		CannonRollupConfigPath:  ctx.String(CannonRollupConfigFlag.Name),

op-challenger/game/fault/agent.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"sync"
 
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/solver"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
@@ -18,6 +19,8 @@ import (
 type Responder interface {
 	CallResolve(ctx context.Context) (gameTypes.GameStatus, error)
 	Resolve(ctx context.Context) error
+	CallResolveClaim(ctx context.Context, claimIdx uint64) error
+	ResolveClaim(ctx context.Context, claimIdx uint64) error
 	PerformAction(ctx context.Context, action types.Action) error
 }
 
@@ -27,6 +30,7 @@ type ClaimLoader interface {
 
 type Agent struct {
 	metrics                 metrics.Metricer
+	fdgAddr                 common.Address
 	solver                  *solver.GameSolver
 	loader                  ClaimLoader
 	responder               Responder
@@ -36,9 +40,10 @@ type Agent struct {
 	log                     log.Logger
 }
 
-func NewAgent(m metrics.Metricer, loader ClaimLoader, maxDepth int, trace types.TraceProvider, responder Responder, updater types.OracleUpdater, agreeWithProposedOutput bool, log log.Logger) *Agent {
+func NewAgent(m metrics.Metricer, addr common.Address, loader ClaimLoader, maxDepth int, trace types.TraceProvider, responder Responder, updater types.OracleUpdater, agreeWithProposedOutput bool, log log.Logger) *Agent {
 	return &Agent{
 		metrics:                 m,
+		fdgAddr:                 addr,
 		solver:                  solver.NewGameSolver(maxDepth, trace),
 		loader:                  loader,
 		responder:               responder,
@@ -112,6 +117,10 @@ func (a *Agent) shouldResolve(status gameTypes.GameStatus) bool {
 // tryResolve resolves the game if it is in a winning state
 // Returns true if the game is resolvable (regardless of whether it was actually resolved)
 func (a *Agent) tryResolve(ctx context.Context) bool {
+	if err := a.resolveClaims(ctx); err != nil {
+		a.log.Error("Failed to resolve claims", "err", err)
+		return false
+	}
 	status, err := a.responder.CallResolve(ctx)
 	if err != nil || status == gameTypes.GameStatusInProgress {
 		return false
@@ -126,6 +135,60 @@ func (a *Agent) tryResolve(ctx context.Context) bool {
 	return true
 }
 
+var errNoResolvableClaims = errors.New("no resolvable claims")
+
+func (a *Agent) tryResolveClaims(ctx context.Context) error {
+	claims, err := a.loader.FetchClaims(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to fetch claims: %w", err)
+	}
+	if len(claims) == 0 {
+		return errNoResolvableClaims
+	}
+
+	var resolvableClaims []int64
+	for _, claim := range claims {
+		a.log.Debug("checking if claim is resolvable", "claimIdx", claim.ContractIndex)
+		if err := a.responder.CallResolveClaim(ctx, uint64(claim.ContractIndex)); err == nil {
+			a.log.Info("Resolving claim", "claimIdx", claim.ContractIndex)
+			resolvableClaims = append(resolvableClaims, int64(claim.ContractIndex))
+		}
+	}
+	a.log.Info("Resolving claims", "numClaims", len(resolvableClaims))
+	if len(resolvableClaims) == 0 {
+		return errNoResolvableClaims
+	}
+
+	var wg sync.WaitGroup
+	wg.Add(len(resolvableClaims))
+	for _, claimIdx := range resolvableClaims {
+		claimIdx := claimIdx
+		go func() {
+			defer wg.Done()
+			err := a.responder.ResolveClaim(ctx, uint64(claimIdx))
+			if err != nil {
+				a.log.Error("Failed to resolve claim", "err", err)
+			}
+		}()
+	}
+	wg.Wait()
+	return nil
+}
+
+func (a *Agent) resolveClaims(ctx context.Context) error {
+	for {
+		err := a.tryResolveClaims(ctx)
+		switch err {
+		case errNoResolvableClaims:
+			return nil
+		case nil:
+			continue
+		default:
+			return err
+		}
+	}
+}
+
 // newGameFromContracts initializes a new game state from the state in the contract
 func (a *Agent) newGameFromContracts(ctx context.Context) (types.Game, error) {
 	claims, err := a.loader.FetchClaims(ctx)
@@ -135,6 +198,7 @@ func (a *Agent) newGameFromContracts(ctx context.Context) (types.Game, error) {
 	if len(claims) == 0 {
 		return nil, errors.New("no claims")
 	}
+	a.metrics.RecordGameClaimCount(a.fdgAddr.String(), len(claims))
 	game := types.NewGameState(a.agreeWithProposedOutput, claims[0], uint64(a.maxDepth))
 	if err := game.PutAll(claims[1:]); err != nil {
 		return nil, fmt.Errorf("failed to load claims into the local state: %w", err)

op-challenger/game/fault/agent_test.go

@@ -10,10 +10,11 @@ import (
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
 	gameTypes "github.com/ethereum-optimism/optimism/op-challenger/game/types"
 	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
+	"github.com/ethereum-optimism/optimism/op-node/testlog"
+
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/stretchr/testify/require"
-
-	"github.com/ethereum-optimism/optimism/op-node/testlog"
 )
 
 // TestShouldResolve tests the resolution logic.
@@ -77,7 +78,7 @@ func TestDoNotMakeMovesWhenGameIsResolvable(t *testing.T) {
 			require.NoError(t, agent.Act(ctx))
 
 			require.Equal(t, 1, responder.callResolveCount, "should check if game is resolvable")
-			require.Zero(t, claimLoader.callCount, "should not fetch claims for resolvable game")
+			require.Equal(t, 1, claimLoader.callCount, "should fetch claims once for resolveClaim")
 
 			if test.shouldResolve {
 				require.EqualValues(t, 1, responder.resolveCount, "should resolve winning game")
@@ -92,6 +93,7 @@ func TestLoadClaimsWhenGameNotResolvable(t *testing.T) {
 	// Checks that if the game isn't resolvable, that the agent continues on to start checking claims
 	agent, claimLoader, responder := setupTestAgent(t, false)
 	responder.callResolveErr = errors.New("game is not resolvable")
+	responder.callResolveClaimErr = errors.New("claim is not resolvable")
 	depth := 4
 	claimBuilder := test.NewClaimBuilder(t, depth, alphabet.NewTraceProvider("abcdefg", uint64(depth)))
 
@@ -101,17 +103,20 @@ func TestLoadClaimsWhenGameNotResolvable(t *testing.T) {
 
 	require.NoError(t, agent.Act(context.Background()))
 
-	require.EqualValues(t, 1, claimLoader.callCount, "should load claims for unresolvable game")
+	require.EqualValues(t, 2, claimLoader.callCount, "should load claims for unresolvable game")
+	require.EqualValues(t, responder.callResolveClaimCount, 1, "should check if claim is resolvable")
+	require.Zero(t, responder.resolveClaimCount, "should not send resolveClaim")
 }
 
 func setupTestAgent(t *testing.T, agreeWithProposedOutput bool) (*Agent, *stubClaimLoader, *stubResponder) {
 	logger := testlog.Logger(t, log.LvlInfo)
 	claimLoader := &stubClaimLoader{}
+	addr := common.HexToAddress("0x1234")
 	depth := 4
 	trace := alphabet.NewTraceProvider("abcd", uint64(depth))
 	responder := &stubResponder{}
 	updater := &stubUpdater{}
-	agent := NewAgent(metrics.NoopMetrics, claimLoader, depth, trace, responder, updater, agreeWithProposedOutput, logger)
+	agent := NewAgent(metrics.NoopMetrics, addr, claimLoader, depth, trace, responder, updater, agreeWithProposedOutput, logger)
 	return agent, claimLoader, responder
 }
 
@@ -132,6 +137,10 @@ type stubResponder struct {
 
 	resolveCount int
 	resolveErr   error
+
+	callResolveClaimCount int
+	callResolveClaimErr   error
+	resolveClaimCount     int
 }
 
 func (s *stubResponder) CallResolve(ctx context.Context) (gameTypes.GameStatus, error) {
@@ -144,8 +153,18 @@ func (s *stubResponder) Resolve(ctx context.Context) error {
 	return s.resolveErr
 }
 
+func (s *stubResponder) CallResolveClaim(ctx context.Context, clainIdx uint64) error {
+	s.callResolveClaimCount++
+	return s.callResolveClaimErr
+}
+
+func (s *stubResponder) ResolveClaim(ctx context.Context, clainIdx uint64) error {
+	s.resolveClaimCount++
+	return nil
+}
+
 func (s *stubResponder) PerformAction(ctx context.Context, response types.Action) error {
-	panic("Not implemented")
+	return nil
 }
 
 type stubUpdater struct {

op-challenger/game/fault/player.go

@@ -106,7 +106,7 @@ func NewGamePlayer(
 	}
 
 	return &GamePlayer{
-		act:                     NewAgent(m, loader, int(gameDepth), provider, responder, updater, cfg.AgreeWithProposedOutput, logger).Act,
+		act:                     NewAgent(m, addr, loader, int(gameDepth), provider, responder, updater, cfg.AgreeWithProposedOutput, logger).Act,
 		agreeWithProposedOutput: cfg.AgreeWithProposedOutput,
 		loader:                  loader,
 		logger:                  logger,
@@ -114,6 +114,10 @@ func NewGamePlayer(
 	}, nil
 }
 
+func (g *GamePlayer) Status() gameTypes.GameStatus {
+	return g.status
+}
+
 func (g *GamePlayer) ProgressGame(ctx context.Context) gameTypes.GameStatus {
 	if g.status != gameTypes.GameStatusInProgress {
 		// Game is already complete so don't try to perform further actions.

op-challenger/game/fault/responder/responder.go

@@ -94,6 +94,34 @@ func (r *FaultResponder) Resolve(ctx context.Context) error {
 	return r.sendTxAndWait(ctx, txData)
 }
 
+// buildResolveClaimData creates the transaction data for the ResolveClaim function.
+func (r *FaultResponder) buildResolveClaimData(ctx context.Context, claimIdx uint64) ([]byte, error) {
+	return r.fdgAbi.Pack("resolveClaim", big.NewInt(int64(claimIdx)))
+}
+
+// CallResolveClaim determines if the resolveClaim function on the fault dispute game contract
+// would succeed.
+func (r *FaultResponder) CallResolveClaim(ctx context.Context, claimIdx uint64) error {
+	txData, err := r.buildResolveClaimData(ctx, claimIdx)
+	if err != nil {
+		return err
+	}
+	_, err = r.txMgr.Call(ctx, ethereum.CallMsg{
+		To:   &r.fdgAddr,
+		Data: txData,
+	}, nil)
+	return err
+}
+
+// ResolveClaim executes a resolveClaim transaction to resolve a fault dispute game.
+func (r *FaultResponder) ResolveClaim(ctx context.Context, claimIdx uint64) error {
+	txData, err := r.buildResolveClaimData(ctx, claimIdx)
+	if err != nil {
+		return err
+	}
+	return r.sendTxAndWait(ctx, txData)
+}
+
 func (r *FaultResponder) PerformAction(ctx context.Context, action types.Action) error {
 	var txData []byte
 	var err error

op-challenger/game/fault/responder/responder_test.go

@@ -73,6 +73,40 @@ func TestResolve(t *testing.T) {
 	})
 }
 
+func TestCallResolveClaim(t *testing.T) {
+	t.Run("SendFails", func(t *testing.T) {
+		responder, mockTxMgr := newTestFaultResponder(t)
+		mockTxMgr.callFails = true
+		err := responder.CallResolveClaim(context.Background(), 0)
+		require.ErrorIs(t, err, mockCallError)
+		require.Equal(t, 0, mockTxMgr.calls)
+	})
+
+	t.Run("Success", func(t *testing.T) {
+		responder, mockTxMgr := newTestFaultResponder(t)
+		err := responder.CallResolveClaim(context.Background(), 0)
+		require.NoError(t, err)
+		require.Equal(t, 1, mockTxMgr.calls)
+	})
+}
+
+func TestResolveClaim(t *testing.T) {
+	t.Run("SendFails", func(t *testing.T) {
+		responder, mockTxMgr := newTestFaultResponder(t)
+		mockTxMgr.sendFails = true
+		err := responder.ResolveClaim(context.Background(), 0)
+		require.ErrorIs(t, err, mockSendError)
+		require.Equal(t, 0, mockTxMgr.sends)
+	})
+
+	t.Run("Success", func(t *testing.T) {
+		responder, mockTxMgr := newTestFaultResponder(t)
+		err := responder.ResolveClaim(context.Background(), 0)
+		require.NoError(t, err)
+		require.Equal(t, 1, mockTxMgr.sends)
+	})
+}
+
 // TestRespond tests the [Responder.Respond] method.
 func TestPerformAction(t *testing.T) {
 	t.Run("send fails", func(t *testing.T) {

op-challenger/game/fault/solver/game_solver.go

@@ -48,7 +48,10 @@ func (s *GameSolver) calculateStep(ctx context.Context, game types.Game, claim t
 	if game.AgreeWithClaimLevel(claim) {
 		return nil, nil
 	}
-	step, err := s.claimSolver.AttemptStep(ctx, claim, game.AgreeWithClaimLevel(claim))
+	step, err := s.claimSolver.AttemptStep(ctx, game, claim)
+	if err == ErrStepIgnoreInvalidPath {
+		return nil, nil
+	}
 	if err != nil {
 		return nil, err
 	}
@@ -63,11 +66,14 @@ func (s *GameSolver) calculateStep(ctx context.Context, game types.Game, claim t
 }
 
 func (s *GameSolver) calculateMove(ctx context.Context, game types.Game, claim types.Claim) (*types.Action, error) {
-	move, err := s.claimSolver.NextMove(ctx, claim, game.AgreeWithClaimLevel(claim))
+	if game.AgreeWithClaimLevel(claim) {
+		return nil, nil
+	}
+	move, err := s.claimSolver.NextMove(ctx, claim, game)
 	if err != nil {
 		return nil, fmt.Errorf("failed to calculate next move for claim index %v: %w", claim.ContractIndex, err)
 	}
-	if move == nil || game.IsDuplicate(move.ClaimData) {
+	if move == nil || game.IsDuplicate(*move) {
 		return nil, nil
 	}
 	return &types.Action{

op-challenger/game/fault/solver/game_solver_test.go

@@ -48,7 +48,6 @@ func TestCalculateNextActions(t *testing.T) {
 			rootClaimCorrect:    true,
 			setupGame:           func(builder *faulttest.GameBuilder) {},
 		},
-
 		{
 			name:                "DoNotPerformDuplicateMoves",
 			agreeWithOutputRoot: true,
@@ -93,16 +92,15 @@ func TestCalculateNextActions(t *testing.T) {
 				maliciousStateHash := common.Hash{0x01, 0xaa}
 
 				// Dishonest actor counters their own claims to set up a situation with an invalid prestate
-				// The honest actor should attack all claims that support the root claim (disagree with the output root)
-				builder.Seq().ExpectAttack(). // This expected action is the winning move.
-								Attack(maliciousStateHash).
-								Defend(maliciousStateHash).ExpectAttack().
-								Attack(maliciousStateHash).
-								Attack(maliciousStateHash).ExpectStepAttack()
-
-				// The attempt to step against our malicious leaf node will fail because the pre-state won't match our
-				// malicious state hash. However, it is the very first expected action, attacking the root claim with
-				// the correct hash that wins the game since it will be the left-most uncountered claim.
+				// The honest actor should ignore path created by the dishonest actor, only supporting its own attack on the root claim
+				honestMove := builder.Seq().AttackCorrect() // This expected action is the winning move.
+				dishonestMove := honestMove.Attack(maliciousStateHash)
+				// The expected action by the honest actor
+				dishonestMove.ExpectAttack()
+				// The honest actor will ignore this poisoned path
+				dishonestMove.
+					Defend(maliciousStateHash).
+					Attack(maliciousStateHash)
 			},
 		},
 	}

op-challenger/game/fault/solver/rules.go

@@ -13,7 +13,6 @@ var rules = []actionRule{
 	parentMustExist,
 	onlyStepAtMaxDepth,
 	onlyMoveBeforeMaxDepth,
-	onlyCounterClaimsAtDisagreeingLevels,
 	doNotDuplicateExistingMoves,
 	doNotDefendRootClaim,
 }
@@ -57,20 +56,12 @@ func onlyMoveBeforeMaxDepth(game types.Game, action types.Action) error {
 	return nil
 }
 
-func onlyCounterClaimsAtDisagreeingLevels(game types.Game, action types.Action) error {
-	parentClaim := game.Claims()[action.ParentIdx]
-	if game.AgreeWithClaimLevel(parentClaim) {
-		return fmt.Errorf("countering a claim at depth %v that supports our view of the root", parentClaim.Position.Depth())
-	}
-	return nil
-}
-
 func doNotDuplicateExistingMoves(game types.Game, action types.Action) error {
 	newClaimData := types.ClaimData{
 		Value:    action.Value,
 		Position: resultingPosition(game, action),
 	}
-	if game.IsDuplicate(newClaimData) {
+	if game.IsDuplicate(types.Claim{ClaimData: newClaimData, ParentContractIndex: action.ParentIdx}) {
 		return fmt.Errorf("creating duplicate claim at %v with value %v", newClaimData.Position.ToGIndex(), newClaimData.Value)
 	}
 	return nil

op-challenger/game/fault/solver/solver.go

@@ -11,8 +11,9 @@ import (
 )
 
 var (
-	ErrStepNonLeafNode = errors.New("cannot step on non-leaf claims")
-	ErrStepAgreedClaim = errors.New("cannot step on claims we agree with")
+	ErrStepNonLeafNode       = errors.New("cannot step on non-leaf claims")
+	ErrStepAgreedClaim       = errors.New("cannot step on claims we agree with")
+	ErrStepIgnoreInvalidPath = errors.New("cannot step on claims that dispute invalid paths")
 )
 
 // claimSolver uses a [TraceProvider] to determine the moves to make in a dispute game.
@@ -30,10 +31,7 @@ func newClaimSolver(gameDepth int, traceProvider types.TraceProvider) *claimSolv
 }
 
 // NextMove returns the next move to make given the current state of the game.
-func (s *claimSolver) NextMove(ctx context.Context, claim types.Claim, agreeWithClaimLevel bool) (*types.Claim, error) {
-	if agreeWithClaimLevel {
-		return nil, nil
-	}
+func (s *claimSolver) NextMove(ctx context.Context, claim types.Claim, game types.Game) (*types.Claim, error) {
 	if claim.Depth() == s.gameDepth {
 		return nil, types.ErrGameDepthReached
 	}
@@ -41,6 +39,24 @@ func (s *claimSolver) NextMove(ctx context.Context, claim types.Claim, agreeWith
 	if err != nil {
 		return nil, err
 	}
+
+	// Before challenging this claim, first check that the move wasn't warranted.
+	// If the parent claim is on a dishonest path, then we would have moved against it anyways. So we don't move.
+	// Avoiding dishonest paths ensures that there's always a valid claim available to support ours during step.
+	if !claim.IsRoot() {
+		parent, err := game.GetParent(claim)
+		if err != nil {
+			return nil, err
+		}
+		agreeWithParent, err := s.agreeWithClaimPath(ctx, game, parent)
+		if err != nil {
+			return nil, err
+		}
+		if !agreeWithParent {
+			return nil, nil
+		}
+	}
+
 	if agree {
 		return s.defend(ctx, claim)
 	} else {
@@ -58,13 +74,25 @@ type StepData struct {
 
 // AttemptStep determines what step should occur for a given leaf claim.
 // An error will be returned if the claim is not at the max depth.
-func (s *claimSolver) AttemptStep(ctx context.Context, claim types.Claim, agreeWithClaimLevel bool) (StepData, error) {
+// Returns ErrStepIgnoreInvalidPath if the claim disputes an invalid path
+func (s *claimSolver) AttemptStep(ctx context.Context, game types.Game, claim types.Claim) (StepData, error) {
 	if claim.Depth() != s.gameDepth {
 		return StepData{}, ErrStepNonLeafNode
 	}
-	if agreeWithClaimLevel {
-		return StepData{}, ErrStepAgreedClaim
+
+	// Step only on claims that dispute a valid path
+	parent, err := game.GetParent(claim)
+	if err != nil {
+		return StepData{}, err
 	}
+	parentValid, err := s.agreeWithClaimPath(ctx, game, parent)
+	if err != nil {
+		return StepData{}, err
+	}
+	if !parentValid {
+		return StepData{}, ErrStepIgnoreInvalidPath
+	}
+
 	claimCorrect, err := s.agreeWithClaim(ctx, claim.ClaimData)
 	if err != nil {
 		return StepData{}, err
@@ -142,3 +170,26 @@ func (s *claimSolver) traceAtPosition(ctx context.Context, p types.Position) (co
 	hash, err := s.trace.Get(ctx, index)
 	return hash, err
 }
+
+// agreeWithClaimPath returns true if the every other claim in the path to root is correct according to the internal [TraceProvider].
+func (s *claimSolver) agreeWithClaimPath(ctx context.Context, game types.Game, claim types.Claim) (bool, error) {
+	agree, err := s.agreeWithClaim(ctx, claim.ClaimData)
+	if err != nil {
+		return false, err
+	}
+	if !agree {
+		return false, nil
+	}
+	if claim.IsRoot() || claim.Parent.IsRootPosition() {
+		return true, nil
+	}
+	parent, err := game.GetParent(claim)
+	if err != nil {
+		return false, err
+	}
+	grandParent, err := game.GetParent(parent)
+	if err != nil {
+		return false, err
+	}
+	return s.agreeWithClaimPath(ctx, game, grandParent)
+}

op-challenger/game/fault/test/claim_builder.go

@@ -79,12 +79,13 @@ func (c *ClaimBuilder) claim(idx uint64, correct bool) common.Hash {
 
 func (c *ClaimBuilder) CreateRootClaim(correct bool) types.Claim {
 	value := c.claim((1<<c.maxDepth)-1, correct)
-	return types.Claim{
+	claim := types.Claim{
 		ClaimData: types.ClaimData{
 			Value:    value,
 			Position: types.NewPosition(0, 0),
 		},
 	}
+	return claim
 }
 
 func (c *ClaimBuilder) CreateLeafClaim(traceIndex uint64, correct bool) types.Claim {

op-challenger/game/fault/types/game.go

@@ -23,8 +23,12 @@ type Game interface {
 	// Claims returns all of the claims in the game.
 	Claims() []Claim
 
-	// IsDuplicate returns true if the provided [Claim] already exists in the game state.
-	IsDuplicate(claim ClaimData) bool
+	// GetParent returns the parent of the provided claim.
+	GetParent(claim Claim) (Claim, error)
+
+	// IsDuplicate returns true if the provided [Claim] already exists in the game state
+	// referencing the same parent claim
+	IsDuplicate(claim Claim) bool
 
 	// AgreeWithClaimLevel returns if the game state agrees with the provided claim level.
 	AgreeWithClaimLevel(claim Claim) bool
@@ -32,32 +36,45 @@ type Game interface {
 	MaxDepth() uint64
 }
 
+type claimEntry struct {
+	ClaimData
+	ParentContractIndex int
+}
+
 type extendedClaim struct {
 	self     Claim
-	children []ClaimData
+	children []claimEntry
 }
 
 // gameState is a struct that represents the state of a dispute game.
 // The game state implements the [Game] interface.
 type gameState struct {
 	agreeWithProposedOutput bool
-	root                    ClaimData
-	claims                  map[ClaimData]*extendedClaim
-	depth                   uint64
+	root                    claimEntry
+	// contractIndicies maps a contract index to it's extended claim.
+	// This is used to perform O(1) parent lookups.
+	contractIndicies map[int]*extendedClaim
+	// claims maps a claim entry to it's extended claim.
+	claims map[claimEntry]*extendedClaim
+	depth  uint64
 }
 
 // NewGameState returns a new game state.
 // The provided [Claim] is used as the root node.
 func NewGameState(agreeWithProposedOutput bool, root Claim, depth uint64) *gameState {
-	claims := make(map[ClaimData]*extendedClaim)
-	claims[root.ClaimData] = &extendedClaim{
+	claims := make(map[claimEntry]*extendedClaim)
+	parents := make(map[int]*extendedClaim)
+	rootClaimEntry := makeClaimEntry(root)
+	claims[rootClaimEntry] = &extendedClaim{
 		self:     root,
-		children: make([]ClaimData, 0),
+		children: make([]claimEntry, 0),
 	}
+	parents[root.ContractIndex] = claims[rootClaimEntry]
 	return &gameState{
 		agreeWithProposedOutput: agreeWithProposedOutput,
-		root:                    root.ClaimData,
+		root:                    rootClaimEntry,
 		claims:                  claims,
+		contractIndicies:        parents,
 		depth:                   depth,
 	}
 }
@@ -87,29 +104,31 @@ func (g *gameState) PutAll(claims []Claim) error {
 
 // Put adds a claim into the game state.
 func (g *gameState) Put(claim Claim) error {
-	if claim.IsRoot() || g.IsDuplicate(claim.ClaimData) {
+	if claim.IsRoot() || g.IsDuplicate(claim) {
 		return ErrClaimExists
 	}
-	parent, ok := g.claims[claim.Parent]
-	if !ok {
+
+	parent := g.getParent(claim)
+	if parent == nil {
 		return errors.New("no parent claim")
-	} else {
-		parent.children = append(parent.children, claim.ClaimData)
 	}
-	g.claims[claim.ClaimData] = &extendedClaim{
+	parent.children = append(parent.children, makeClaimEntry(claim))
+	claimWithExtension := &extendedClaim{
 		self:     claim,
-		children: make([]ClaimData, 0),
+		children: make([]claimEntry, 0),
 	}
+	g.claims[makeClaimEntry(claim)] = claimWithExtension
+	g.contractIndicies[claim.ContractIndex] = claimWithExtension
 	return nil
 }
 
-func (g *gameState) IsDuplicate(claim ClaimData) bool {
-	_, ok := g.claims[claim]
+func (g *gameState) IsDuplicate(claim Claim) bool {
+	_, ok := g.claims[makeClaimEntry(claim)]
 	return ok
 }
 
 func (g *gameState) Claims() []Claim {
-	queue := []ClaimData{g.root}
+	queue := []claimEntry{g.root}
 	var out []Claim
 	for len(queue) > 0 {
 		item := queue[0]
@@ -124,17 +143,31 @@ func (g *gameState) MaxDepth() uint64 {
 	return g.depth
 }
 
-func (g *gameState) getChildren(c ClaimData) []ClaimData {
+func (g *gameState) getChildren(c claimEntry) []claimEntry {
 	return g.claims[c].children
 }
 
-func (g *gameState) getParent(claim Claim) (Claim, error) {
-	if claim.IsRoot() {
+func (g *gameState) GetParent(claim Claim) (Claim, error) {
+	parent := g.getParent(claim)
+	if parent == nil {
 		return Claim{}, ErrClaimNotFound
 	}
-	if parent, ok := g.claims[claim.Parent]; !ok {
-		return Claim{}, ErrClaimNotFound
-	} else {
-		return parent.self, nil
+	return parent.self, nil
+}
+
+func (g *gameState) getParent(claim Claim) *extendedClaim {
+	if claim.IsRoot() {
+		return nil
+	}
+	if parent, ok := g.contractIndicies[claim.ParentContractIndex]; ok {
+		return parent
+	}
+	return nil
+}
+
+func makeClaimEntry(claim Claim) claimEntry {
+	return claimEntry{
+		ClaimData:           claim.ClaimData,
+		ParentContractIndex: claim.ParentContractIndex,
 	}
 }

op-challenger/game/fault/types/game_test.go

@@ -24,14 +24,18 @@ func createTestClaims() (Claim, Claim, Claim, Claim) {
 			Value:    common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000364"),
 			Position: NewPosition(1, 0),
 		},
-		Parent: root.ClaimData,
+		Parent:              root.ClaimData,
+		ContractIndex:       1,
+		ParentContractIndex: 0,
 	}
 	middle := Claim{
 		ClaimData: ClaimData{
 			Value:    common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000578"),
 			Position: NewPosition(2, 2),
 		},
-		Parent: top.ClaimData,
+		Parent:              top.ClaimData,
+		ContractIndex:       2,
+		ParentContractIndex: 1,
 	}
 
 	bottom := Claim{
@@ -39,7 +43,9 @@ func createTestClaims() (Claim, Claim, Claim, Claim) {
 			Value:    common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000465"),
 			Position: NewPosition(3, 4),
 		},
-		Parent: middle.ClaimData,
+		Parent:              middle.ClaimData,
+		ContractIndex:       3,
+		ParentContractIndex: 2,
 	}
 
 	return root, top, middle, bottom
@@ -52,12 +58,12 @@ func TestIsDuplicate(t *testing.T) {
 	require.NoError(t, g.Put(top))
 
 	// Root + Top should be duplicates
-	require.True(t, g.IsDuplicate(root.ClaimData))
-	require.True(t, g.IsDuplicate(top.ClaimData))
+	require.True(t, g.IsDuplicate(root))
+	require.True(t, g.IsDuplicate(top))
 
 	// Middle + Bottom should not be a duplicate
-	require.False(t, g.IsDuplicate(middle.ClaimData))
-	require.False(t, g.IsDuplicate(bottom.ClaimData))
+	require.False(t, g.IsDuplicate(middle))
+	require.False(t, g.IsDuplicate(bottom))
 }
 
 // TestGame_Put_RootAlreadyExists tests the [Game.Put] method using a [gameState]
@@ -104,20 +110,20 @@ func TestGame_PutAll_ParentsAndChildren(t *testing.T) {
 	g := NewGameState(false, root, testMaxDepth)
 
 	// We should not be able to get the parent of the root claim.
-	parent, err := g.getParent(root)
+	parent, err := g.GetParent(root)
 	require.ErrorIs(t, err, ErrClaimNotFound)
 	require.Equal(t, parent, Claim{})
 
 	// Put the rest of the claims in the state.
 	err = g.PutAll([]Claim{top, middle, bottom})
 	require.NoError(t, err)
-	parent, err = g.getParent(top)
+	parent, err = g.GetParent(top)
 	require.NoError(t, err)
 	require.Equal(t, parent, root)
-	parent, err = g.getParent(middle)
+	parent, err = g.GetParent(middle)
 	require.NoError(t, err)
 	require.Equal(t, parent, top)
-	parent, err = g.getParent(bottom)
+	parent, err = g.GetParent(bottom)
 	require.NoError(t, err)
 	require.Equal(t, parent, middle)
 }
@@ -145,28 +151,28 @@ func TestGame_Put_ParentsAndChildren(t *testing.T) {
 	g := NewGameState(false, root, testMaxDepth)
 
 	// We should not be able to get the parent of the root claim.
-	parent, err := g.getParent(root)
+	parent, err := g.GetParent(root)
 	require.ErrorIs(t, err, ErrClaimNotFound)
 	require.Equal(t, parent, Claim{})
 
 	// Put + Check Top
 	err = g.Put(top)
 	require.NoError(t, err)
-	parent, err = g.getParent(top)
+	parent, err = g.GetParent(top)
 	require.NoError(t, err)
 	require.Equal(t, parent, root)
 
 	// Put + Check Top Middle
 	err = g.Put(middle)
 	require.NoError(t, err)
-	parent, err = g.getParent(middle)
+	parent, err = g.GetParent(middle)
 	require.NoError(t, err)
 	require.Equal(t, parent, top)
 
 	// Put + Check Top Bottom
 	err = g.Put(bottom)
 	require.NoError(t, err)
-	parent, err = g.getParent(bottom)
+	parent, err = g.GetParent(bottom)
 	require.NoError(t, err)
 	require.Equal(t, parent, middle)
 }
@@ -194,27 +200,3 @@ func TestGame_ClaimPairs(t *testing.T) {
 	claims := g.Claims()
 	require.ElementsMatch(t, expected, claims)
 }
-
-func TestAgreeWithClaimLevelDisagreeWithOutput(t *testing.T) {
-	// Setup the game state.
-	root, top, middle, bottom := createTestClaims()
-	g := NewGameState(false, root, testMaxDepth)
-	require.NoError(t, g.PutAll([]Claim{top, middle, bottom}))
-
-	require.True(t, g.AgreeWithClaimLevel(root))
-	require.False(t, g.AgreeWithClaimLevel(top))
-	require.True(t, g.AgreeWithClaimLevel(middle))
-	require.False(t, g.AgreeWithClaimLevel(bottom))
-}
-
-func TestAgreeWithClaimLevelAgreeWithOutput(t *testing.T) {
-	// Setup the game state.
-	root, top, middle, bottom := createTestClaims()
-	g := NewGameState(true, root, testMaxDepth)
-	require.NoError(t, g.PutAll([]Claim{top, middle, bottom}))
-
-	require.False(t, g.AgreeWithClaimLevel(root))
-	require.True(t, g.AgreeWithClaimLevel(top))
-	require.False(t, g.AgreeWithClaimLevel(middle))
-	require.True(t, g.AgreeWithClaimLevel(bottom))
-}

op-challenger/game/scheduler/coordinator.go

@@ -109,9 +109,14 @@ func (c *coordinator) createJob(game common.Address) (*job, error) {
 			return nil, fmt.Errorf("failed to create game player: %w", err)
 		}
 		state.player = player
+		state.status = player.Status()
 	}
 	state.inflight = true
-	return &job{addr: game, player: state.player}, nil
+	if state.status != types.GameStatusInProgress {
+		c.logger.Debug("Not rescheduling resolved game", "game", game, "status", state.status)
+		return nil, nil
+	}
+	return &job{addr: game, player: state.player, status: state.status}, nil
 }
 
 func (c *coordinator) enqueueJob(ctx context.Context, j job) error {

op-challenger/game/scheduler/coordinator_test.go

@@ -150,7 +150,10 @@ func TestDeleteDataForResolvedGames(t *testing.T) {
 	gameAddrs := []common.Address{gameAddr1, gameAddr2, gameAddr3}
 	require.NoError(t, c.schedule(ctx, gameAddrs))
 
-	require.Len(t, workQueue, len(gameAddrs), "should schedule all games")
+	// The work queue should only contain jobs for games 1 and 2
+	// A resolved game should not be scheduled for an update.
+	// This makes the inflight game metric more robust.
+	require.Len(t, workQueue, 2, "should schedule all games")
 
 	// Game 1 progresses and is still in progress
 	// Game 2 progresses and is now resolved
@@ -249,6 +252,10 @@ func (g *stubGame) ProgressGame(_ context.Context) types.GameStatus {
 	return g.status
 }
 
+func (g *stubGame) Status() types.GameStatus {
+	return g.status
+}
+
 type createdGames struct {
 	t               *testing.T
 	createCompleted common.Address

op-challenger/game/scheduler/scheduler.go

@@ -15,11 +15,16 @@ type SchedulerMetricer interface {
 	RecordGamesStatus(inProgress, defenderWon, challengerWon int)
 	RecordGameUpdateScheduled()
 	RecordGameUpdateCompleted()
+	IncActiveExecutors()
+	DecActiveExecutors()
+	IncIdleExecutors()
+	DecIdleExecutors()
 }
 
 type Scheduler struct {
 	logger         log.Logger
 	coordinator    *coordinator
+	m              SchedulerMetricer
 	maxConcurrency uint
 	scheduleQueue  chan []common.Address
 	jobQueue       chan job
@@ -40,6 +45,7 @@ func NewScheduler(logger log.Logger, m SchedulerMetricer, disk DiskManager, maxC
 
 	return &Scheduler{
 		logger:         logger,
+		m:              m,
 		coordinator:    newCoordinator(logger, m, jobQueue, resultQueue, createPlayer, disk),
 		maxConcurrency: maxConcurrency,
 		scheduleQueue:  scheduleQueue,
@@ -48,13 +54,24 @@ func NewScheduler(logger log.Logger, m SchedulerMetricer, disk DiskManager, maxC
 	}
 }
 
+func (s *Scheduler) ThreadActive() {
+	s.m.IncActiveExecutors()
+	s.m.DecIdleExecutors()
+}
+
+func (s *Scheduler) ThreadIdle() {
+	s.m.IncIdleExecutors()
+	s.m.DecActiveExecutors()
+}
+
 func (s *Scheduler) Start(ctx context.Context) {
 	ctx, cancel := context.WithCancel(ctx)
 	s.cancel = cancel
 
 	for i := uint(0); i < s.maxConcurrency; i++ {
+		s.m.IncIdleExecutors()
 		s.wg.Add(1)
-		go progressGames(ctx, s.jobQueue, s.resultQueue, &s.wg)
+		go progressGames(ctx, s.jobQueue, s.resultQueue, &s.wg, s.ThreadActive, s.ThreadIdle)
 	}
 
 	s.wg.Add(1)

op-challenger/game/scheduler/types.go

@@ -10,6 +10,7 @@ import (
 
 type GamePlayer interface {
 	ProgressGame(ctx context.Context) types.GameStatus
+	Status() types.GameStatus
 }
 
 type DiskManager interface {

op-challenger/game/scheduler/worker.go

@@ -8,15 +8,17 @@ import (
 // progressGames accepts jobs from in channel, calls ProgressGame on the job.player and returns the job
 // with updated job.resolved via the out channel.
 // The loop exits when the ctx is done.  wg.Done() is called when the function returns.
-func progressGames(ctx context.Context, in <-chan job, out chan<- job, wg *sync.WaitGroup) {
+func progressGames(ctx context.Context, in <-chan job, out chan<- job, wg *sync.WaitGroup, threadActive, threadIdle func()) {
 	defer wg.Done()
 	for {
 		select {
 		case <-ctx.Done():
 			return
 		case j := <-in:
+			threadActive()
 			j.status = j.player.ProgressGame(ctx)
 			out <- j
+			threadIdle()
 		}
 	}
 }

op-challenger/game/scheduler/worker_test.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"github.com/ethereum-optimism/optimism/op-challenger/game/types"
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/wait"
 
 	"github.com/stretchr/testify/require"
 )
@@ -15,18 +16,32 @@ func TestWorkerShouldProcessJobsUntilContextDone(t *testing.T) {
 	in := make(chan job, 2)
 	out := make(chan job, 2)
 
+	ms := &metricSink{}
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	var wg sync.WaitGroup
 	wg.Add(1)
-	go progressGames(ctx, in, out, &wg)
+	go progressGames(ctx, in, out, &wg, ms.ThreadActive, ms.ThreadIdle)
 
 	in <- job{
 		player: &stubPlayer{status: types.GameStatusInProgress},
 	}
+	waitErr := wait.For(context.Background(), 100*time.Millisecond, func() (bool, error) {
+		return ms.activeCalls >= 1, nil
+	})
+	require.NoError(t, waitErr)
+	require.Equal(t, ms.activeCalls, 1)
+	require.Equal(t, ms.idleCalls, 1)
+
 	in <- job{
 		player: &stubPlayer{status: types.GameStatusDefenderWon},
 	}
+	waitErr = wait.For(context.Background(), 100*time.Millisecond, func() (bool, error) {
+		return ms.activeCalls >= 2, nil
+	})
+	require.NoError(t, waitErr)
+	require.Equal(t, ms.activeCalls, 2)
+	require.Equal(t, ms.idleCalls, 2)
 
 	result1 := readWithTimeout(t, out)
 	result2 := readWithTimeout(t, out)
@@ -39,6 +54,19 @@ func TestWorkerShouldProcessJobsUntilContextDone(t *testing.T) {
 	wg.Wait()
 }
 
+type metricSink struct {
+	activeCalls int
+	idleCalls   int
+}
+
+func (m *metricSink) ThreadActive() {
+	m.activeCalls++
+}
+
+func (m *metricSink) ThreadIdle() {
+	m.idleCalls++
+}
+
 type stubPlayer struct {
 	status types.GameStatus
 }
@@ -47,6 +75,10 @@ func (s *stubPlayer) ProgressGame(ctx context.Context) types.GameStatus {
 	return s.status
 }
 
+func (s *stubPlayer) Status() types.GameStatus {
+	return s.status
+}
+
 func readWithTimeout[T any](t *testing.T, ch <-chan T) T {
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()

op-challenger/metrics/metrics.go

@@ -25,10 +25,17 @@ type Metricer interface {
 	RecordGameMove()
 	RecordCannonExecutionTime(t float64)
 
+	RecordGameClaimCount(addr string, count int)
+
 	RecordGamesStatus(inProgress, defenderWon, challengerWon int)
 
 	RecordGameUpdateScheduled()
 	RecordGameUpdateCompleted()
+
+	IncActiveExecutors()
+	DecActiveExecutors()
+	IncIdleExecutors()
+	DecIdleExecutors()
 }
 
 type Metrics struct {
@@ -41,11 +48,15 @@ type Metrics struct {
 	info prometheus.GaugeVec
 	up   prometheus.Gauge
 
+	executors prometheus.GaugeVec
+
 	moves prometheus.Counter
 	steps prometheus.Counter
 
 	cannonExecutionTime prometheus.Histogram
 
+	gameClaimCount prometheus.GaugeVec
+
 	trackedGames  prometheus.GaugeVec
 	inflightGames prometheus.Gauge
 }
@@ -75,6 +86,13 @@ func NewMetrics() *Metrics {
 			Name:      "up",
 			Help:      "1 if the op-challenger has finished starting up",
 		}),
+		executors: *factory.NewGaugeVec(prometheus.GaugeOpts{
+			Namespace: Namespace,
+			Name:      "executors",
+			Help:      "Number of active and idle executors",
+		}, []string{
+			"status",
+		}),
 		moves: factory.NewCounter(prometheus.CounterOpts{
 			Namespace: Namespace,
 			Name:      "moves",
@@ -93,6 +111,13 @@ func NewMetrics() *Metrics {
 				[]float64{1.0, 10.0},
 				prometheus.ExponentialBuckets(30.0, 2.0, 14)...),
 		}),
+		gameClaimCount: *factory.NewGaugeVec(prometheus.GaugeOpts{
+			Namespace: Namespace,
+			Name:      "game_claim_count",
+			Help:      "Number of claims in the game",
+		}, []string{
+			"game_address",
+		}),
 		trackedGames: *factory.NewGaugeVec(prometheus.GaugeOpts{
 			Namespace: Namespace,
 			Name:      "tracked_games",
@@ -149,6 +174,26 @@ func (m *Metrics) RecordCannonExecutionTime(t float64) {
 	m.cannonExecutionTime.Observe(t)
 }
 
+func (m *Metrics) IncActiveExecutors() {
+	m.executors.WithLabelValues("active").Inc()
+}
+
+func (m *Metrics) DecActiveExecutors() {
+	m.executors.WithLabelValues("active").Dec()
+}
+
+func (m *Metrics) IncIdleExecutors() {
+	m.executors.WithLabelValues("idle").Inc()
+}
+
+func (m *Metrics) DecIdleExecutors() {
+	m.executors.WithLabelValues("idle").Dec()
+}
+
+func (m *Metrics) RecordGameClaimCount(addr string, count int) {
+	m.gameClaimCount.With(prometheus.Labels{"game_address": addr}).Set(float64(count))
+}
+
 func (m *Metrics) RecordGamesStatus(inProgress, defenderWon, challengerWon int) {
 	m.trackedGames.WithLabelValues("in_progress").Set(float64(inProgress))
 	m.trackedGames.WithLabelValues("defender_won").Set(float64(defenderWon))

op-challenger/metrics/noop.go

@@ -22,3 +22,10 @@ func (*NoopMetricsImpl) RecordGamesStatus(inProgress, defenderWon, challengerWon
 
 func (*NoopMetricsImpl) RecordGameUpdateScheduled() {}
 func (*NoopMetricsImpl) RecordGameUpdateCompleted() {}
+
+func (*NoopMetricsImpl) IncActiveExecutors() {}
+func (*NoopMetricsImpl) DecActiveExecutors() {}
+func (*NoopMetricsImpl) IncIdleExecutors()   {}
+func (*NoopMetricsImpl) DecIdleExecutors()   {}
+
+func (*NoopMetricsImpl) RecordGameClaimCount(addr string, count int) {}

op-e2e/e2eutils/challenger/helper.go

@@ -68,6 +68,12 @@ func WithAlphabet(alphabet string) Option {
 	}
 }
 
+func WithPollInterval(pollInterval time.Duration) Option {
+	return func(c *config.Config) {
+		c.PollInterval = pollInterval
+	}
+}
+
 func WithCannon(
 	t *testing.T,
 	rollupCfg *rollup.Config,
@@ -98,7 +104,7 @@ func WithCannon(
 }
 
 func NewChallenger(t *testing.T, ctx context.Context, l1Endpoint string, name string, options ...Option) *Helper {
-	log := testlog.Logger(t, log.LvlInfo).New("role", name)
+	log := testlog.Logger(t, log.LvlDebug).New("role", name)
 	log.Info("Creating challenger", "l1", l1Endpoint)
 	cfg := NewChallengerConfig(t, l1Endpoint, options...)
 

op-e2e/e2eutils/disputegame/alphabet_helper.go

@@ -4,6 +4,7 @@ import (
 	"context"
 
 	"github.com/ethereum-optimism/optimism/op-challenger/config"
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/alphabet"
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/challenger"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -33,3 +34,12 @@ func (g *AlphabetGameHelper) StartChallenger(ctx context.Context, l1Endpoint str
 	})
 	return c
 }
+
+func (g *AlphabetGameHelper) CreateHonestActor(ctx context.Context, alphabetTrace string, depth uint64) *HonestHelper {
+	return &HonestHelper{
+		t:            g.t,
+		require:      g.require,
+		game:         &g.FaultGameHelper,
+		correctTrace: alphabet.NewTraceProvider(alphabetTrace, depth),
+	}
+}

op-e2e/e2eutils/disputegame/game_helper.go

@@ -2,16 +2,19 @@ package disputegame
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"math/big"
 	"testing"
 	"time"
 
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/wait"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
+	gethtypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/stretchr/testify/require"
 )
@@ -130,6 +133,10 @@ func (g *FaultGameHelper) getClaim(ctx context.Context, claimIdx int64) Contract
 	return claimData
 }
 
+func (g *FaultGameHelper) GetClaimUnsafe(ctx context.Context, claimIdx int64) ContractClaim {
+	return g.getClaim(ctx, claimIdx)
+}
+
 func (g *FaultGameHelper) WaitForClaimAtDepth(ctx context.Context, depth int) {
 	g.waitForClaim(
 		ctx,
@@ -169,6 +176,12 @@ func (g *FaultGameHelper) Resolve(ctx context.Context) {
 	g.require.NoError(err)
 }
 
+func (g *FaultGameHelper) Status(ctx context.Context) Status {
+	status, err := g.game.Status(&bind.CallOpts{Context: ctx})
+	g.require.NoError(err)
+	return Status(status)
+}
+
 func (g *FaultGameHelper) WaitForGameStatus(ctx context.Context, expected Status) {
 	g.t.Logf("Waiting for game %v to have status %v", g.addr, expected)
 	timedCtx, cancel := context.WithTimeout(ctx, time.Minute)
@@ -186,6 +199,46 @@ func (g *FaultGameHelper) WaitForGameStatus(ctx context.Context, expected Status
 	g.require.NoErrorf(err, "wait for game status. Game state: \n%v", g.gameData(ctx))
 }
 
+func (g *FaultGameHelper) WaitForInactivity(ctx context.Context, numInactiveBlocks int, untilGameEnds bool) {
+	g.t.Logf("Waiting for game %v to have no activity for %v blocks", g.addr, numInactiveBlocks)
+	headCh := make(chan *gethtypes.Header, 100)
+	headSub, err := g.client.SubscribeNewHead(ctx, headCh)
+	g.require.NoError(err)
+	defer headSub.Unsubscribe()
+
+	var lastActiveBlock uint64
+	for {
+		if untilGameEnds && g.Status(ctx) != StatusInProgress {
+			break
+		}
+		select {
+		case head := <-headCh:
+			if lastActiveBlock == 0 {
+				lastActiveBlock = head.Number.Uint64()
+				continue
+			} else if lastActiveBlock+uint64(numInactiveBlocks) < head.Number.Uint64() {
+				return
+			}
+			block, err := g.client.BlockByNumber(ctx, head.Number)
+			g.require.NoError(err)
+			numActions := 0
+			for _, tx := range block.Transactions() {
+				if tx.To().Hex() == g.addr.Hex() {
+					numActions++
+				}
+			}
+			if numActions != 0 {
+				g.t.Logf("Game %v has %v actions in block %d. Resetting inactivity timeout", g.addr, numActions, block.NumberU64())
+				lastActiveBlock = head.Number.Uint64()
+			}
+		case err := <-headSub.Err():
+			g.require.NoError(err)
+		case <-ctx.Done():
+			g.require.Fail("Context canceled", ctx.Err())
+		}
+	}
+}
+
 // Mover is a function that either attacks or defends the claim at parentClaimIdx
 type Mover func(parentClaimIdx int64)
 
@@ -239,6 +292,21 @@ func (g *FaultGameHelper) ChallengeRootClaim(ctx context.Context, performMove Mo
 	attemptStep(maxDepth)
 }
 
+func (g *FaultGameHelper) WaitForNewClaim(ctx context.Context, checkPoint int64) (int64, error) {
+	timedCtx, cancel := context.WithTimeout(ctx, 2*time.Minute)
+	defer cancel()
+	var newClaimLen int64
+	err := wait.For(timedCtx, time.Second, func() (bool, error) {
+		actual, err := g.game.ClaimDataLen(&bind.CallOpts{Context: ctx})
+		if err != nil {
+			return false, err
+		}
+		newClaimLen = actual.Int64()
+		return actual.Cmp(big.NewInt(checkPoint)) > 0, nil
+	})
+	return newClaimLen, err
+}
+
 func (g *FaultGameHelper) Attack(ctx context.Context, claimIdx int64, claim common.Hash) {
 	tx, err := g.game.Attack(g.opts, big.NewInt(claimIdx), claim)
 	g.require.NoError(err, "Attack transaction did not send")
@@ -266,6 +334,33 @@ func (g *FaultGameHelper) StepFails(claimIdx int64, isAttack bool, stateData []b
 	g.require.Equal("0xfb4e40dd", errData.ErrorData(), "Revert reason should be abi encoded ValidStep()")
 }
 
+// ResolveClaim resolves a single subgame
+func (g *FaultGameHelper) ResolveClaim(ctx context.Context, claimIdx int64) {
+	tx, err := g.game.ResolveClaim(g.opts, big.NewInt(claimIdx))
+	g.require.NoError(err, "ResolveClaim transaction did not send")
+	_, err = wait.ForReceiptOK(ctx, g.client, tx.Hash())
+	g.require.NoError(err, "ResolveClaim transaction was not OK")
+}
+
+// ResolveAllClaims resolves all subgames
+// This function does not resolve the game. That's the responsibility of challengers
+func (g *FaultGameHelper) ResolveAllClaims(ctx context.Context) {
+	loader := fault.NewLoader(g.game)
+	claims, err := loader.FetchClaims(ctx)
+	g.require.NoError(err, "Failed to fetch claims")
+	subgames := make(map[int]bool)
+	for i := len(claims) - 1; i > 0; i-- {
+		subgames[claims[i].ParentContractIndex] = true
+		// Subgames containing only one node are implicitly resolved
+		// i.e. uncountered and claims at MAX_DEPTH
+		if !subgames[i] {
+			continue
+		}
+		g.ResolveClaim(ctx, int64(i))
+	}
+	g.ResolveClaim(ctx, 0)
+}
+
 func (g *FaultGameHelper) gameData(ctx context.Context) string {
 	opts := &bind.CallOpts{Context: ctx}
 	maxDepth := int(g.MaxDepth(ctx))
@@ -277,8 +372,8 @@ func (g *FaultGameHelper) gameData(ctx context.Context) string {
 		g.require.NoErrorf(err, "Fetch claim %v", i)
 
 		pos := types.NewPositionFromGIndex(claim.Position.Uint64())
-		info = info + fmt.Sprintf("%v - Position: %v, Depth: %v, IndexAtDepth: %v Trace Index: %v, Value: %v, Countered: %v\n",
-			i, claim.Position.Int64(), pos.Depth(), pos.IndexAtDepth(), pos.TraceIndex(maxDepth), common.Hash(claim.Claim).Hex(), claim.Countered)
+		info = info + fmt.Sprintf("%v - Position: %v, Depth: %v, IndexAtDepth: %v Trace Index: %v, Value: %v, Countered: %v, ParentIndex: %v\n",
+			i, claim.Position.Int64(), pos.Depth(), pos.IndexAtDepth(), pos.TraceIndex(maxDepth), common.Hash(claim.Claim).Hex(), claim.Countered, claim.ParentIndex)
 	}
 	status, err := g.game.Status(opts)
 	g.require.NoError(err, "Load game status")
@@ -288,3 +383,106 @@ func (g *FaultGameHelper) gameData(ctx context.Context) string {
 func (g *FaultGameHelper) LogGameData(ctx context.Context) {
 	g.t.Log(g.gameData(ctx))
 }
+
+type dishonestClaim struct {
+	ParentIndex int64
+	IsAttack    bool
+	Valid       bool
+}
+type DishonestHelper struct {
+	*FaultGameHelper
+	*HonestHelper
+	claims   map[dishonestClaim]bool
+	defender bool
+}
+
+func NewDishonestHelper(g *FaultGameHelper, correctTrace *HonestHelper, defender bool) *DishonestHelper {
+	return &DishonestHelper{g, correctTrace, make(map[dishonestClaim]bool), defender}
+}
+
+func (t *DishonestHelper) Attack(ctx context.Context, claimIndex int64) {
+	c := dishonestClaim{claimIndex, true, false}
+	if t.claims[c] {
+		return
+	}
+	t.claims[c] = true
+	t.FaultGameHelper.Attack(ctx, claimIndex, common.Hash{byte(claimIndex)})
+}
+
+func (t *DishonestHelper) Defend(ctx context.Context, claimIndex int64) {
+	c := dishonestClaim{claimIndex, false, false}
+	if t.claims[c] {
+		return
+	}
+	t.claims[c] = true
+	t.FaultGameHelper.Defend(ctx, claimIndex, common.Hash{byte(claimIndex)})
+}
+
+func (t *DishonestHelper) AttackCorrect(ctx context.Context, claimIndex int64) {
+	c := dishonestClaim{claimIndex, true, true}
+	if t.claims[c] {
+		return
+	}
+	t.claims[c] = true
+	t.HonestHelper.Attack(ctx, claimIndex)
+}
+
+func (t *DishonestHelper) DefendCorrect(ctx context.Context, claimIndex int64) {
+	c := dishonestClaim{claimIndex, false, true}
+	if t.claims[c] {
+		return
+	}
+	t.claims[c] = true
+	t.HonestHelper.Defend(ctx, claimIndex)
+}
+
+// ExhaustDishonestClaims makes all possible significant moves (mod honest challenger's) in a game.
+// It is very inefficient and should NOT be used on games with large depths
+func (d *DishonestHelper) ExhaustDishonestClaims(ctx context.Context) {
+	depth := d.MaxDepth(ctx)
+
+	move := func(claimIndex int64, claimData ContractClaim) {
+		// dishonest level, valid attack
+		// dishonest level, invalid attack
+		// dishonest level, valid defense
+		// dishonest level, invalid defense
+		// honest level, invalid attack
+		// honest level, invalid defense
+
+		pos := types.NewPositionFromGIndex(claimData.Position.Uint64())
+		if int64(pos.Depth()) == depth {
+			return
+		}
+
+		d.LogGameData(ctx)
+		d.FaultGameHelper.t.Logf("Dishonest moves against claimIndex %d", claimIndex)
+		agreeWithLevel := d.defender == (pos.Depth()%2 == 0)
+		if !agreeWithLevel {
+			d.AttackCorrect(ctx, claimIndex)
+			if claimIndex != 0 {
+				d.DefendCorrect(ctx, claimIndex)
+			}
+		}
+		d.Attack(ctx, claimIndex)
+		if claimIndex != 0 {
+			d.Defend(ctx, claimIndex)
+		}
+	}
+
+	var numClaimsSeen int64
+	for {
+		newCount, err := d.WaitForNewClaim(ctx, numClaimsSeen)
+		if errors.Is(err, context.DeadlineExceeded) {
+			// we assume that the honest challenger has stopped responding
+			// There's nothing to respond to.
+			break
+		}
+		d.FaultGameHelper.require.NoError(err)
+
+		for i := numClaimsSeen; i < newCount; i++ {
+			claimData := d.getClaim(ctx, numClaimsSeen)
+			move(numClaimsSeen, claimData)
+			numClaimsSeen++
+		}
+	}
+}

op-e2e/faultproof_test.go

@@ -3,7 +3,9 @@ package op_e2e
 import (
 	"context"
 	"testing"
+	"time"
 
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/challenger"
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/disputegame"
 	l2oo2 "github.com/ethereum-optimism/optimism/op-e2e/e2eutils/l2oo"
@@ -62,8 +64,12 @@ func TestMultipleCannonGames(t *testing.T) {
 	sys.TimeTravelClock.AdvanceTime(gameDuration)
 	require.NoError(t, wait.ForNextBlock(ctx, l1Client))
 
-	game1.WaitForGameStatus(ctx, disputegame.StatusChallengerWins)
-	game2.WaitForGameStatus(ctx, disputegame.StatusChallengerWins)
+	game1.WaitForInactivity(ctx, 10, true)
+	game2.WaitForInactivity(ctx, 10, true)
+	game1.LogGameData(ctx)
+	game2.LogGameData(ctx)
+	require.EqualValues(t, disputegame.StatusChallengerWins, game1.Status(ctx))
+	require.EqualValues(t, disputegame.StatusChallengerWins, game2.Status(ctx))
 
 	// Check that the game directories are removed
 	challenger.WaitForGameDataDeletion(ctx, game1, game2)
@@ -168,11 +174,72 @@ func TestChallengerCompleteDisputeGame(t *testing.T) {
 			sys.TimeTravelClock.AdvanceTime(gameDuration)
 			require.NoError(t, wait.ForNextBlock(ctx, l1Client))
 
-			game.WaitForGameStatus(ctx, test.expectedResult)
+			game.WaitForInactivity(ctx, 10, true)
+			game.LogGameData(ctx)
+			require.EqualValues(t, test.expectedResult, game.Status(ctx))
 		})
 	}
 }
 
+func TestChallengerCompleteExhaustiveDisputeGame(t *testing.T) {
+	InitParallel(t)
+
+	testCase := func(t *testing.T, isRootCorrect bool) {
+		ctx := context.Background()
+		sys, l1Client := startFaultDisputeSystem(t)
+		t.Cleanup(sys.Close)
+
+		disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys.cfg.L1Deployments, l1Client)
+		rootClaimedAlphabet := disputegame.CorrectAlphabet
+		if !isRootCorrect {
+			rootClaimedAlphabet = "abcdexyz"
+		}
+		game := disputeGameFactory.StartAlphabetGame(ctx, rootClaimedAlphabet)
+		require.NotNil(t, game)
+		gameDuration := game.GameDuration(ctx)
+
+		// Start honest challenger
+		game.StartChallenger(ctx, sys.NodeEndpoint("l1"), "Challenger",
+			challenger.WithAgreeProposedOutput(!isRootCorrect),
+			challenger.WithAlphabet(disputegame.CorrectAlphabet),
+			challenger.WithPrivKey(sys.cfg.Secrets.Alice),
+			// Ensures the challenger responds to all claims before test timeout
+			challenger.WithPollInterval(time.Millisecond*400),
+		)
+
+		// Start dishonest challenger
+		correctTrace := game.CreateHonestActor(ctx, disputegame.CorrectAlphabet, 4)
+		dishonestHelper := disputegame.NewDishonestHelper(&game.FaultGameHelper, correctTrace, !isRootCorrect)
+		dishonestHelper.ExhaustDishonestClaims(ctx)
+
+		// Wait until we've reached max depth before checking for inactivity
+		game.WaitForClaimAtDepth(ctx, int(game.MaxDepth(ctx)))
+
+		// Wait for 4 blocks of no challenger responses. The challenger may still be stepping on invalid claims at max depth
+		game.WaitForInactivity(ctx, 4, false)
+
+		sys.TimeTravelClock.AdvanceTime(gameDuration)
+		require.NoError(t, wait.ForNextBlock(ctx, l1Client))
+
+		expectedStatus := disputegame.StatusChallengerWins
+		if isRootCorrect {
+			expectedStatus = disputegame.StatusDefenderWins
+		}
+		game.WaitForInactivity(ctx, 10, true)
+		game.LogGameData(ctx)
+		require.EqualValues(t, expectedStatus, game.Status(ctx))
+	}
+
+	t.Run("RootCorrect", func(t *testing.T) {
+		InitParallel(t)
+		testCase(t, true)
+	})
+	t.Run("RootIncorrect", func(t *testing.T) {
+		InitParallel(t)
+		testCase(t, false)
+	})
+}
+
 func TestCannonDisputeGame(t *testing.T) {
 	InitParallel(t)
 
@@ -217,8 +284,9 @@ func TestCannonDisputeGame(t *testing.T) {
 			sys.TimeTravelClock.AdvanceTime(game.GameDuration(ctx))
 			require.NoError(t, wait.ForNextBlock(ctx, l1Client))
 
-			game.WaitForGameStatus(ctx, disputegame.StatusChallengerWins)
+			game.WaitForInactivity(ctx, 10, true)
 			game.LogGameData(ctx)
+			require.EqualValues(t, disputegame.StatusChallengerWins, game.Status(ctx))
 		})
 	}
 }
@@ -260,8 +328,9 @@ func TestCannonDefendStep(t *testing.T) {
 	sys.TimeTravelClock.AdvanceTime(game.GameDuration(ctx))
 	require.NoError(t, wait.ForNextBlock(ctx, l1Client))
 
-	game.WaitForGameStatus(ctx, disputegame.StatusChallengerWins)
+	game.WaitForInactivity(ctx, 10, true)
 	game.LogGameData(ctx)
+	require.EqualValues(t, disputegame.StatusChallengerWins, game.Status(ctx))
 }
 
 func TestCannonProposedOutputRootInvalid(t *testing.T) {
@@ -335,14 +404,14 @@ func TestCannonProposedOutputRootInvalid(t *testing.T) {
 			sys.TimeTravelClock.AdvanceTime(game.GameDuration(ctx))
 			require.NoError(t, wait.ForNextBlock(ctx, l1Client))
 
-			game.WaitForGameStatus(ctx, disputegame.StatusDefenderWins)
+			game.WaitForInactivity(ctx, 10, true)
 			game.LogGameData(ctx)
+			require.EqualValues(t, disputegame.StatusDefenderWins, game.Status(ctx))
 		})
 	}
 }
 
 func TestCannonPoisonedPostState(t *testing.T) {
-	t.Skip("Known failure case")
 	InitParallel(t)
 
 	ctx := context.Background()
@@ -365,9 +434,12 @@ func TestCannonPoisonedPostState(t *testing.T) {
 	// Honest defense at "dishonest" level
 	correctTrace.Defend(ctx, 1)
 
-	// Dishonest attack at "honest" level - honest move would be to defend
+	// Dishonest attack at "honest" level - honest move would be to ignore
 	game.Attack(ctx, 2, common.Hash{0x03, 0xaa})
 
+	// Honest attack at "dishonest" level - honest move would be to ignore
+	correctTrace.Attack(ctx, 3)
+
 	// Start the honest challenger
 	game.StartChallenger(ctx, sys.RollupConfig, sys.L2GenesisCfg, l1Endpoint, l2Endpoint, "Honest",
 		// Agree with the proposed output, so disagree with the root claim
@@ -376,29 +448,40 @@ func TestCannonPoisonedPostState(t *testing.T) {
 	)
 
 	// Start dishonest challenger that posts correct claims
-	game.StartChallenger(ctx, sys.RollupConfig, sys.L2GenesisCfg, l1Endpoint, l2Endpoint, "DishonestCorrect",
-		// Disagree with the proposed output, so agree with the root claim
-		challenger.WithAgreeProposedOutput(false),
-		challenger.WithPrivKey(sys.cfg.Secrets.Mallory),
-	)
-
-	// Give the challengers time to progress down the full game depth
-	depth := game.MaxDepth(ctx)
-	for i := 3; i <= int(depth); i++ {
-		game.WaitForClaimAtDepth(ctx, i)
-		game.LogGameData(ctx)
-	}
+	// It participates in the subgame root the honest claim index 4
+	func() {
+		claimCount := int64(5)
+		depth := game.MaxDepth(ctx)
+		for {
+			game.LogGameData(ctx)
+			claimCount++
+			// Wait for the challenger to counter
+			game.WaitForClaimCount(ctx, claimCount)
+
+			// Respond with our own move
+			correctTrace.Defend(ctx, claimCount-1)
+			claimCount++
+			game.WaitForClaimCount(ctx, claimCount)
+
+			// Defender moves last. If we're at max depth, then we're done
+			dishonestClaim := game.GetClaimUnsafe(ctx, claimCount-1)
+			pos := types.NewPositionFromGIndex(dishonestClaim.Position.Uint64())
+			if int64(pos.Depth()) == depth {
+				break
+			}
+		}
+	}()
 
-	// Wait for all the leaf nodes to be countered
-	// Wait for the challengers to drive the game down to the leaf node which should be countered
-	game.WaitForAllClaimsCountered(ctx)
+	// Wait for the challenger to drive the subgame at 4 to the leaf node, which should be countered
+	game.WaitForClaimAtMaxDepth(ctx, true)
 
 	// Time travel past when the game will be resolvable.
 	sys.TimeTravelClock.AdvanceTime(game.GameDuration(ctx))
 	require.NoError(t, wait.ForNextBlock(ctx, l1Client))
 
-	game.WaitForGameStatus(ctx, disputegame.StatusChallengerWins)
+	game.WaitForInactivity(ctx, 10, true)
 	game.LogGameData(ctx)
+	require.EqualValues(t, disputegame.StatusChallengerWins, game.Status(ctx))
 }
 
 // setupDisputeGameForInvalidOutputRoot sets up an L2 chain with at least one valid output root followed by an invalid output root.
@@ -470,8 +553,9 @@ func TestCannonChallengeWithCorrectRoot(t *testing.T) {
 	sys.TimeTravelClock.AdvanceTime(game.GameDuration(ctx))
 	require.NoError(t, wait.ForNextBlock(ctx, l1Client))
 
-	game.WaitForGameStatus(ctx, disputegame.StatusChallengerWins)
+	game.WaitForInactivity(ctx, 10, true)
 	game.LogGameData(ctx)
+	require.EqualValues(t, disputegame.StatusChallengerWins, game.Status(ctx))
 }
 
 func startFaultDisputeSystem(t *testing.T) (*System, *ethclient.Client) {

op-node/flags/flags.go

@@ -306,7 +306,7 @@ var optionalFlags = []cli.Flag{
 var Flags []cli.Flag
 
 func init() {
-	optionalFlags = append(optionalFlags, p2pFlags...)
+	optionalFlags = append(optionalFlags, P2pFlags...)
 	optionalFlags = append(optionalFlags, oplog.CLIFlags(EnvVarPrefix)...)
 	Flags = append(requiredFlags, optionalFlags...)
 }

op-node/flags/p2p_flags.go

@@ -308,7 +308,7 @@ var (
 
 // None of these flags are strictly required.
 // Some are hidden if they are too technical, or not recommended.
-var p2pFlags = []cli.Flag{
+var P2pFlags = []cli.Flag{
 	DisableP2P,
 	NoDiscovery,
 	P2PPrivPath,

op-node/node/node.go

@@ -49,6 +49,9 @@ type OpNode struct {
 	resourcesCtx   context.Context
 	resourcesClose context.CancelFunc
 
+	// Indicates when it's safe to close data sources used by the runtimeConfig bg loader
+	runtimeConfigReloaderDone chan struct{}
+
 	closed atomic.Bool
 }
 
@@ -197,9 +200,8 @@ func (n *OpNode) initRuntimeConfig(ctx context.Context, cfg *Config) error {
 			return l1Head, err
 		}
 
-		n.handleProtocolVersionsUpdate(ctx)
-
-		return l1Head, nil
+		err = n.handleProtocolVersionsUpdate(ctx)
+		return l1Head, err
 	}
 
 	// initialize the runtime config before unblocking
@@ -210,10 +212,10 @@ func (n *OpNode) initRuntimeConfig(ctx context.Context, cfg *Config) error {
 	}
 
 	// start a background loop, to keep reloading it at the configured reload interval
-	go func(ctx context.Context, reloadInterval time.Duration) {
+	reloader := func(ctx context.Context, reloadInterval time.Duration) bool {
 		if reloadInterval <= 0 {
 			n.log.Debug("not running runtime-config reloading background loop")
-			return
+			return false
 		}
 		ticker := time.NewTicker(reloadInterval)
 		defer ticker.Stop()
@@ -222,13 +224,30 @@ func (n *OpNode) initRuntimeConfig(ctx context.Context, cfg *Config) error {
 			case <-ticker.C:
 				// If the reload fails, we will try again the next interval.
 				// Missing a runtime-config update is not critical, and we do not want to overwhelm the L1 RPC.
-				if l1Head, err := reload(ctx); err != nil {
-					n.log.Warn("failed to reload runtime config", "err", err)
-				} else {
+				l1Head, err := reload(ctx)
+				switch err {
+				case errNodeHalt, nil:
 					n.log.Debug("reloaded runtime config", "l1_head", l1Head)
+					if err == errNodeHalt {
+						return true
+					}
+				default:
+					n.log.Warn("failed to reload runtime config", "err", err)
 				}
 			case <-ctx.Done():
-				return
+				return false
+			}
+		}
+	}
+
+	n.runtimeConfigReloaderDone = make(chan struct{})
+	// Manages the lifetime of reloader. In order to safely Close the OpNode
+	go func(ctx context.Context, reloadInterval time.Duration) {
+		halt := reloader(ctx, reloadInterval)
+		close(n.runtimeConfigReloaderDone)
+		if halt {
+			if err := n.Close(); err != nil {
+				n.log.Error("Failed to halt rollup", "err", err)
 			}
 		}
 	}(n.resourcesCtx, cfg.RuntimeConfigReloadInterval) // this keeps running after initialization
@@ -499,6 +518,11 @@ func (n *OpNode) Close() error {
 		}
 	}
 
+	// Wait for the runtime config loader to be done using the data sources before closing them
+	if n.runtimeConfigReloaderDone != nil {
+		<-n.runtimeConfigReloaderDone
+	}
+
 	// close L2 engine RPC client
 	if n.l2Source != nil {
 		n.l2Source.Close()

op-node/node/superchain.go

@@ -2,18 +2,21 @@ package node
 
 import (
 	"context"
+	"errors"
 
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
 	"github.com/ethereum/go-ethereum/eth/catalyst"
 	"github.com/ethereum/go-ethereum/params"
 )
 
-func (n *OpNode) handleProtocolVersionsUpdate(ctx context.Context) {
+var errNodeHalt = errors.New("opted to halt, unprepared for protocol change")
+
+func (n *OpNode) handleProtocolVersionsUpdate(ctx context.Context) error {
 	recommended := n.runCfg.RecommendedProtocolVersion()
 	required := n.runCfg.RequiredProtocolVersion()
 	// if the protocol version sources are disabled we do not process them
 	if recommended == (params.ProtocolVersion{}) && required == (params.ProtocolVersion{}) {
-		return
+		return nil
 	}
 	local := rollup.OPStackSupport
 	// forward to execution engine, and get back the protocol version that op-geth supports
@@ -30,20 +33,20 @@ func (n *OpNode) handleProtocolVersionsUpdate(ctx context.Context) {
 	catalyst.LogProtocolVersionSupport(n.log.New("node", "engine"), local, required, "required")
 
 	// We may need to halt the node, if the user opted in to handling incompatible protocol-version signals
-	n.HaltMaybe()
+	return n.haltMaybe()
 }
 
-// HaltMaybe halts the rollup node if the runtime config indicates an incompatible required protocol change
+// haltMaybe returns errNodeHalt if the runtime config indicates an incompatible required protocol change
 // and the node is configured to opt-in to halting at this protocol-change level.
-func (n *OpNode) HaltMaybe() {
+func (n *OpNode) haltMaybe() error {
 	local := rollup.OPStackSupport
 	required := n.runCfg.RequiredProtocolVersion()
 	if haltMaybe(n.rollupHalt, local.Compare(required)) { // halt if we opted in to do so at this granularity
 		n.log.Error("Opted to halt, unprepared for protocol change", "required", required, "local", local)
-		if err := n.Close(); err != nil {
-			n.log.Error("Failed to halt rollup", "err", err)
-		}
+		// Avoid deadlocking the runtime config reloader by closing the OpNode elsewhere
+		return errNodeHalt
 	}
+	return nil
 }
 
 // haltMaybe returns true when we should halt, given the halt-option and required-version comparison

op-node/rollup/driver/driver.go

@@ -81,6 +81,7 @@ type SequencerIface interface {
 	PlanNextSequencerAction() time.Duration
 	RunNextSequencerAction(ctx context.Context) (*eth.ExecutionPayload, error)
 	BuildingOnto() eth.L2BlockRef
+	CancelBuildingBlock(ctx context.Context)
 }
 
 type Network interface {

op-node/rollup/driver/state.go

@@ -381,6 +381,9 @@ func (s *Driver) eventLoop() {
 				}
 				s.log.Warn("Sequencer has been stopped")
 				s.driverConfig.SequencerStopped = true
+				// Cancel any inflight block building. If we don't cancel this, we can resume sequencing an old block
+				// even if we've received new unsafe heads in the interim, causing us to introduce a re-org.
+				s.sequencer.CancelBuildingBlock(ctx)
 				respCh <- hashAndError{hash: s.derivation.UnsafeL2Head().Hash}
 			}
 		case respCh := <-s.sequencerActive:

op-program/host/config/config.go

@@ -64,6 +64,9 @@ type Config struct {
 	// ServerMode indicates that the program should run in pre-image server mode and wait for requests.
 	// No client program is run.
 	ServerMode bool
+
+	// IsCustomChainConfig indicates that the program uses a custom chain configuration
+	IsCustomChainConfig bool
 }
 
 func (c *Config) Check() error {
@@ -117,15 +120,18 @@ func NewConfig(
 	l2Claim common.Hash,
 	l2ClaimBlockNum uint64,
 ) *Config {
+	_, err := params.LoadOPStackChainConfig(l2Genesis.ChainID.Uint64())
+	isCustomConfig := err != nil
 	return &Config{
-		Rollup:             rollupCfg,
-		L2ChainConfig:      l2Genesis,
-		L1Head:             l1Head,
-		L2Head:             l2Head,
-		L2OutputRoot:       l2OutputRoot,
-		L2Claim:            l2Claim,
-		L2ClaimBlockNumber: l2ClaimBlockNum,
-		L1RPCKind:          sources.RPCKindBasic,
+		Rollup:              rollupCfg,
+		L2ChainConfig:       l2Genesis,
+		L1Head:              l1Head,
+		L2Head:              l2Head,
+		L2OutputRoot:        l2OutputRoot,
+		L2Claim:             l2Claim,
+		L2ClaimBlockNumber:  l2ClaimBlockNum,
+		L1RPCKind:           sources.RPCKindBasic,
+		IsCustomChainConfig: isCustomConfig,
 	}
 }
 
@@ -156,6 +162,7 @@ func NewConfigFromCLI(log log.Logger, ctx *cli.Context) (*Config, error) {
 	}
 	l2GenesisPath := ctx.String(flags.L2GenesisPath.Name)
 	var l2ChainConfig *params.ChainConfig
+	var isCustomConfig bool
 	if l2GenesisPath == "" {
 		networkName := ctx.String(flags.Network.Name)
 		ch := chaincfg.ChainByName(networkName)
@@ -169,25 +176,27 @@ func NewConfigFromCLI(log log.Logger, ctx *cli.Context) (*Config, error) {
 		l2ChainConfig = cfg
 	} else {
 		l2ChainConfig, err = loadChainConfigFromGenesis(l2GenesisPath)
+		isCustomConfig = true
 	}
 	if err != nil {
 		return nil, fmt.Errorf("invalid genesis: %w", err)
 	}
 	return &Config{
-		Rollup:             rollupCfg,
-		DataDir:            ctx.String(flags.DataDir.Name),
-		L2URL:              ctx.String(flags.L2NodeAddr.Name),
-		L2ChainConfig:      l2ChainConfig,
-		L2Head:             l2Head,
-		L2OutputRoot:       l2OutputRoot,
-		L2Claim:            l2Claim,
-		L2ClaimBlockNumber: l2ClaimBlockNum,
-		L1Head:             l1Head,
-		L1URL:              ctx.String(flags.L1NodeAddr.Name),
-		L1TrustRPC:         ctx.Bool(flags.L1TrustRPC.Name),
-		L1RPCKind:          sources.RPCProviderKind(ctx.String(flags.L1RPCProviderKind.Name)),
-		ExecCmd:            ctx.String(flags.Exec.Name),
-		ServerMode:         ctx.Bool(flags.Server.Name),
+		Rollup:              rollupCfg,
+		DataDir:             ctx.String(flags.DataDir.Name),
+		L2URL:               ctx.String(flags.L2NodeAddr.Name),
+		L2ChainConfig:       l2ChainConfig,
+		L2Head:              l2Head,
+		L2OutputRoot:        l2OutputRoot,
+		L2Claim:             l2Claim,
+		L2ClaimBlockNumber:  l2ClaimBlockNum,
+		L1Head:              l1Head,
+		L1URL:               ctx.String(flags.L1NodeAddr.Name),
+		L1TrustRPC:          ctx.Bool(flags.L1TrustRPC.Name),
+		L1RPCKind:           sources.RPCProviderKind(ctx.String(flags.L1RPCProviderKind.Name)),
+		ExecCmd:             ctx.String(flags.Exec.Name),
+		ServerMode:          ctx.Bool(flags.Server.Name),
+		IsCustomChainConfig: isCustomConfig,
 	}, nil
 }
 

op-program/host/config/config_test.go

 package config
 
 import (
+	"math/big"
 	"testing"
 
 	"github.com/ethereum-optimism/optimism/op-node/chaincfg"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
+	"github.com/ethereum-optimism/optimism/op-program/chainconfig"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/params"
 	"github.com/stretchr/testify/require"
@@ -12,7 +14,7 @@ import (
 
 var (
 	validRollupConfig    = chaincfg.Goerli
-	validL2Genesis       = params.GoerliChainConfig
+	validL2Genesis       = chainconfig.OPGoerliChainConfig
 	validL1Head          = common.Hash{0xaa}
 	validL2Head          = common.Hash{0xbb}
 	validL2Claim         = common.Hash{0xcc}
@@ -158,6 +160,19 @@ func TestRejectExecAndServerMode(t *testing.T) {
 	require.ErrorIs(t, err, ErrNoExecInServerMode)
 }
 
+func TestIsCustomChainConfig(t *testing.T) {
+	t.Run("nonCustom", func(t *testing.T) {
+		cfg := validConfig()
+		require.Equal(t, cfg.IsCustomChainConfig, false)
+	})
+	t.Run("custom", func(t *testing.T) {
+		customChainConfig := &params.ChainConfig{ChainID: big.NewInt(0x1212121212)}
+		cfg := NewConfig(validRollupConfig, customChainConfig, validL1Head, validL2Head, validL2OutputRoot, validL2Claim, validL2ClaimBlockNum)
+		require.Equal(t, cfg.IsCustomChainConfig, true)
+	})
+
+}
+
 func validConfig() *Config {
 	cfg := NewConfig(validRollupConfig, validL2Genesis, validL1Head, validL2Head, validL2OutputRoot, validL2Claim, validL2ClaimBlockNum)
 	cfg.DataDir = "/tmp/configTest"

op-program/host/kvstore/local.go

@@ -38,7 +38,15 @@ func (s *LocalPreimageSource) Get(key common.Hash) ([]byte, error) {
 	case l2ClaimBlockNumberKey:
 		return binary.BigEndian.AppendUint64(nil, s.config.L2ClaimBlockNumber), nil
 	case l2ChainIDKey:
-		return binary.BigEndian.AppendUint64(nil, client.CustomChainIDIndicator), nil
+		// The CustomChainIDIndicator informs the client to rely on the L2ChainConfigKey to
+		// read the chain config. Otherwise, it'll attempt to read a non-existent hardcoded chain config
+		var chainID uint64
+		if s.config.IsCustomChainConfig {
+			chainID = client.CustomChainIDIndicator
+		} else {
+			chainID = s.config.L2ChainConfig.ChainID.Uint64()
+		}
+		return binary.BigEndian.AppendUint64(nil, chainID), nil
 	case l2ChainConfigKey:
 		return json.Marshal(s.config.L2ChainConfig)
 	case rollupKey:

op-program/host/kvstore/local_test.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/ethereum-optimism/optimism/op-node/chaincfg"
 	preimage "github.com/ethereum-optimism/optimism/op-preimage"
-	"github.com/ethereum-optimism/optimism/op-program/client"
 	"github.com/ethereum-optimism/optimism/op-program/host/config"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/params"
@@ -33,7 +32,7 @@ func TestLocalPreimageSource(t *testing.T) {
 		{"L2OutputRoot", l2OutputRootKey, cfg.L2OutputRoot.Bytes()},
 		{"L2Claim", l2ClaimKey, cfg.L2Claim.Bytes()},
 		{"L2ClaimBlockNumber", l2ClaimBlockNumberKey, binary.BigEndian.AppendUint64(nil, cfg.L2ClaimBlockNumber)},
-		{"L2ChainID", l2ChainIDKey, binary.BigEndian.AppendUint64(nil, client.CustomChainIDIndicator)},
+		{"L2ChainID", l2ChainIDKey, binary.BigEndian.AppendUint64(nil, cfg.L2ChainConfig.ChainID.Uint64())},
 		{"Rollup", rollupKey, asJson(t, cfg.Rollup)},
 		{"ChainConfig", l2ChainConfigKey, asJson(t, cfg.L2ChainConfig)},
 		{"Unknown", preimage.LocalIndexKey(1000).PreimageKey(), nil},

ops-bedrock/Dockerfile.l1

-FROM ethereum/client-go:v1.13.0
+FROM ethereum/client-go:v1.13.1
 
 RUN apk add --no-cache jq
 

ops/check-changed/main.py

@@ -56,11 +56,7 @@ log = logging.getLogger(__name__)
 
 def main():
     patterns = sys.argv[1].split(',')
-
-    # temporarily only run indexer tests if indexer is changed because the tests are flaky
-    if len(patterns) != 1 or patterns[0] != "indexer":
-      patterns = patterns + REBUILD_ALL_PATTERNS
-
+    patterns = patterns + REBUILD_ALL_PATTERNS
 
     fp = os.path.realpath(__file__)
     monorepo_path = os.path.realpath(os.path.join(fp, '..', '..'))

package.json

@@ -59,7 +59,7 @@
     "eslint-plugin-prettier": "^4.0.0",
     "eslint-plugin-promise": "^5.1.0",
     "eslint-plugin-react": "^7.24.0",
-    "eslint-plugin-unicorn": "^42.0.0",
+    "eslint-plugin-unicorn": "^48.0.1",
     "husky": "^8.0.3",
     "lint-staged": "14.0.1",
     "markdownlint": "^0.31.0",

packages/contracts-bedrock/.gas-snapshot

@@ -46,6 +46,9 @@ CrossDomainOwnable3_Test:test_transferOwnership_zeroAddress_reverts() (gas: 1208
 CrossDomainOwnableThroughPortal_Test:test_depositTransaction_crossDomainOwner_succeeds() (gas: 81417)
 CrossDomainOwnable_Test:test_onlyOwner_notOwner_reverts() (gas: 10597)
 CrossDomainOwnable_Test:test_onlyOwner_succeeds() (gas: 34883)
+DelayedVetoable_Getters_Test:test_getters() (gas: 24466)
+DelayedVetoable_Getters_TestFail:test_getters_notZeroAddress_reverts() (gas: 31166)
+DelayedVetoable_HandleCall_TestFail:test_handleCall_unauthorizedInitiation_reverts() (gas: 20234)
 DeleteOutput:test_script_succeeds() (gas: 3100)
 DeployerWhitelist_Test:test_owner_succeeds() (gas: 7582)
 DeployerWhitelist_Test:test_storageSlots_succeeds() (gas: 33395)
@@ -88,39 +91,45 @@ FaucetTest:test_nonAdmin_drip_fails() (gas: 262520)
 FaucetTest:test_receive_succeeds() (gas: 17401)
 FaucetTest:test_withdraw_nonAdmin_reverts() (gas: 13145)
 FaucetTest:test_withdraw_succeeds() (gas: 78359)
-FaultDisputeGame_ResolvesCorrectly_CorrectRoot1:test_resolvesCorrectly_succeeds() (gas: 499197)
-FaultDisputeGame_ResolvesCorrectly_CorrectRoot2:test_resolvesCorrectly_succeeds() (gas: 506057)
-FaultDisputeGame_ResolvesCorrectly_CorrectRoot3:test_resolvesCorrectly_succeeds() (gas: 502738)
-FaultDisputeGame_ResolvesCorrectly_CorrectRoot4:test_resolvesCorrectly_succeeds() (gas: 505955)
-FaultDisputeGame_ResolvesCorrectly_CorrectRoot5:test_resolvesCorrectly_succeeds() (gas: 505224)
-FaultDisputeGame_ResolvesCorrectly_IncorrectRoot1:test_resolvesCorrectly_succeeds() (gas: 497962)
-FaultDisputeGame_ResolvesCorrectly_IncorrectRoot2:test_resolvesCorrectly_succeeds() (gas: 504822)
-FaultDisputeGame_ResolvesCorrectly_IncorrectRoot3:test_resolvesCorrectly_succeeds() (gas: 501503)
-FaultDisputeGame_ResolvesCorrectly_IncorrectRoot4:test_resolvesCorrectly_succeeds() (gas: 502720)
-FaultDisputeGame_ResolvesCorrectly_IncorrectRoot5:test_resolvesCorrectly_succeeds() (gas: 501989)
-FaultDisputeGame_Test:test_addLocalData_static_succeeds() (gas: 640504)
+FaultDisputeGame_ResolvesCorrectly_CorrectRoot1:test_resolvesCorrectly_succeeds() (gas: 660411)
+FaultDisputeGame_ResolvesCorrectly_CorrectRoot2:test_resolvesCorrectly_succeeds() (gas: 667293)
+FaultDisputeGame_ResolvesCorrectly_CorrectRoot3:test_resolvesCorrectly_succeeds() (gas: 663974)
+FaultDisputeGame_ResolvesCorrectly_CorrectRoot4:test_resolvesCorrectly_succeeds() (gas: 667169)
+FaultDisputeGame_ResolvesCorrectly_CorrectRoot5:test_resolvesCorrectly_succeeds() (gas: 666460)
+FaultDisputeGame_ResolvesCorrectly_IncorrectRoot1:test_resolvesCorrectly_succeeds() (gas: 653092)
+FaultDisputeGame_ResolvesCorrectly_IncorrectRoot2:test_resolvesCorrectly_succeeds() (gas: 658598)
+FaultDisputeGame_ResolvesCorrectly_IncorrectRoot3:test_resolvesCorrectly_succeeds() (gas: 655943)
+FaultDisputeGame_ResolvesCorrectly_IncorrectRoot4:test_resolvesCorrectly_succeeds() (gas: 656899)
+FaultDisputeGame_ResolvesCorrectly_IncorrectRoot5:test_resolvesCorrectly_succeeds() (gas: 656332)
+FaultDisputeGame_Test:test_addLocalData_static_succeeds() (gas: 640567)
 FaultDisputeGame_Test:test_createdAt_succeeds() (gas: 10342)
-FaultDisputeGame_Test:test_extraData_succeeds() (gas: 32377)
-FaultDisputeGame_Test:test_gameData_succeeds() (gas: 32804)
-FaultDisputeGame_Test:test_gameType_succeeds() (gas: 8309)
-FaultDisputeGame_Test:test_initialize_correctData_succeeds() (gas: 57628)
-FaultDisputeGame_Test:test_initialize_firstOutput_reverts() (gas: 210629)
-FaultDisputeGame_Test:test_initialize_l1HeadTooOld_reverts() (gas: 228390)
-FaultDisputeGame_Test:test_move_clockCorrectness_succeeds() (gas: 415971)
-FaultDisputeGame_Test:test_move_clockTimeExceeded_reverts() (gas: 23197)
-FaultDisputeGame_Test:test_move_defendRoot_reverts() (gas: 13344)
-FaultDisputeGame_Test:test_move_duplicateClaim_reverts() (gas: 102898)
-FaultDisputeGame_Test:test_move_gameDepthExceeded_reverts() (gas: 407913)
+FaultDisputeGame_Test:test_extraData_succeeds() (gas: 32355)
+FaultDisputeGame_Test:test_gameData_succeeds() (gas: 32782)
+FaultDisputeGame_Test:test_gameType_succeeds() (gas: 8265)
+FaultDisputeGame_Test:test_initialize_correctData_succeeds() (gas: 57739)
+FaultDisputeGame_Test:test_initialize_firstOutput_reverts() (gas: 210563)
+FaultDisputeGame_Test:test_initialize_l1HeadTooOld_reverts() (gas: 228368)
+FaultDisputeGame_Test:test_move_clockCorrectness_succeeds() (gas: 594268)
+FaultDisputeGame_Test:test_move_clockTimeExceeded_reverts() (gas: 23175)
+FaultDisputeGame_Test:test_move_defendRoot_reverts() (gas: 13366)
+FaultDisputeGame_Test:test_move_duplicateClaim_reverts() (gas: 147389)
+FaultDisputeGame_Test:test_move_duplicateClaimsDifferentSubgames_succeeds() (gas: 556885)
+FaultDisputeGame_Test:test_move_gameDepthExceeded_reverts() (gas: 585897)
 FaultDisputeGame_Test:test_move_gameNotInProgress_reverts() (gas: 11002)
-FaultDisputeGame_Test:test_move_nonExistentParent_reverts() (gas: 24710)
-FaultDisputeGame_Test:test_move_simpleAttack_succeeds() (gas: 107384)
-FaultDisputeGame_Test:test_resolve_challengeContested_succeeds() (gas: 224949)
-FaultDisputeGame_Test:test_resolve_notInProgress_reverts() (gas: 9686)
-FaultDisputeGame_Test:test_resolve_rootContested_succeeds() (gas: 109879)
-FaultDisputeGame_Test:test_resolve_rootUncontestedClockNotExpired_succeeds() (gas: 21421)
-FaultDisputeGame_Test:test_resolve_rootUncontested_succeeds() (gas: 27279)
-FaultDisputeGame_Test:test_resolve_teamDeathmatch_succeeds() (gas: 395658)
-FaultDisputeGame_Test:test_rootClaim_succeeds() (gas: 8276)
+FaultDisputeGame_Test:test_move_nonExistentParent_reverts() (gas: 24666)
+FaultDisputeGame_Test:test_move_simpleAttack_succeeds() (gas: 151959)
+FaultDisputeGame_Test:test_resolve_challengeContested_succeeds() (gas: 269413)
+FaultDisputeGame_Test:test_resolve_claimAlreadyResolved_reverts() (gas: 272356)
+FaultDisputeGame_Test:test_resolve_claimAtMaxDepthAlreadyResolved_reverts() (gas: 586672)
+FaultDisputeGame_Test:test_resolve_notInProgress_reverts() (gas: 9732)
+FaultDisputeGame_Test:test_resolve_outOfOrderResolution_reverts() (gas: 309037)
+FaultDisputeGame_Test:test_resolve_rootContested_succeeds() (gas: 139044)
+FaultDisputeGame_Test:test_resolve_rootUncontestedButUnresolved_reverts() (gas: 15883)
+FaultDisputeGame_Test:test_resolve_rootUncontestedClockNotExpired_succeeds() (gas: 18406)
+FaultDisputeGame_Test:test_resolve_rootUncontested_succeeds() (gas: 51409)
+FaultDisputeGame_Test:test_resolve_stepReached_succeeds() (gas: 498476)
+FaultDisputeGame_Test:test_resolve_teamDeathmatch_succeeds() (gas: 443373)
+FaultDisputeGame_Test:test_rootClaim_succeeds() (gas: 8232)
 FeeVault_Test:test_constructor_succeeds() (gas: 18185)
 GasBenchMark_L1CrossDomainMessenger:test_sendMessage_benchmark_0() (gas: 354421)
 GasBenchMark_L1CrossDomainMessenger:test_sendMessage_benchmark_1() (gas: 2952628)

packages/contracts-bedrock/foundry.toml

@@ -16,7 +16,8 @@ remappings = [
   '@rari-capital/solmate/=lib/solmate',
   '@cwia/=lib/clones-with-immutable-args/src',
   'forge-std/=lib/forge-std/src',
-  'ds-test/=lib/forge-std/lib/ds-test/src'
+  'ds-test/=lib/forge-std/lib/ds-test/src',
+  'safe-contracts/=lib/safe-contracts/contracts'
 ]
 extra_output = ['devdoc', 'userdoc', 'metadata', 'storageLayout']
 bytecode_hash = 'none'

safe-contracts @ e870f514

+Subproject commit e870f514ad34cd9654c72174d6d4a839e3c6639f

packages/contracts-bedrock/scripts/Deploy.s.sol

@@ -9,6 +9,8 @@ import { stdJson } from "forge-std/StdJson.sol";
 import { Deployer } from "./Deployer.sol";
 import { DeployConfig } from "./DeployConfig.s.sol";
 
+import { Safe } from "safe-contracts/Safe.sol";
+import { SafeProxyFactory } from "safe-contracts/proxies/SafeProxyFactory.sol";
 import { ProxyAdmin } from "src/universal/ProxyAdmin.sol";
 import { AddressManager } from "src/legacy/AddressManager.sol";
 import { Proxy } from "src/universal/Proxy.sol";

packages/contracts-bedrock/semver-lock.json

 {
   "src/EAS/EAS.sol": "0x1acb25751a1206eb859cc5fcf934da2f84cfb907b8e8951d86fc4e43c53a7303",
   "src/EAS/SchemaRegistry.sol": "0x305f3afed2e337cd70aac70fc202e6503b947b0a31e0d4e18c49486eeb635bb5",
+  "src/L1/DelayedVetoable.sol": "0x276c6276292095e6aa37a70008cf4e0d1cbcc020dbc9107459bbc72ab5ed744f",
   "src/L1/L1CrossDomainMessenger.sol": "0x14f5991022705b8bd3bf931e138a528cc9c9e90d0f1ec398efd5079224d61b3b",
   "src/L1/L1ERC721Bridge.sol": "0x3e0e3d2f4c151e41585850f06e6452cdda86348debfe6ff16e364a839266450b",
   "src/L1/L1StandardBridge.sol": "0x12e227c6054660a83b92d823a7447db96a7d476b7a94e0f1807772d400329880",
@@ -17,7 +18,7 @@
   "src/L2/L2StandardBridge.sol": "0xfe01bcb1ddc947b9b8a7093d0971854b9fa8d49da5bd933a3dd106167907f882",
   "src/L2/L2ToL1MessagePasser.sol": "0xafc710b4d320ef450586d96a61cbd58cac814cb3b0c4fdc280eace3efdcdf321",
   "src/L2/SequencerFeeVault.sol": "0xc2f733c1128d06ad60bf1e1d98c8f684a4825b11875ccdf2376ede33f5aad4e6",
-  "src/dispute/FaultDisputeGame.sol": "0x7b8462c29d003e96a73491c644001e1a9034bcc45c5be2a7bac3caf80d521635",
+  "src/dispute/FaultDisputeGame.sol": "0x76e7c16431faa32e2074e6abdfe3e86f5ec90b4ac8a6b662edba8c3ce791ad80",
   "src/legacy/DeployerWhitelist.sol": "0xf2129ec3da75307ba8e21bc943c332bb04704642e6e263149b5c8ee92dbcb7a8",
   "src/legacy/L1BlockNumber.sol": "0x30aae1fc85103476af0226b6e98c71c01feebbdc35d93401390b1ad438a37be6",
   "src/legacy/LegacyMessagePasser.sol": "0x5c08b0a663cc49d30e4e38540f6aefab19ef287c3ecd31c8d8c3decd5f5bd497",

packages/contracts-bedrock/src/L1/DelayedVetoable.sol

+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.15;
+
+import { ISemver } from "src/universal/ISemver.sol";
+
+/// @title DelayedVetoable
+/// @notice This contract enables a delay before a call is forwarded to a target contract, and during the delay period
+///         the call can be vetoed by the authorized vetoer.
+///         This contract does not support value transfers, only data is forwarded.
+///         Additionally, this contract cannot be used to forward calls with data beginning with the function selector
+///         of the queuedAt(bytes32) function. This is because of input validation checks which solidity performs at
+///         runtime on functions which take an argument.
+contract DelayedVetoable is ISemver {
+    /// @notice Error for when the delay has already been set.
+    error AlreadyDelayed();
+
+    /// @notice Error for when attempting to forward too early.
+    error ForwardingEarly();
+
+    /// @notice Error for the target is not set.
+    error TargetUnitialized();
+
+    /// @notice Error for unauthorized calls.
+    error Unauthorized(address expected, address actual);
+
+    /// @notice An event that is emitted when the delay is activated.
+    /// @param delay The delay that was activated.
+    event DelayActivated(uint256 delay);
+
+    /// @notice An event that is emitted when a call is initiated.
+    /// @param callHash The hash of the call data.
+    /// @param data The data of the initiated call.
+    event Initiated(bytes32 indexed callHash, bytes data);
+
+    /// @notice An event that is emitted each time a call is forwarded.
+    /// @param callHash The hash of the call data.
+    /// @param data The data forwarded to the target.
+    event Forwarded(bytes32 indexed callHash, bytes data);
+
+    /// @notice An event that is emitted each time a call is vetoed.
+    /// @param callHash The hash of the call data.
+    /// @param data The data forwarded to the target.
+    event Vetoed(bytes32 indexed callHash, bytes data);
+
+    /// @notice The address that all calls are forwarded to after the delay.
+    address internal immutable TARGET;
+
+    /// @notice The address that can veto a call.
+    address internal immutable VETOER;
+
+    /// @notice The address that can initiate a call.
+    address internal immutable INITIATOR;
+
+    /// @notice The delay which will be set after the initial system deployment is completed.
+    uint256 internal immutable OPERATING_DELAY;
+
+    /// @notice The current amount of time to wait before forwarding a call.
+    uint256 internal _delay;
+
+    /// @notice The time that a call was initiated.
+    mapping(bytes32 => uint256) internal _queuedAt;
+
+    /// @notice A modifier that reverts if not called by the vetoer or by address(0) to allow
+    ///         eth_call to interact with this proxy without needing to use low-level storage
+    ///         inspection. We assume that nobody is able to trigger calls from address(0) during
+    ///         normal EVM execution.
+    modifier readOrHandle() {
+        if (msg.sender == address(0)) {
+            _;
+        } else {
+            // This WILL halt the call frame on completion.
+            _handleCall();
+        }
+    }
+
+    /// @notice Semantic version.
+    /// @custom:semver 1.0.0
+    string public constant version = "1.0.0";
+
+    /// @notice Sets the target admin during contract deployment.
+    /// @param vetoer_ Address of the vetoer.
+    /// @param initiator_ Address of the initiator.
+    /// @param target_ Address of the target.
+    /// @param operatingDelay_ Time to delay when the system is operational.
+    constructor(address vetoer_, address initiator_, address target_, uint256 operatingDelay_) {
+        // Note that the _delay value is not set here. Having an initial delay of 0 is helpful
+        // during the deployment of a new system.
+        VETOER = vetoer_;
+        INITIATOR = initiator_;
+        TARGET = target_;
+        OPERATING_DELAY = operatingDelay_;
+    }
+
+    /// @notice Gets the initiator
+    /// @return initiator_ Initiator address.
+    function initiator() external virtual readOrHandle returns (address initiator_) {
+        initiator_ = INITIATOR;
+    }
+
+    //// @notice Queries the vetoer address.
+    /// @return vetoer_ Vetoer address.
+    function vetoer() external virtual readOrHandle returns (address vetoer_) {
+        vetoer_ = VETOER;
+    }
+
+    //// @notice Queries the target address.
+    /// @return target_ Target address.
+    function target() external readOrHandle returns (address target_) {
+        target_ = TARGET;
+    }
+
+    /// @notice Gets the delay
+    /// @return delay_ Delay address.
+    function delay() external readOrHandle returns (uint256 delay_) {
+        delay_ = _delay;
+    }
+
+    /// @notice Gets entries in the _queuedAt mapping.
+    /// @param callHash The hash of the call data.
+    /// @return queuedAt_ The time the callHash was recorded.
+    function queuedAt(bytes32 callHash) external readOrHandle returns (uint256 queuedAt_) {
+        queuedAt_ = _queuedAt[callHash];
+    }
+
+    /// @notice Used for all calls that pass data to the contract.
+    fallback() external {
+        _handleCall();
+    }
+
+    /// @notice Receives all calls other than those made by the vetoer.
+    ///         This enables transparent initiation and forwarding of calls to the target and avoids
+    ///         the need for additional layers of abi encoding.
+    function _handleCall() internal {
+        // The initiator and vetoer activate the delay by passing in null data.
+        if (msg.data.length == 0 && _delay == 0) {
+            if (msg.sender != INITIATOR && msg.sender != VETOER) {
+                revert Unauthorized(INITIATOR, msg.sender);
+            }
+            _delay = OPERATING_DELAY;
+            emit DelayActivated(_delay);
+            return;
+        }
+
+        bytes32 callHash = keccak256(msg.data);
+
+        // Case 1: The initiator is calling the contract to initiate a call.
+        if (msg.sender == INITIATOR && _queuedAt[callHash] == 0) {
+            if (_delay == 0) {
+                // This forward function will halt the call frame on completion.
+                _forwardAndHalt(callHash);
+            }
+            _queuedAt[callHash] = block.timestamp;
+            emit Initiated(callHash, msg.data);
+            return;
+        }
+
+        // Case 2: The vetoer is calling the contract to veto a call.
+        // Note: The vetoer retains the ability to veto even after the delay has passed. This makes censoring the vetoer
+        //       more costly, as there is no time limit after which their transaction can be included.
+        if (msg.sender == VETOER && _queuedAt[callHash] != 0) {
+            delete _queuedAt[callHash];
+            emit Vetoed(callHash, msg.data);
+            return;
+        }
+
+        // Case 3: The call is from an unpermissioned actor. We'll forward the call if the delay has
+        // passed.
+        if (_queuedAt[callHash] == 0) {
+            // The call has not been initiated, so we'll treat this is an unauthorized initiation attempt.
+            revert Unauthorized(INITIATOR, msg.sender);
+        }
+
+        if (_queuedAt[callHash] + _delay < block.timestamp) {
+            // Not enough time has passed, so we'll revert.
+            revert ForwardingEarly();
+        }
+
+        // Delete the call to prevent replays
+        delete _queuedAt[callHash];
+        _forwardAndHalt(callHash);
+    }
+
+    /// @notice Forwards the call to the target and halts the call frame.
+    function _forwardAndHalt(bytes32 callHash) internal {
+        // Forward the call
+        emit Forwarded(callHash, msg.data);
+        (bool success, bytes memory returndata) = TARGET.call(msg.data);
+        if (success == true) {
+            assembly {
+                return(add(returndata, 0x20), mload(returndata))
+            }
+        } else {
+            assembly {
+                revert(add(returndata, 0x20), mload(returndata))
+            }
+        }
+    }
+}

packages/contracts-bedrock/src/dispute/FaultDisputeGame.sol

@@ -75,6 +75,12 @@ contract FaultDisputeGame is IFaultDisputeGame, Clone, Semver {
     /// @notice An internal mapping to allow for constant-time lookups of existing claims.
     mapping(ClaimHash => bool) internal claims;
 
+    /// @notice An internal mapping of subgames rooted at a claim index to other claim indices in the subgame.
+    mapping(uint256 => uint256[]) internal subgames;
+
+    /// @notice Indicates whether the subgame rooted at the root claim has been resolved.
+    bool internal subgameAtRootResolved;
+
     /// @param _gameType The type ID of the game.
     /// @param _absolutePrestate The absolute prestate of the instruction trace.
     /// @param _maxGameDepth The maximum depth of bisection.
@@ -232,9 +238,10 @@ contract FaultDisputeGame is IFaultDisputeGame, Clone, Semver {
         // Construct the next clock with the new duration and the current block timestamp.
         Clock nextClock = LibClock.wrap(nextDuration, Timestamp.wrap(uint64(block.timestamp)));
 
-        // INVARIANT: A claim may only exist at a given position once. Multiple claims may exist
-        //            at the same position, however they must have different values.
-        ClaimHash claimHash = _claim.hashClaimPos(nextPosition);
+        // INVARIANT: There cannot be multiple identical claims with identical moves on the same challengeIndex. Multiple
+        // claims
+        //            at the same position may dispute the same challengeIndex. However, the must have different values.
+        ClaimHash claimHash = _claim.hashClaimPos(nextPosition, _challengeIndex);
         if (claims[claimHash]) revert ClaimAlreadyExists();
         claims[claimHash] = true;
 
@@ -252,6 +259,9 @@ contract FaultDisputeGame is IFaultDisputeGame, Clone, Semver {
         // Set the parent claim as countered.
         claimData[_challengeIndex].countered = true;
 
+        // Update the subgame rooted at the parent claim.
+        subgames[_challengeIndex].push(claimData.length - 1);
+
         // Emit the appropriate event for the attack or defense.
         emit Move(_challengeIndex, _claim, msg.sender);
     }
@@ -348,67 +358,64 @@ contract FaultDisputeGame is IFaultDisputeGame, Clone, Semver {
         // INVARIANT: Resolution cannot occur unless the game is currently in progress.
         if (status != GameStatus.IN_PROGRESS) revert GameNotInProgress();
 
-        // Search for the left-most dangling non-bottom node
-        // The most recent claim is always a dangling, non-bottom node so we start with that
-        uint256 leftMostIndex = claimData.length - 1;
-        uint256 leftMostTraceIndex = type(uint128).max;
-        for (uint256 i = leftMostIndex; i < type(uint64).max;) {
-            // Fetch the claim at the current index.
-            ClaimData storage claim = claimData[i];
-
-            // Decrement the loop counter; If it underflows, we've reached the root
-            // claim and can stop searching.
-            unchecked {
-                --i;
-            }
+        // INVARIANT: Resolution cannot occur unless the absolute root subgame has been resolved.
+        if (!subgameAtRootResolved) revert OutOfOrderResolution();
 
-            // INVARIANT: A claim can never be considered as the leftMostIndex or leftMostTraceIndex
-            //            if it has been countered.
-            if (claim.countered) continue;
-
-            // If the claim is a dangling node, we can check if it is the left-most
-            // dangling node we've come across so far. If it is, we can update the
-            // left-most trace index.
-            uint256 traceIndex = claim.position.traceIndex(MAX_GAME_DEPTH);
-            if (traceIndex < leftMostTraceIndex) {
-                leftMostTraceIndex = traceIndex;
-                unchecked {
-                    leftMostIndex = i + 1;
-                }
-            }
-        }
+        status_ = claimData[0].countered ? GameStatus.CHALLENGER_WINS : GameStatus.DEFENDER_WINS;
+        emit Resolved(status = status_);
+    }
 
-        // Create a reference to the left most uncontested claim and its parent.
-        ClaimData storage leftMostUncontested = claimData[leftMostIndex];
+    /// @inheritdoc IFaultDisputeGame
+    function resolveClaim(uint256 _claimIndex) external payable {
+        // INVARIANT: Resolution cannot occur unless the game is currently in progress.
+        if (status != GameStatus.IN_PROGRESS) revert GameNotInProgress();
 
-        // INVARIANT: The game may never be resolved unless the clock of the left-most uncontested
-        //            claim's parent has expired. If the left-most uncontested claim is the root
-        //            claim, it is uncountered, and we check if 3.5 days has passed since its
-        //            creation.
-        uint256 parentIndex = leftMostUncontested.parentIndex;
-        Clock opposingClock = parentIndex == type(uint32).max ? leftMostUncontested.clock : claimData[parentIndex].clock;
+        ClaimData storage parent = claimData[_claimIndex];
+
+        // INVARIANT: Cannot resolve a subgame unless the clock of its root has expired
         if (
-            Duration.unwrap(opposingClock.duration()) + (block.timestamp - Timestamp.unwrap(opposingClock.timestamp()))
+            Duration.unwrap(parent.clock.duration()) + (block.timestamp - Timestamp.unwrap(parent.clock.timestamp()))
                 <= Duration.unwrap(GAME_DURATION) >> 1
         ) {
             revert ClockNotExpired();
         }
 
-        // If the left-most dangling node is at an even depth, the defender wins.
-        // Otherwise, the challenger wins and the root claim is deemed invalid.
-        if (
-            leftMostUncontested
-                .position
-                // slither-disable-next-line weak-prng
-                .depth() % 2 == 0 && leftMostTraceIndex != type(uint128).max
-        ) {
-            status_ = GameStatus.DEFENDER_WINS;
-        } else {
-            status_ = GameStatus.CHALLENGER_WINS;
+        uint256[] storage challengeIndices = subgames[_claimIndex];
+
+        // INVARIANT: Cannot resolve subgames twice
+        // Uncontested claims are resolved implicitly unless they are the root claim
+        if (_claimIndex == 0 && subgameAtRootResolved) revert ClaimAlreadyResolved();
+        if (challengeIndices.length == 0 && _claimIndex != 0) revert ClaimAlreadyResolved();
+
+        // Assume parent is honest until proven otherwise
+        bool countered = false;
+
+        for (uint256 i = 0; i < challengeIndices.length; ++i) {
+            uint256 challengeIndex = challengeIndices[i];
+
+            // INVARIANT: Cannot resolve a subgame containing an unresolved claim
+            if (subgames[challengeIndex].length != 0) revert OutOfOrderResolution();
+
+            ClaimData storage claim = claimData[challengeIndex];
+
+            // Ignore false claims
+            if (!claim.countered) {
+                countered = true;
+                break;
+            }
         }
 
-        // Update the game status
-        emit Resolved(status = status_);
+        // Once a subgame is resolved, we percolate the result up the DAG so subsequent calls to
+        // resolveClaim will not need to traverse this subgame.
+        parent.countered = countered;
+
+        // Resolved subgames have no entries
+        delete subgames[_claimIndex];
+
+        // Indicate the game is ready to be resolved
+        if (_claimIndex == 0) {
+            subgameAtRootResolved = true;
+        }
     }
 
     /// @inheritdoc IDisputeGame

packages/contracts-bedrock/src/dispute/interfaces/IFaultDisputeGame.sol

@@ -73,6 +73,14 @@ interface IFaultDisputeGame is IDisputeGame {
     /// @param _partOffset The offset of the data to post.
     function addLocalData(uint256 _ident, uint256 _partOffset) external;
 
+    /// @notice Resolves the subgame rooted at the given claim index.
+    /// @dev This function must be called bottom-up in the DAG
+    ///      A subgame is a tree of claims that has a maximum depth of 1.
+    ///      A subgame root claims is valid if, and only if, all of its child claims are invalid.
+    ///      At the deepest level in the DAG, a claim is invalid if there's a successful step against it.
+    /// @param _claimIndex The index of the subgame root claim to resolve.
+    function resolveClaim(uint256 _claimIndex) external payable;
+
     /// @notice An L1 block hash that contains the disputed output root, fetched from the
     ///         `BlockOracle` and verified by referencing the timestamp associated with the
     ///         first L2 Output Proposal in the `L2OutputOracle` that contains the disputed

packages/contracts-bedrock/src/dispute/lib/LibHashing.sol

@@ -9,11 +9,20 @@ library LibHashing {
     /// @notice Hashes a claim and a position together.
     /// @param _claim A Claim type.
     /// @param _position The position of `claim`.
-    /// @return claimHash_ A hash of abi.encodePacked(claim, position);
-    function hashClaimPos(Claim _claim, Position _position) internal pure returns (ClaimHash claimHash_) {
+    /// @param _challengeIndex The index of the claim being moved against.
+    /// @return claimHash_ A hash of abi.encodePacked(claim, position|challengeIndex);
+    function hashClaimPos(
+        Claim _claim,
+        Position _position,
+        uint256 _challengeIndex
+    )
+        internal
+        pure
+        returns (ClaimHash claimHash_)
+    {
         assembly {
             mstore(0x00, _claim)
-            mstore(0x20, _position)
+            mstore(0x20, or(shl(128, _position), and(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF, _challengeIndex)))
             claimHash_ := keccak256(0x00, 0x40)
         }
     }

packages/contracts-bedrock/src/libraries/DisputeErrors.sol

@@ -66,6 +66,12 @@ error L1HeadTooOld();
 /// @notice Thrown when an invalid local identifier is passed to the `addLocalData` function.
 error InvalidLocalIdent();
 
+/// @notice Thrown when resolving claims out of order.
+error OutOfOrderResolution();
+
+/// @notice Thrown when resolving a claim that has already been resolved.
+error ClaimAlreadyResolved();
+
 ////////////////////////////////////////////////////////////////
 //              `AttestationDisputeGame` Errors               //
 ////////////////////////////////////////////////////////////////

pnpm-workspace.yaml

@@ -2,4 +2,4 @@ packages:
   - 'packages/*'
   - 'endpoint-monitor'
   - 'op-exporter'
-  - 'indexer/ts'
+  - 'indexer/api-ts'

proxyd/cache.go

@@ -7,8 +7,8 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/rpc"
+	"github.com/redis/go-redis/v9"
 
-	"github.com/go-redis/redis/v8"
 	"github.com/golang/snappy"
 	lru "github.com/hashicorp/golang-lru"
 )
@@ -78,7 +78,7 @@ func (c *redisCache) Get(ctx context.Context, key string) (string, error) {
 
 func (c *redisCache) Put(ctx context.Context, key string, value string) error {
 	start := time.Now()
-	err := c.rdb.SetEX(ctx, c.namespaced(key), value, redisTTL).Err()
+	err := c.rdb.SetEx(ctx, c.namespaced(key), value, redisTTL).Err()
 	redisCacheDurationSumm.WithLabelValues("SETEX").Observe(float64(time.Since(start).Milliseconds()))
 
 	if err != nil {

proxyd/config.go

@@ -110,6 +110,10 @@ type BackendGroupConfig struct {
 	ConsensusMaxBlockLag        uint64       `toml:"consensus_max_block_lag"`
 	ConsensusMaxBlockRange      uint64       `toml:"consensus_max_block_range"`
 	ConsensusMinPeerCount       int          `toml:"consensus_min_peer_count"`
+
+	ConsensusHA                  bool         `toml:"consensus_ha"`
+	ConsensusHAHeartbeatInterval TOMLDuration `toml:"consensus_ha_heartbeat_interval"`
+	ConsensusHALockPeriod        TOMLDuration `toml:"consensus_ha_lock_period"`
 }
 
 type BackendGroupsConfig map[string]*BackendGroupConfig

proxyd/consensus_poller.go

@@ -23,6 +23,7 @@ type OnConsensusBroken func()
 // resolves the highest common block for multiple nodes, and reconciles the consensus
 // in case of block hash divergence to minimize re-orgs
 type ConsensusPoller struct {
+	ctx        context.Context
 	cancelFunc context.CancelFunc
 	listeners  []OnConsensusBroken
 
@@ -220,6 +221,7 @@ func NewConsensusPoller(bg *BackendGroup, opts ...ConsensusOpt) *ConsensusPoller
 	state := make(map[*Backend]*backendState, len(bg.Backends))
 
 	cp := &ConsensusPoller{
+		ctx:          ctx,
 		cancelFunc:   cancelFunc,
 		backendGroup: bg,
 		backendState: state,

proxyd/frontend_rate_limiter.go

@@ -6,7 +6,7 @@ import (
 	"sync"
 	"time"
 
-	"github.com/go-redis/redis/v8"
+	"github.com/redis/go-redis/v9"
 )
 
 type FrontendRateLimiter interface {

proxyd/frontend_rate_limiter_test.go

@@ -7,7 +7,7 @@ import (
 	"time"
 
 	"github.com/alicebob/miniredis"
-	"github.com/go-redis/redis/v8"
+	"github.com/redis/go-redis/v9"
 	"github.com/stretchr/testify/require"
 )
 

proxyd/go.mod

@@ -7,7 +7,6 @@ require (
 	github.com/alicebob/miniredis v2.5.0+incompatible
 	github.com/emirpasic/gods v1.18.1
 	github.com/ethereum/go-ethereum v1.12.1
-	github.com/go-redis/redis/v8 v8.11.4
 	github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb
 	github.com/gorilla/mux v1.8.0
 	github.com/gorilla/websocket v1.5.0
@@ -44,11 +43,14 @@ require (
 	github.com/ethereum/c-kzg-4844 v0.3.0 // indirect
 	github.com/getsentry/sentry-go v0.18.0 // indirect
 	github.com/go-ole/go-ole v1.2.6 // indirect
+	github.com/go-redsync/redsync/v4 v4.9.4 // indirect
 	github.com/go-stack/stack v1.8.1 // indirect
 	github.com/gofrs/flock v0.8.1 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
-	github.com/gomodule/redigo v1.8.8 // indirect
+	github.com/gomodule/redigo v1.8.9 // indirect
+	github.com/hashicorp/errwrap v1.1.0 // indirect
+	github.com/hashicorp/go-multierror v1.1.1 // indirect
 	github.com/holiman/bloomfilter/v2 v2.0.3 // indirect
 	github.com/holiman/uint256 v1.2.3 // indirect
 	github.com/klauspost/compress v1.15.15 // indirect
@@ -62,6 +64,7 @@ require (
 	github.com/prometheus/client_model v0.3.0 // indirect
 	github.com/prometheus/common v0.39.0 // indirect
 	github.com/prometheus/procfs v0.9.0 // indirect
+	github.com/redis/go-redis/v9 v9.1.0 // indirect
 	github.com/rivo/uniseg v0.2.0 // indirect
 	github.com/rogpeppe/go-internal v1.9.0 // indirect
 	github.com/shirou/gopsutil v3.21.11+incompatible // indirect

proxyd/metrics.go

@@ -262,6 +262,33 @@ var (
 		"backend_group_name",
 	})
 
+	consensusHALatestBlock = promauto.NewGaugeVec(prometheus.GaugeOpts{
+		Namespace: MetricsNamespace,
+		Name:      "group_consensus_ha_latest_block",
+		Help:      "Consensus HA latest block",
+	}, []string{
+		"backend_group_name",
+		"leader",
+	})
+
+	consensusHASafeBlock = promauto.NewGaugeVec(prometheus.GaugeOpts{
+		Namespace: MetricsNamespace,
+		Name:      "group_consensus_ha_safe_block",
+		Help:      "Consensus HA safe block",
+	}, []string{
+		"backend_group_name",
+		"leader",
+	})
+
+	consensusHAFinalizedBlock = promauto.NewGaugeVec(prometheus.GaugeOpts{
+		Namespace: MetricsNamespace,
+		Name:      "group_consensus_ha_finalized_block",
+		Help:      "Consensus HA finalized block",
+	}, []string{
+		"backend_group_name",
+		"leader",
+	})
+
 	backendLatestBlockBackend = promauto.NewGaugeVec(prometheus.GaugeOpts{
 		Namespace: MetricsNamespace,
 		Name:      "backend_latest_block",
@@ -438,6 +465,18 @@ func RecordBatchSize(size int) {
 	batchSizeHistogram.Observe(float64(size))
 }
 
+func RecordGroupConsensusHALatestBlock(group *BackendGroup, leader string, blockNumber hexutil.Uint64) {
+	consensusHALatestBlock.WithLabelValues(group.Name, leader).Set(float64(blockNumber))
+}
+
+func RecordGroupConsensusHASafeBlock(group *BackendGroup, leader string, blockNumber hexutil.Uint64) {
+	consensusHASafeBlock.WithLabelValues(group.Name, leader).Set(float64(blockNumber))
+}
+
+func RecordGroupConsensusHAFinalizedBlock(group *BackendGroup, leader string, blockNumber hexutil.Uint64) {
+	consensusHAFinalizedBlock.WithLabelValues(group.Name, leader).Set(float64(blockNumber))
+}
+
 func RecordGroupConsensusLatestBlock(group *BackendGroup, blockNumber hexutil.Uint64) {
 	consensusLatestBlock.WithLabelValues(group.Name).Set(float64(blockNumber))
 }

proxyd/redis.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"time"
 
-	"github.com/go-redis/redis/v8"
+	"github.com/redis/go-redis/v9"
 )
 
 func NewRedisClient(url string) (*redis.Client, error) {