Merge branch 'develop' into 08-17-fix_indexer_Run_docker-compose_for_indexer_correctly

docs/README.md

+## Optimism Monorepo Documentation
+
+The `docs/` directory contains Optimism documentation closely tied to the implementation details of the monorepo (https://github.com/ethereum-optimism/optimism).
+
+The directory layout is divided into the following sub-directories.
+
+- [`postmortems/`](./postmortems/): Timestamped post-mortem documents.
+- [`security-reviews`](./security-reviews/): Audit summaries and other security review documents.

go.mod

@@ -31,7 +31,7 @@ require (
 	github.com/multiformats/go-multiaddr v0.10.1
 	github.com/multiformats/go-multiaddr-dns v0.3.1
 	github.com/olekukonko/tablewriter v0.0.5
-	github.com/onsi/gomega v1.27.4
+	github.com/onsi/gomega v1.27.10
 	github.com/pkg/errors v0.9.1
 	github.com/pkg/profile v1.7.0
 	github.com/prometheus/client_golang v1.14.0
@@ -43,7 +43,7 @@ require (
 	golang.org/x/term v0.11.0
 	golang.org/x/time v0.3.0
 	gorm.io/driver/postgres v1.5.2
-	gorm.io/gorm v1.25.3
+	gorm.io/gorm v1.25.4
 )
 
 require (
@@ -157,7 +157,7 @@ require (
 	github.com/multiformats/go-varint v0.0.7 // indirect
 	github.com/naoina/go-stringutil v0.1.0 // indirect
 	github.com/naoina/toml v0.1.2-0.20170918210437-9fafd6967416 // indirect
-	github.com/onsi/ginkgo/v2 v2.9.2 // indirect
+	github.com/onsi/ginkgo/v2 v2.11.0 // indirect
 	github.com/opencontainers/runtime-spec v1.0.2 // indirect
 	github.com/opentracing/opentracing-go v1.2.0 // indirect
 	github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 // indirect
@@ -193,10 +193,10 @@ require (
 	go.uber.org/multierr v1.11.0 // indirect
 	go.uber.org/zap v1.24.0 // indirect
 	golang.org/x/mod v0.11.0 // indirect
-	golang.org/x/net v0.10.0 // indirect
+	golang.org/x/net v0.12.0 // indirect
 	golang.org/x/sys v0.11.0 // indirect
 	golang.org/x/text v0.12.0 // indirect
-	golang.org/x/tools v0.7.0 // indirect
+	golang.org/x/tools v0.9.3 // indirect
 	google.golang.org/protobuf v1.30.0 // indirect
 	gopkg.in/natefinch/lumberjack.v2 v2.0.0 // indirect
 	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce // indirect

go.sum

@@ -214,7 +214,7 @@ github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm
 github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA=
 github.com/go-kit/log v0.1.0/go.mod h1:zbhenjAZHb184qTLMA9ZjW7ThYL0H2mk7Q6pNt4vbaY=
 github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
-github.com/go-logr/logr v1.2.3 h1:2DntVwHkVopvECVRSlL5PSo9eG+cAkDCuckLubN+rq0=
+github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ=
 github.com/go-martini/martini v0.0.0-20170121215854-22fa46961aab/go.mod h1:/P9AEU963A2AYjv4d1V5eVL1CQbEJq6aCNHDDjibzu8=
 github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY=
 github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
@@ -647,16 +647,16 @@ github.com/onsi/ginkgo v1.16.4/go.mod h1:dX+/inL/fNMqNlz0e9LfyB9TswhZpCVdJM/Z6Vv
 github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE=
 github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU=
 github.com/onsi/ginkgo/v2 v2.1.3/go.mod h1:vw5CSIxN1JObi/U8gcbwft7ZxR2dgaR70JSE3/PpL4c=
-github.com/onsi/ginkgo/v2 v2.9.2 h1:BA2GMJOtfGAfagzYtrAlufIP0lq6QERkFmHLMLPwFSU=
-github.com/onsi/ginkgo/v2 v2.9.2/go.mod h1:WHcJJG2dIlcCqVfBAwUCrJxSPFb6v4azBwgxeMeDuts=
+github.com/onsi/ginkgo/v2 v2.11.0 h1:WgqUCUt/lT6yXoQ8Wef0fsNn5cAuMK7+KT9UFRz2tcU=
+github.com/onsi/ginkgo/v2 v2.11.0/go.mod h1:ZhrRA5XmEE3x3rhlzamx/JJvujdZoJ2uvgI7kR0iZvM=
 github.com/onsi/gomega v1.4.1/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA=
 github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
 github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
 github.com/onsi/gomega v1.17.0/go.mod h1:HnhC7FXeEQY45zxNK3PPoIUhzk/80Xly9PcubAlGdZY=
 github.com/onsi/gomega v1.19.0/go.mod h1:LY+I3pBVzYsTBU1AnDwOSxaYi9WoWiqgwooUqq9yPro=
-github.com/onsi/gomega v1.27.4 h1:Z2AnStgsdSayCMDiCU42qIz+HLqEPcgiOCXjAU/w+8E=
-github.com/onsi/gomega v1.27.4/go.mod h1:riYq/GJKh8hhoM01HN6Vmuy93AarCXCBGpvFDK3q3fQ=
+github.com/onsi/gomega v1.27.10 h1:naR28SdDFlqrG6kScpT8VWpu1xWY5nJRCF3XaYyBjhI=
+github.com/onsi/gomega v1.27.10/go.mod h1:RsS8tutOdbdgzbPtzzATp12yT7kM5I5aElG3evPbQ0M=
 github.com/opencontainers/runtime-spec v1.0.2 h1:UfAcuLBJB9Coz72x1hgl8O5RVzTdNiaglX6v2DM6FI0=
 github.com/opencontainers/runtime-spec v1.0.2/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0=
 github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
@@ -934,8 +934,8 @@ golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT
 golang.org/x/net v0.0.0-20211008194852-3b03d305991f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk=
 golang.org/x/net v0.0.0-20220607020251-c690dde0001d/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M=
-golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
+golang.org/x/net v0.12.0 h1:cfawfvKITfUsFCeJIHJrbSxpeu/E81khclypR0GVT50=
+golang.org/x/net v0.12.0/go.mod h1:zEVYFnQC7m/vmpQFELhcD1EWkZlX69l4oqgmer6hfKA=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20181017192945-9dcd33a902f4/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20181203162652-d668ce993890/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
@@ -1056,8 +1056,8 @@ golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4f
 golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.3/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
-golang.org/x/tools v0.7.0 h1:W4OVu8VVOaIO0yzWMNdepAulS7YfoS3Zabrm8DOXXU4=
-golang.org/x/tools v0.7.0/go.mod h1:4pg6aUX35JBAogB10C9AtvVL+qowtN4pT3CGSQex14s=
+golang.org/x/tools v0.9.3 h1:Gn1I8+64MsuTb/HpH+LmQtNas23LhUVr3rYZ0eKuaMM=
+golang.org/x/tools v0.9.3/go.mod h1:owI94Op576fPu3cIGQeHs3joujW/2Oc6MtlxbF5dfNc=
 golang.org/x/xerrors v0.0.0-20190410155217-1f06c39b4373/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20190513163551-3ee3066db522/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -1136,8 +1136,8 @@ gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gorm.io/driver/postgres v1.5.2 h1:ytTDxxEv+MplXOfFe3Lzm7SjG09fcdb3Z/c056DTBx0=
 gorm.io/driver/postgres v1.5.2/go.mod h1:fmpX0m2I1PKuR7mKZiEluwrP3hbs+ps7JIGMUBpCgl8=
-gorm.io/gorm v1.25.3 h1:zi4rHZj1anhZS2EuEODMhDisGy+Daq9jtPrNGgbQYD8=
-gorm.io/gorm v1.25.3/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k=
+gorm.io/gorm v1.25.4 h1:iyNd8fNAe8W9dvtlgeRI5zSVZPsq3OpcTu37cYcpCmw=
+gorm.io/gorm v1.25.4/go.mod h1:L4uxeKpfBml98NYqVqwAdmV1a2nBtAec/cf3fpucW/k=
 grpc.go4.org v0.0.0-20170609214715-11d0a25b4919/go.mod h1:77eQGdRu53HpSqPFJFmuJdjuHRquDANNeA4x7B8WQ9o=
 honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

op-challenger/config/config.go

@@ -35,27 +35,19 @@ const (
 	TraceTypeAlphabet TraceType = "alphabet"
 	TraceTypeCannon   TraceType = "cannon"
 
-	// Devnet game IDs
-	DevnetGameIDAlphabet = uint8(0)
-	DevnetGameIDCannon   = uint8(1)
+	// Mainnet games
+	CannonFaultGameID = 0
 
-	// Mainnet game IDs
-	MainnetGameIDFault = uint8(0)
+	// Devnet games
+	AlphabetFaultGameID = 255
 )
 
 var TraceTypes = []TraceType{TraceTypeAlphabet, TraceTypeCannon}
 
-// GameIdToString maps game IDs to their string representation on a per-network basis.
-var GameIdToString = map[uint64]map[uint8]string{
-	// Mainnet
-	1: {
-		MainnetGameIDFault: "fault-cannon",
-	},
-	// Devnet
-	900: {
-		DevnetGameIDAlphabet: "fault-alphabet",
-		DevnetGameIDCannon:   "fault-cannon",
-	},
+// GameIdToString maps game IDs to their string representation.
+var GameIdToString = map[uint8]string{
+	CannonFaultGameID:   "Cannon",
+	AlphabetFaultGameID: "Alphabet",
 }
 
 func (t TraceType) String() string {

op-challenger/fault/caller.go

@@ -4,13 +4,11 @@ import (
 	"context"
 	"math/big"
 
+	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
+	"github.com/ethereum-optimism/optimism/op-challenger/fault/types"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
-	"github.com/ethereum/go-ethereum/log"
-
-	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
-	"github.com/ethereum-optimism/optimism/op-challenger/fault/types"
 )
 
 type FaultDisputeGameCaller interface {
@@ -19,62 +17,39 @@ type FaultDisputeGameCaller interface {
 }
 
 type FaultCaller struct {
-	FaultDisputeGameCaller
-	log log.Logger
+	contract FaultDisputeGameCaller
 }
 
-func NewFaultCaller(caller FaultDisputeGameCaller, log log.Logger) *FaultCaller {
+func NewFaultCaller(caller FaultDisputeGameCaller) *FaultCaller {
 	return &FaultCaller{
 		caller,
-		log,
 	}
 }
 
-func NewFaultCallerFromBindings(fdgAddr common.Address, client *ethclient.Client, log log.Logger) (*FaultCaller, error) {
+func NewFaultCallerFromBindings(fdgAddr common.Address, client *ethclient.Client) (*FaultCaller, error) {
 	caller, err := bindings.NewFaultDisputeGameCaller(fdgAddr, client)
 	if err != nil {
 		return nil, err
 	}
 	return &FaultCaller{
 		caller,
-		log,
 	}, nil
 }
 
-// LogGameInfo logs the game info.
-func (fc *FaultCaller) LogGameInfo(ctx context.Context) {
-	status, err := fc.GetGameStatus(ctx)
-	if err != nil {
-		fc.log.Error("failed to get game status", "err", err)
-		return
-	}
-	claimLen, err := fc.GetClaimDataLength(ctx)
-	if err != nil {
-		fc.log.Error("failed to get claim count", "err", err)
-		return
-	}
-	fc.log.Info("Game info", "claims", claimLen, "status", status)
-}
-
 // GetGameStatus returns the current game status.
 // 0: In Progress
 // 1: Challenger Won
 // 2: Defender Won
 func (fc *FaultCaller) GetGameStatus(ctx context.Context) (types.GameStatus, error) {
-	status, err := fc.Status(&bind.CallOpts{Context: ctx})
+	status, err := fc.contract.Status(&bind.CallOpts{Context: ctx})
 	return types.GameStatus(status), err
 }
 
-// GetClaimDataLength returns the number of claims in the game.
-func (fc *FaultCaller) GetClaimDataLength(ctx context.Context) (*big.Int, error) {
-	return fc.ClaimDataLen(&bind.CallOpts{Context: ctx})
-}
-
-func (fc *FaultCaller) LogClaimDataLength(ctx context.Context) {
-	claimLen, err := fc.GetClaimDataLength(ctx)
+// GetClaimCount returns the number of claims in the game.
+func (fc *FaultCaller) GetClaimCount(ctx context.Context) (uint64, error) {
+	count, err := fc.contract.ClaimDataLen(&bind.CallOpts{Context: ctx})
 	if err != nil {
-		fc.log.Error("failed to get claim count", "err", err)
-		return
+		return 0, err
 	}
-	fc.log.Info("Number of claims", "length", claimLen)
+	return count.Uint64(), nil
 }

op-challenger/fault/caller_test.go

@@ -64,7 +64,7 @@ func TestFaultCaller_GetGameStatus(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			fc := NewFaultCaller(test.caller, nil)
+			fc := NewFaultCaller(test.caller)
 			status, err := fc.GetGameStatus(context.Background())
 			require.Equal(t, test.expectedStatus, status)
 			require.Equal(t, test.expectedErr, err)
@@ -72,11 +72,11 @@ func TestFaultCaller_GetGameStatus(t *testing.T) {
 	}
 }
 
-func TestFaultCaller_GetClaimDataLength(t *testing.T) {
+func TestFaultCaller_GetClaimCount(t *testing.T) {
 	tests := []struct {
 		name                 string
 		caller               FaultDisputeGameCaller
-		expectedClaimDataLen *big.Int
+		expectedClaimDataLen uint64
 		expectedErr          error
 	}{
 		{
@@ -84,7 +84,7 @@ func TestFaultCaller_GetClaimDataLength(t *testing.T) {
 			caller: &mockFaultDisputeGameCaller{
 				claimDataLen: big.NewInt(1),
 			},
-			expectedClaimDataLen: big.NewInt(1),
+			expectedClaimDataLen: 1,
 			expectedErr:          nil,
 		},
 		{
@@ -92,15 +92,15 @@ func TestFaultCaller_GetClaimDataLength(t *testing.T) {
 			caller: &mockFaultDisputeGameCaller{
 				errClaimDataLen: true,
 			},
-			expectedClaimDataLen: nil,
+			expectedClaimDataLen: 0,
 			expectedErr:          errMock,
 		},
 	}
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			fc := NewFaultCaller(test.caller, nil)
-			claimDataLen, err := fc.GetClaimDataLength(context.Background())
+			fc := NewFaultCaller(test.caller)
+			claimDataLen, err := fc.GetClaimCount(context.Background())
 			require.Equal(t, test.expectedClaimDataLen, claimDataLen)
 			require.Equal(t, test.expectedErr, err)
 		})

op-challenger/fault/cannon/executor.go

@@ -39,7 +39,6 @@ type Executor struct {
 	rollupConfig     string
 	l2Genesis        string
 	absolutePreState string
-	dataDir          string
 	snapshotFreq     uint
 	selectSnapshot   snapshotSelect
 	cmdExecutor      cmdExecutor
@@ -57,7 +56,6 @@ func NewExecutor(logger log.Logger, cfg *config.Config, inputs LocalGameInputs)
 		rollupConfig:     cfg.CannonRollupConfigPath,
 		l2Genesis:        cfg.CannonL2GenesisPath,
 		absolutePreState: cfg.CannonAbsolutePreState,
-		dataDir:          cfg.CannonDatadir,
 		snapshotFreq:     cfg.CannonSnapshotFreq,
 		selectSnapshot:   findStartingSnapshot,
 		cmdExecutor:      runCmd,
@@ -71,7 +69,7 @@ func (e *Executor) GenerateProof(ctx context.Context, dir string, i uint64) erro
 		return fmt.Errorf("find starting snapshot: %w", err)
 	}
 	proofDir := filepath.Join(dir, proofsDir)
-	dataDir := filepath.Join(e.dataDir, preimagesDir)
+	dataDir := filepath.Join(dir, preimagesDir)
 	lastGeneratedState := filepath.Join(dir, finalState)
 	args := []string{
 		"run",

op-challenger/fault/cannon/executor_test.go

@@ -22,7 +22,9 @@ const execTestCannonPrestate = "/foo/pre.json"
 func TestGenerateProof(t *testing.T) {
 	input := "starting.json"
 	cfg := config.NewConfig(common.Address{0xbb}, "http://localhost:8888", config.TraceTypeCannon, true)
-	cfg.CannonDatadir = t.TempDir()
+	tempDir := t.TempDir()
+	dir := filepath.Join(tempDir, "gameDir")
+	cfg.CannonDatadir = tempDir
 	cfg.CannonAbsolutePreState = "pre.json"
 	cfg.CannonBin = "./bin/cannon"
 	cfg.CannonServer = "./bin/op-program"
@@ -58,7 +60,7 @@ func TestGenerateProof(t *testing.T) {
 			}
 			return nil
 		}
-		err := executor.GenerateProof(context.Background(), cfg.CannonDatadir, proofAt)
+		err := executor.GenerateProof(context.Background(), dir, proofAt)
 		require.NoError(t, err)
 		return binary, subcommand, args
 	}
@@ -68,15 +70,15 @@ func TestGenerateProof(t *testing.T) {
 		cfg.CannonRollupConfigPath = ""
 		cfg.CannonL2GenesisPath = ""
 		binary, subcommand, args := captureExec(t, cfg, 150_000_000)
-		require.DirExists(t, filepath.Join(cfg.CannonDatadir, preimagesDir))
-		require.DirExists(t, filepath.Join(cfg.CannonDatadir, proofsDir))
-		require.DirExists(t, filepath.Join(cfg.CannonDatadir, snapsDir))
+		require.DirExists(t, filepath.Join(dir, preimagesDir))
+		require.DirExists(t, filepath.Join(dir, proofsDir))
+		require.DirExists(t, filepath.Join(dir, snapsDir))
 		require.Equal(t, cfg.CannonBin, binary)
 		require.Equal(t, "run", subcommand)
 		require.Equal(t, input, args["--input"])
 		require.Contains(t, args, "--meta")
 		require.Equal(t, "", args["--meta"])
-		require.Equal(t, filepath.Join(cfg.CannonDatadir, finalState), args["--output"])
+		require.Equal(t, filepath.Join(dir, finalState), args["--output"])
 		require.Equal(t, "=150000000", args["--proof-at"])
 		require.Equal(t, "=150000001", args["--stop-at"])
 		require.Equal(t, "%500", args["--snapshot-at"])
@@ -86,9 +88,9 @@ func TestGenerateProof(t *testing.T) {
 		require.Equal(t, "--server", args[cfg.CannonServer])
 		require.Equal(t, cfg.L1EthRpc, args["--l1"])
 		require.Equal(t, cfg.CannonL2, args["--l2"])
-		require.Equal(t, filepath.Join(cfg.CannonDatadir, preimagesDir), args["--datadir"])
-		require.Equal(t, filepath.Join(cfg.CannonDatadir, proofsDir, "%d.json"), args["--proof-fmt"])
-		require.Equal(t, filepath.Join(cfg.CannonDatadir, snapsDir, "%d.json"), args["--snapshot-fmt"])
+		require.Equal(t, filepath.Join(dir, preimagesDir), args["--datadir"])
+		require.Equal(t, filepath.Join(dir, proofsDir, "%d.json"), args["--proof-fmt"])
+		require.Equal(t, filepath.Join(dir, snapsDir, "%d.json"), args["--snapshot-fmt"])
 		require.Equal(t, cfg.CannonNetwork, args["--network"])
 		require.NotContains(t, args, "--rollup.config")
 		require.NotContains(t, args, "--l2.genesis")

op-challenger/fault/cannon/provider.go

@@ -64,13 +64,14 @@ func NewTraceProvider(ctx context.Context, logger log.Logger, cfg *config.Config
 	if err != nil {
 		return nil, fmt.Errorf("fetch local game inputs: %w", err)
 	}
-	return NewTraceProviderFromInputs(logger, cfg, localInputs), nil
+	return NewTraceProviderFromInputs(logger, cfg, gameAddr.Hex(), localInputs), nil
 }
 
-func NewTraceProviderFromInputs(logger log.Logger, cfg *config.Config, localInputs LocalGameInputs) *CannonTraceProvider {
+func NewTraceProviderFromInputs(logger log.Logger, cfg *config.Config, gameDirName string, localInputs LocalGameInputs) *CannonTraceProvider {
+	dir := filepath.Join(cfg.CannonDatadir, gameDirName)
 	return &CannonTraceProvider{
 		logger:    logger,
-		dir:       cfg.CannonDatadir,
+		dir:       dir,
 		prestate:  cfg.CannonAbsolutePreState,
 		generator: NewExecutor(logger, cfg, localInputs),
 	}

op-challenger/fault/cannon/provider_test.go

@@ -11,6 +11,7 @@ import (
 	"testing"
 
 	"github.com/ethereum-optimism/optimism/cannon/mipsevm"
+	"github.com/ethereum-optimism/optimism/op-challenger/config"
 	"github.com/ethereum-optimism/optimism/op-challenger/fault/types"
 	"github.com/ethereum-optimism/optimism/op-node/testlog"
 	"github.com/ethereum/go-ethereum/common"
@@ -149,7 +150,6 @@ func TestGetStepData(t *testing.T) {
 
 func TestAbsolutePreState(t *testing.T) {
 	dataDir := t.TempDir()
-	_ = os.Mkdir(dataDir, 0o777)
 
 	prestate := "state.json"
 
@@ -189,6 +189,21 @@ func TestAbsolutePreState(t *testing.T) {
 	})
 }
 
+func TestUseGameSpecificSubdir(t *testing.T) {
+	tempDir := t.TempDir()
+	dataDir := filepath.Join(tempDir, "data")
+	setupPreState(t, tempDir, "state.json")
+	logger := testlog.Logger(t, log.LvlInfo)
+	cfg := &config.Config{
+		CannonAbsolutePreState: filepath.Join(tempDir, "state.json"),
+		CannonDatadir:          dataDir,
+	}
+	gameDirName := "gameSubdir"
+	localInputs := LocalGameInputs{}
+	provider := NewTraceProviderFromInputs(logger, cfg, gameDirName, localInputs)
+	require.Equal(t, filepath.Join(dataDir, gameDirName), provider.dir, "should use game specific subdir")
+}
+
 func setupPreState(t *testing.T, dataDir string, filename string) {
 	srcDir := filepath.Join("test_data")
 	path := filepath.Join(srcDir, filename)

op-challenger/fault/monitor.go

@@ -6,6 +6,7 @@ import (
 	"math/big"
 	"time"
 
+	"github.com/ethereum-optimism/optimism/op-service/clock"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
 )
@@ -24,6 +25,7 @@ type gameSource interface {
 
 type gameMonitor struct {
 	logger           log.Logger
+	clock            clock.Clock
 	source           gameSource
 	createPlayer     playerCreator
 	fetchBlockNumber blockNumberFetcher
@@ -31,9 +33,10 @@ type gameMonitor struct {
 	players          map[common.Address]gamePlayer
 }
 
-func newGameMonitor(logger log.Logger, fetchBlockNumber blockNumberFetcher, allowedGame common.Address, source gameSource, createGame playerCreator) *gameMonitor {
+func newGameMonitor(logger log.Logger, cl clock.Clock, fetchBlockNumber blockNumberFetcher, allowedGame common.Address, source gameSource, createGame playerCreator) *gameMonitor {
 	return &gameMonitor{
 		logger:           logger,
+		clock:            cl,
 		source:           source,
 		createPlayer:     createGame,
 		fetchBlockNumber: fetchBlockNumber,
@@ -86,11 +89,8 @@ func (m *gameMonitor) MonitorGames(ctx context.Context) error {
 		if err != nil {
 			m.logger.Error("Failed to progress games", "err", err)
 		}
-		select {
-		case <-time.After(300 * time.Millisecond):
-		// Continue
-		case <-ctx.Done():
-			return ctx.Err()
+		if err := m.clock.SleepCtx(ctx, 300*time.Millisecond); err != nil {
+			return err
 		}
 	}
 }

op-challenger/fault/monitor_test.go

@@ -5,6 +5,7 @@ import (
 	"math/big"
 	"testing"
 
+	"github.com/ethereum-optimism/optimism/op-service/clock"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/stretchr/testify/require"
@@ -86,7 +87,7 @@ func setupMonitorTest(t *testing.T, allowedGame common.Address) (*gameMonitor, *
 	fetchBlockNum := func(ctx context.Context) (uint64, error) {
 		return 1234, nil
 	}
-	monitor := newGameMonitor(logger, fetchBlockNum, allowedGame, source, games.CreateGame)
+	monitor := newGameMonitor(logger, clock.SystemClock, fetchBlockNum, allowedGame, source, games.CreateGame)
 	return monitor, source, games
 }
 

op-challenger/fault/game.go → op-challenger/fault/player.go

@@ -21,7 +21,7 @@ type Actor interface {
 
 type GameInfo interface {
 	GetGameStatus(context.Context) (types.GameStatus, error)
-	LogGameInfo(ctx context.Context)
+	GetClaimCount(context.Context) (uint64, error)
 }
 
 type GamePlayer struct {
@@ -80,7 +80,7 @@ func NewGamePlayer(
 		return nil, fmt.Errorf("failed to create the responder: %w", err)
 	}
 
-	caller, err := NewFaultCallerFromBindings(addr, client, logger)
+	caller, err := NewFaultCallerFromBindings(addr, client)
 	if err != nil {
 		return nil, fmt.Errorf("failed to bind the fault contract: %w", err)
 	}
@@ -100,21 +100,32 @@ func (g *GamePlayer) ProgressGame(ctx context.Context) bool {
 	}
 	if status, err := g.caller.GetGameStatus(ctx); err != nil {
 		g.logger.Warn("Unable to retrieve game status", "err", err)
-	} else if status != 0 {
-		var expectedStatus types.GameStatus
-		if g.agreeWithProposedOutput {
-			expectedStatus = types.GameStatusChallengerWon
-		} else {
-			expectedStatus = types.GameStatusDefenderWon
-		}
-		if expectedStatus == status {
-			g.logger.Info("Game won", "status", status)
-		} else {
-			g.logger.Error("Game lost", "status", status)
-		}
-		return true
 	} else {
-		g.caller.LogGameInfo(ctx)
+		g.logGameStatus(ctx, status)
+		return status != types.GameStatusInProgress
 	}
 	return false
 }
+
+func (g *GamePlayer) logGameStatus(ctx context.Context, status types.GameStatus) {
+	if status == types.GameStatusInProgress {
+		claimCount, err := g.caller.GetClaimCount(ctx)
+		if err != nil {
+			g.logger.Error("Failed to get claim count for in progress game", "err", err)
+			return
+		}
+		g.logger.Info("Game info", "claims", claimCount, "status", status)
+		return
+	}
+	var expectedStatus types.GameStatus
+	if g.agreeWithProposedOutput {
+		expectedStatus = types.GameStatusChallengerWon
+	} else {
+		expectedStatus = types.GameStatusDefenderWon
+	}
+	if expectedStatus == status {
+		g.logger.Info("Game won", "status", status)
+	} else {
+		g.logger.Error("Game lost", "status", status)
+	}
+}

op-challenger/fault/game_test.go → op-challenger/fault/player_test.go

@@ -11,27 +11,23 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-func TestProgressGameAndLogState(t *testing.T) {
-	_, game, actor, gameInfo := setupProgressGameTest(t, true)
-	done := game.ProgressGame(context.Background())
-	require.False(t, done, "should not be done")
-	require.Equal(t, 1, actor.callCount, "should perform next actions")
-	require.Equal(t, 1, gameInfo.logCount, "should log latest game state")
-}
-
 func TestProgressGame_LogErrorFromAct(t *testing.T) {
-	handler, game, actor, gameInfo := setupProgressGameTest(t, true)
+	handler, game, actor, _ := setupProgressGameTest(t, true)
 	actor.err = errors.New("boom")
 	done := game.ProgressGame(context.Background())
 	require.False(t, done, "should not be done")
 	require.Equal(t, 1, actor.callCount, "should perform next actions")
-	require.Equal(t, 1, gameInfo.logCount, "should log latest game state")
 	errLog := handler.FindLog(log.LvlError, "Error when acting on game")
 	require.NotNil(t, errLog, "should log error")
 	require.Equal(t, actor.err, errLog.GetContextValue("err"))
+
+	// Should still log game status
+	msg := handler.FindLog(log.LvlInfo, "Game info")
+	require.NotNil(t, msg)
+	require.Equal(t, uint64(1), msg.GetContextValue("claims"))
 }
 
-func TestProgressGame_LogErrorWhenGameLost(t *testing.T) {
+func TestProgressGame_LogGameStatus(t *testing.T) {
 	tests := []struct {
 		name            string
 		status          types.GameStatus
@@ -67,16 +63,23 @@ func TestProgressGame_LogErrorWhenGameLost(t *testing.T) {
 			logLevel:        log.LvlInfo,
 			logMsg:          "Game won",
 		},
+		{
+			name:            "GameInProgress",
+			status:          types.GameStatusInProgress,
+			agreeWithOutput: true,
+			logLevel:        log.LvlInfo,
+			logMsg:          "Game info",
+		},
 	}
 	for _, test := range tests {
 		test := test
 		t.Run(test.name, func(t *testing.T) {
-			handler, game, _, gameInfo := setupProgressGameTest(t, test.agreeWithOutput)
+			handler, game, actor, gameInfo := setupProgressGameTest(t, test.agreeWithOutput)
 			gameInfo.status = test.status
 
 			done := game.ProgressGame(context.Background())
-			require.True(t, done, "should be done")
-			require.Equal(t, 0, gameInfo.logCount, "should not log latest game state")
+			require.Equal(t, 1, actor.callCount, "should perform next actions")
+			require.Equal(t, test.status != types.GameStatusInProgress, done, "should be done when not in progress")
 			errLog := handler.FindLog(test.logLevel, test.logMsg)
 			require.NotNil(t, errLog, "should log game result")
 			require.Equal(t, test.status, errLog.GetContextValue("status"))
@@ -91,7 +94,7 @@ func setupProgressGameTest(t *testing.T, agreeWithProposedRoot bool) (*testlog.C
 	}
 	logger.SetHandler(handler)
 	actor := &stubActor{}
-	gameInfo := &stubGameInfo{}
+	gameInfo := &stubGameInfo{claimCount: 1}
 	game := &GamePlayer{
 		agent:                   actor,
 		agreeWithProposedOutput: agreeWithProposedRoot,
@@ -112,15 +115,15 @@ func (a *stubActor) Act(ctx context.Context) error {
 }
 
 type stubGameInfo struct {
-	status   types.GameStatus
-	err      error
-	logCount int
+	status     types.GameStatus
+	claimCount uint64
+	err        error
 }
 
 func (s *stubGameInfo) GetGameStatus(ctx context.Context) (types.GameStatus, error) {
 	return s.status, s.err
 }
 
-func (s *stubGameInfo) LogGameInfo(ctx context.Context) {
-	s.logCount++
+func (s *stubGameInfo) GetClaimCount(ctx context.Context) (uint64, error) {
+	return s.claimCount, s.err
 }

op-challenger/fault/service.go

@@ -11,6 +11,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
 	"github.com/ethereum-optimism/optimism/op-challenger/version"
 	"github.com/ethereum-optimism/optimism/op-service/client"
+	"github.com/ethereum-optimism/optimism/op-service/clock"
 	oppprof "github.com/ethereum-optimism/optimism/op-service/pprof"
 	"github.com/ethereum-optimism/optimism/op-service/txmgr"
 	"github.com/ethereum/go-ethereum/common"
@@ -33,6 +34,7 @@ type service struct {
 
 // NewService creates a new Service.
 func NewService(ctx context.Context, logger log.Logger, cfg *config.Config) (*service, error) {
+	cl := clock.SystemClock
 	m := metrics.NewMetrics()
 	txMgr, err := txmgr.NewSimpleTxManager("challenger", logger, &m.TxMetrics, cfg.TxMgrConfig)
 	if err != nil {
@@ -71,7 +73,7 @@ func NewService(ctx context.Context, logger log.Logger, cfg *config.Config) (*se
 	}
 	loader := NewGameLoader(factory)
 
-	monitor := newGameMonitor(logger, client.BlockNumber, cfg.GameAddress, loader, func(addr common.Address) (gamePlayer, error) {
+	monitor := newGameMonitor(logger, cl, client.BlockNumber, cfg.GameAddress, loader, func(addr common.Address) (gamePlayer, error) {
 		return NewGamePlayer(ctx, logger, cfg, addr, txMgr, client)
 	})
 

op-challenger/fault/types/game.go

@@ -60,7 +60,7 @@ func NewGameState(agreeWithProposedOutput bool, root Claim, depth uint64) *gameS
 	}
 }
 
-// AgreeWithLevel returns if the game state agrees with the provided claim level.
+// AgreeWithClaimLevel returns if the game state agrees with the provided claim level.
 func (g *gameState) AgreeWithClaimLevel(claim Claim) bool {
 	isOddLevel := claim.Depth()%2 == 1
 	// If we agree with the proposed output, we agree with odd levels

op-challenger/scripts/alphabet/init_game.sh

@@ -78,8 +78,8 @@ cast call $L2_OUTPUT_ORACLE_PROXY "getL2Output(uint256)" $PRIOR_INDEX
 echo "Getting the l2 output at index $INDEX"
 cast call $L2_OUTPUT_ORACLE_PROXY "getL2Output(uint256)" $INDEX
 
-# (Alphabet) Fault game type = 0
-GAME_TYPE=0
+# (Alphabet) Fault game type = 255
+GAME_TYPE=255
 
 # Root claim commits to the entire trace.
 # Alphabet game claim construction: keccak256(abi.encode(trace_index, trace[trace_index]))

op-e2e/e2eutils/disputegame/helper.go

@@ -26,8 +26,8 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-const alphabetGameType uint8 = 0
-const cannonGameType uint8 = 1
+const alphabetGameType uint8 = 255
+const cannonGameType uint8 = 0
 const alphabetGameDepth = 4
 const lastAlphabetTraceIndex = 1<<alphabetGameDepth - 1
 
@@ -170,7 +170,7 @@ func (h *FactoryHelper) StartCannonGameWithCorrectRoot(ctx context.Context, roll
 		L2Claim:       challengedOutput.OutputRoot,
 		L2BlockNumber: challengedOutput.L2BlockNumber,
 	}
-	provider := cannon.NewTraceProviderFromInputs(testlog.Logger(h.t, log.LvlInfo).New("role", "CorrectTrace"), cfg, inputs)
+	provider := cannon.NewTraceProviderFromInputs(testlog.Logger(h.t, log.LvlInfo).New("role", "CorrectTrace"), cfg, "correct", inputs)
 	rootClaim, err := provider.Get(ctx, math.MaxUint64)
 	h.require.NoError(err, "Compute correct root hash")
 

op-e2e/e2eutils/wait/waits.go

@@ -56,7 +56,8 @@ func (s *jsonRawString) UnmarshalJSON(input []byte) error {
 // printDebugTrace logs debug_traceTransaction output to aid in debugging unexpected receipt statuses
 func printDebugTrace(ctx context.Context, client *ethclient.Client, txHash common.Hash) {
 	var trace jsonRawString
-	options := map[string]string{}
+	options := map[string]any{}
+	options["enableReturnData"] = true
 	err := client.Client().CallContext(ctx, &trace, "debug_traceTransaction", hexutil.Bytes(txHash.Bytes()), options)
 	if err != nil {
 		fmt.Printf("TxTrace unavailable: %v\n", err)

op-e2e/faultproof_test.go

@@ -50,7 +50,6 @@ func TestMultipleAlphabetGames(t *testing.T) {
 }
 
 func TestMultipleCannonGames(t *testing.T) {
-	t.Skip("Cannon provider doesn't currently isolate different game traces")
 	InitParallel(t)
 
 	ctx := context.Background()

op-node/p2p/host.go

@@ -186,9 +186,6 @@ func (conf *Config) Host(log log.Logger, reporter metrics.Reporter, metrics Host
 	tcpTransport := libp2p.Transport(
 		tcp.NewTCPTransport,
 		tcp.WithConnectionTimeout(time.Minute*60)) // break unused connections
-	if err != nil {
-		return nil, fmt.Errorf("failed to create TCP transport: %w", err)
-	}
 	// TODO: technically we can also run the node on websocket and QUIC transports. Maybe in the future?
 
 	var nat lconf.NATManagerC // disabled if nil

op-service/clock/clock.go

 // Package clock provides an abstraction for time to enable testing of functionality that uses time as an input.
 package clock
 
-import "time"
+import (
+	"context"
+	"time"
+)
 
 // Clock represents time in a way that can be provided by varying implementations.
-// Methods are designed to be direct replacements for methods in the time package.
+// Methods are designed to be direct replacements for methods in the time package,
+// with some new additions to make common patterns simple.
 type Clock interface {
 	// Now provides the current local time. Equivalent to time.Now
 	Now() time.Time
@@ -26,6 +30,10 @@ type Clock interface {
 	// NewTimer creates a new Timer that will send
 	// the current time on its channel after at least duration d.
 	NewTimer(d time.Duration) Timer
+
+	// SleepCtx sleeps until either ctx is done or the specified duration has elapsed.
+	// Returns the ctx.Err if it returns because the context is done.
+	SleepCtx(ctx context.Context, d time.Duration) error
 }
 
 // A Ticker holds a channel that delivers "ticks" of a clock at intervals
@@ -104,3 +112,14 @@ func (t *SystemTimer) Ch() <-chan time.Time {
 func (s systemClock) AfterFunc(d time.Duration, f func()) Timer {
 	return &SystemTimer{time.AfterFunc(d, f)}
 }
+
+func (s systemClock) SleepCtx(ctx context.Context, d time.Duration) error {
+	timer := s.NewTimer(d)
+	defer timer.Stop()
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case <-timer.Ch():
+		return nil
+	}
+}

op-service/clock/clock_test.go

+package clock
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestSystemClock_SleepCtx(t *testing.T) {
+	t.Run("ReturnWhenContextDone", func(t *testing.T) {
+		ctx, cancel := context.WithCancel(context.Background())
+		cancel()
+		start := time.Now()
+		err := SystemClock.SleepCtx(ctx, 5*time.Minute)
+		end := time.Now()
+		require.ErrorIs(t, err, context.Canceled)
+		// The call shouldn't block for the 5 minutes, but use a high tolerance as test servers can be slow
+		// and clocks are inaccurate.
+		require.Less(t, end.Sub(start), time.Minute)
+	})
+
+	t.Run("ReturnAfterDuration", func(t *testing.T) {
+		start := time.Now()
+		err := SystemClock.SleepCtx(context.Background(), 100*time.Millisecond)
+		end := time.Now()
+		require.NoError(t, err)
+		// Require the call to sleep for at least a little. Use a high tolerance since clocks can be quite inaccurate.
+		require.Greater(t, end.Sub(start), 5*time.Millisecond, "should sleep at least a bit")
+	})
+}

op-service/clock/common.go

+package clock
+
+import (
+	"context"
+	"time"
+)
+
+func sleepCtx(ctx context.Context, d time.Duration, c Clock) error {
+	timer := c.NewTimer(d)
+	defer timer.Stop()
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case <-timer.Ch():
+		return nil
+	}
+}

op-service/clock/deterministic.go

@@ -195,6 +195,10 @@ func (s *DeterministicClock) NewTimer(d time.Duration) Timer {
 	return t
 }
 
+func (s *DeterministicClock) SleepCtx(ctx context.Context, d time.Duration) error {
+	return sleepCtx(ctx, d, s)
+}
+
 func (s *DeterministicClock) addPending(t action) {
 	s.pending = append(s.pending, t)
 	select {

op-service/clock/deterministic_test.go

@@ -315,3 +315,38 @@ func TestWaitForPending(t *testing.T) {
 		require.False(t, clock.WaitForNewPendingTask(ctx), "should have reset new pending task flag")
 	})
 }
+
+func TestSleepCtx(t *testing.T) {
+	t.Run("ReturnWhenContextComplete", func(t *testing.T) {
+		clock := NewDeterministicClock(time.UnixMilli(1000))
+		ctx, cancel := context.WithCancel(context.Background())
+		cancel()
+		err := clock.SleepCtx(ctx, 5*time.Minute)
+		require.ErrorIs(t, err, context.Canceled)
+	})
+
+	t.Run("ReturnWhenDurationComplete", func(t *testing.T) {
+		clock := NewDeterministicClock(time.UnixMilli(1000))
+		var wg sync.WaitGroup
+		var result atomic.Value
+		wg.Add(1)
+		go func() {
+			err := clock.SleepCtx(context.Background(), 5*time.Minute)
+			if err != nil {
+				result.Store(err)
+			}
+			wg.Done()
+		}()
+
+		ctx, cancelFunc := context.WithTimeout(context.Background(), 30*time.Second)
+		defer cancelFunc()
+		// Wait until the SleepCtx is called and schedules a pending task
+		clock.WaitForNewPendingTask(ctx)
+
+		clock.AdvanceTime(5 * time.Minute)
+
+		// Wait for the call to return
+		wg.Wait()
+		require.Nil(t, result.Load())
+	})
+}

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

@@ -76,7 +76,8 @@ contract Deploy is Deployer {
         initializeL2OutputOracle();
         initializeOptimismPortal();
 
-        setFaultGameImplementation();
+        setAlphabetFaultGameImplementation();
+        setCannonFaultGameImplementation();
 
         transferProxyAdminOwnership();
         transferDisputeGameFactoryOwnership();
@@ -759,47 +760,89 @@ contract Deploy is Deployer {
     }
 
     /// @notice Sets the implementation for the `FAULT` game type in the `DisputeGameFactory`
-    function setFaultGameImplementation() public onlyDevnet broadcast {
-        // Create the absolute prestate dump
-        string memory filePath = string.concat(vm.projectRoot(), "/../../op-program/bin/prestate-proof.json");
-        bytes32 mipsAbsolutePrestate;
-        string[] memory commands = new string[](3);
-        commands[0] = "bash";
-        commands[1] = "-c";
-        commands[2] = string.concat("[[ -f ", filePath, " ]] && echo \"present\"");
-        if (vm.ffi(commands).length == 0) {
-            revert("Cannon prestate dump not found, generate it with `make cannon-prestate` in the monorepo root.");
+    function setCannonFaultGameImplementation() public onlyDevnet broadcast {
+        DisputeGameFactory factory = DisputeGameFactory(mustGetAddress("DisputeGameFactoryProxy"));
+
+        Claim mipsAbsolutePrestate;
+        if (block.chainid == Chains.LocalDevnet || block.chainid == Chains.GethDevnet) {
+            // Fetch the absolute prestate dump
+            string memory filePath = string.concat(vm.projectRoot(), "/../../op-program/bin/prestate-proof.json");
+            string[] memory commands = new string[](3);
+            commands[0] = "bash";
+            commands[1] = "-c";
+            commands[2] = string.concat("[[ -f ", filePath, " ]] && echo \"present\"");
+            if (vm.ffi(commands).length == 0) {
+                revert("Cannon prestate dump not found, generate it with `make cannon-prestate` in the monorepo root.");
+            }
+            commands[2] = string.concat("cat ", filePath, " | jq -r .pre");
+            mipsAbsolutePrestate = Claim.wrap(abi.decode(vm.ffi(commands), (bytes32)));
+            console.log(
+                "[Cannon Dispute Game] Using devnet MIPS Absolute prestate: %s",
+                vm.toString(Claim.unwrap(mipsAbsolutePrestate))
+            );
+        } else {
+            console.log(
+                "[Cannon Dispute Game] Using absolute prestate from config: %s", cfg.faultGameAbsolutePrestate()
+            );
+            mipsAbsolutePrestate = Claim.wrap(bytes32(cfg.faultGameAbsolutePrestate()));
         }
-        commands[2] = string.concat("cat ", filePath, " | jq -r .pre");
-        mipsAbsolutePrestate = abi.decode(vm.ffi(commands), (bytes32));
-        console.log("Absolute prestate: %s", vm.toString(mipsAbsolutePrestate));
 
+        // Set the Cannon FaultDisputeGame implementation in the factory.
+        _setFaultGameImplementation(
+            factory, GameTypes.FAULT, mipsAbsolutePrestate, IBigStepper(mustGetAddress("Mips")), cfg.faultGameMaxDepth()
+        );
+    }
+
+    /// @notice Sets the implementation for the alphabet game type in the `DisputeGameFactory`
+    function setAlphabetFaultGameImplementation() public onlyDevnet broadcast {
         DisputeGameFactory factory = DisputeGameFactory(mustGetAddress("DisputeGameFactoryProxy"));
-        for (uint8 i; i < 2; i++) {
-            Claim absolutePrestate =
-                Claim.wrap(i == 0 ? bytes32(cfg.faultGameAbsolutePrestate()) : mipsAbsolutePrestate);
-            IBigStepper faultVm =
-                IBigStepper(i == 0 ? address(new AlphabetVM(absolutePrestate)) : mustGetAddress("Mips"));
-            GameType gameType = GameType.wrap(i);
-            if (address(factory.gameImpls(gameType)) == address(0)) {
-                factory.setImplementation(
-                    gameType,
-                    new FaultDisputeGame({
-                    _gameType: gameType,
-                    _absolutePrestate: absolutePrestate,
-                    _maxGameDepth: i == 0 ? 4 : cfg.faultGameMaxDepth(), // The max depth of the alphabet game is always 4
+
+        // Set the Alphabet FaultDisputeGame implementation in the factory.
+        Claim alphabetAbsolutePrestate = Claim.wrap(bytes32(cfg.faultGameAbsolutePrestate()));
+        _setFaultGameImplementation(
+            factory,
+            GameType.wrap(255),
+            alphabetAbsolutePrestate,
+            IBigStepper(new AlphabetVM(alphabetAbsolutePrestate)),
+            4 // The max game depth of the alphabet game is always 4.
+        );
+    }
+
+    /// @notice Sets the implementation for the given fault game type in the `DisputeGameFactory`.
+    function _setFaultGameImplementation(
+        DisputeGameFactory _factory,
+        GameType _gameType,
+        Claim _absolutePrestate,
+        IBigStepper _faultVm,
+        uint256 _maxGameDepth
+    )
+        internal
+    {
+        if (address(_factory.gameImpls(_gameType)) == address(0)) {
+            _factory.setImplementation(
+                _gameType,
+                new FaultDisputeGame({
+                    _gameType: _gameType,
+                    _absolutePrestate: _absolutePrestate,
+                    _maxGameDepth: _maxGameDepth,
                     _gameDuration: Duration.wrap(uint64(cfg.faultGameMaxDuration())),
-                    _vm: faultVm,
+                    _vm: _faultVm,
                     _l2oo: L2OutputOracle(mustGetAddress("L2OutputOracleProxy")),
                     _blockOracle: BlockOracle(mustGetAddress("BlockOracle"))
-                    })
-                );
-                console.log(
-                    "DisputeGameFactoryProxy: set `FaultDisputeGame` implementation (Backend: %s | GameType: %s)",
-                    i == 0 ? "AlphabetVM" : "MIPS",
-                    vm.toString(i)
-                );
-            }
+                })
+            );
+
+            uint8 rawGameType = GameType.unwrap(_gameType);
+            console.log(
+                "DisputeGameFactoryProxy: set `FaultDisputeGame` implementation (Backend: %s | GameType: %s)",
+                rawGameType == 0 ? "Cannon" : "Alphabet",
+                vm.toString(rawGameType)
+            );
+        } else {
+            console.log(
+                "[WARN] DisputeGameFactoryProxy: `FaultDisputeGame` implementation already set for game type: %s",
+                vm.toString(GameType.unwrap(_gameType))
+            );
         }
     }
 }

proxyd/backend.go

@@ -17,14 +17,14 @@ import (
 	"sync"
 	"time"
 
-	sw "github.com/ethereum-optimism/optimism/proxyd/pkg/avg-sliding-window"
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/ethereum/go-ethereum/rpc"
-
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/gorilla/websocket"
 	"github.com/prometheus/client_golang/prometheus"
 	"golang.org/x/sync/semaphore"
+
+	sw "github.com/ethereum-optimism/optimism/proxyd/pkg/avg-sliding-window"
 )
 
 const (
@@ -138,6 +138,7 @@ type Backend struct {
 	proxydIP             string
 
 	skipPeerCountCheck bool
+	forcedCandidate    bool
 
 	maxDegradedLatencyThreshold time.Duration
 	maxLatencyThreshold         time.Duration
@@ -220,6 +221,12 @@ func WithConsensusSkipPeerCountCheck(skipPeerCountCheck bool) BackendOpt {
 	}
 }
 
+func WithConsensusForcedCandidate(forcedCandidate bool) BackendOpt {
+	return func(b *Backend) {
+		b.forcedCandidate = forcedCandidate
+	}
+}
+
 func WithMaxDegradedLatencyThreshold(maxDegradedLatencyThreshold time.Duration) BackendOpt {
 	return func(b *Backend) {
 		b.maxDegradedLatencyThreshold = maxDegradedLatencyThreshold
@@ -675,9 +682,10 @@ func (bg *BackendGroup) Forward(ctx context.Context, rpcReqs []*RPCReq, isBatch
 
 		// We also rewrite block tags to enforce compliance with consensus
 		rctx := RewriteContext{
-			latest:    bg.Consensus.GetLatestBlockNumber(),
-			safe:      bg.Consensus.GetSafeBlockNumber(),
-			finalized: bg.Consensus.GetFinalizedBlockNumber(),
+			latest:        bg.Consensus.GetLatestBlockNumber(),
+			safe:          bg.Consensus.GetSafeBlockNumber(),
+			finalized:     bg.Consensus.GetFinalizedBlockNumber(),
+			maxBlockRange: bg.Consensus.maxBlockRange,
 		}
 
 		for i, req := range rpcReqs {
@@ -692,6 +700,10 @@ func (bg *BackendGroup) Forward(ctx context.Context, rpcReqs []*RPCReq, isBatch
 				})
 				if errors.Is(err, ErrRewriteBlockOutOfRange) {
 					res.Error = ErrBlockOutOfRange
+				} else if errors.Is(err, ErrRewriteRangeTooLarge) {
+					res.Error = ErrInvalidParams(
+						fmt.Sprintf("block range greater than %d max", rctx.maxBlockRange),
+					)
 				} else {
 					res.Error = ErrParseErr
 				}

proxyd/config.go

@@ -93,6 +93,7 @@ type BackendConfig struct {
 	StripTrailingXFF bool   `toml:"strip_trailing_xff"`
 
 	ConsensusSkipPeerCountCheck bool   `toml:"consensus_skip_peer_count"`
+	ConsensusForcedCandidate    bool   `toml:"consensus_forced_candidate"`
 	ConsensusReceiptsTarget     string `toml:"consensus_receipts_target"`
 }
 
@@ -107,6 +108,7 @@ type BackendGroupConfig struct {
 	ConsensusBanPeriod          TOMLDuration `toml:"consensus_ban_period"`
 	ConsensusMaxUpdateThreshold TOMLDuration `toml:"consensus_max_update_threshold"`
 	ConsensusMaxBlockLag        uint64       `toml:"consensus_max_block_lag"`
+	ConsensusMaxBlockRange      uint64       `toml:"consensus_max_block_range"`
 	ConsensusMinPeerCount       int          `toml:"consensus_min_peer_count"`
 }
 

proxyd/consensus_poller.go

@@ -38,6 +38,7 @@ type ConsensusPoller struct {
 	banPeriod          time.Duration
 	maxUpdateThreshold time.Duration
 	maxBlockLag        uint64
+	maxBlockRange      uint64
 }
 
 type backendState struct {
@@ -201,6 +202,12 @@ func WithMaxBlockLag(maxBlockLag uint64) ConsensusOpt {
 	}
 }
 
+func WithMaxBlockRange(maxBlockRange uint64) ConsensusOpt {
+	return func(cp *ConsensusPoller) {
+		cp.maxBlockRange = maxBlockRange
+	}
+}
+
 func WithMinPeerCount(minPeerCount uint64) ConsensusOpt {
 	return func(cp *ConsensusPoller) {
 		cp.minPeerCount = minPeerCount
@@ -621,6 +628,10 @@ func (cp *ConsensusPoller) getConsensusCandidates() map[*Backend]*backendState {
 
 	for _, be := range cp.backendGroup.Backends {
 		bs := cp.getBackendState(be)
+		if be.forcedCandidate {
+			candidates[be] = bs
+			continue
+		}
 		if bs.IsBanned() {
 			continue
 		}

proxyd/go.mod

@@ -9,7 +9,6 @@ require (
 	github.com/ethereum/go-ethereum v1.12.0
 	github.com/go-redis/redis/v8 v8.11.4
 	github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb
-	github.com/google/uuid v1.3.0
 	github.com/gorilla/mux v1.8.0
 	github.com/gorilla/websocket v1.5.0
 	github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d
@@ -17,6 +16,7 @@ require (
 	github.com/prometheus/client_golang v1.14.0
 	github.com/rs/cors v1.8.2
 	github.com/stretchr/testify v1.8.1
+	github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7
 	golang.org/x/sync v0.1.0
 	gopkg.in/yaml.v3 v3.0.1
 )
@@ -37,6 +37,8 @@ require (
 	github.com/deckarep/golang-set/v2 v2.1.0 // indirect
 	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.0.1 // indirect
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
+	github.com/fsnotify/fsnotify v1.6.0 // indirect
+	github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff // indirect
 	github.com/getsentry/sentry-go v0.18.0 // indirect
 	github.com/go-ole/go-ole v1.2.6 // indirect
 	github.com/go-stack/stack v1.8.1 // indirect
@@ -44,8 +46,11 @@ require (
 	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/google/uuid v1.3.0 // indirect
 	github.com/holiman/bloomfilter/v2 v2.0.3 // indirect
 	github.com/holiman/uint256 v1.2.2-0.20230321075855-87b91420868c // indirect
+	github.com/huin/goupnp v1.0.3 // indirect
+	github.com/jackpal/go-nat-pmp v1.0.2 // indirect
 	github.com/klauspost/compress v1.15.15 // indirect
 	github.com/kr/pretty v0.3.1 // indirect
 	github.com/kr/text v0.2.0 // indirect
@@ -59,9 +64,10 @@ require (
 	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
-	github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect
+	github.com/status-im/keycard-go v0.2.0 // indirect
 	github.com/tklauser/go-sysconf v0.3.10 // indirect
 	github.com/tklauser/numcpus v0.4.0 // indirect
+	github.com/tyler-smith/go-bip39 v1.1.0 // indirect
 	github.com/yuin/gopher-lua v0.0.0-20210529063254-f4c35e4016d9 // indirect
 	github.com/yusufpapurcu/wmi v1.2.2 // indirect
 	golang.org/x/crypto v0.1.0 // indirect

proxyd/proxyd.go

@@ -142,6 +142,7 @@ func Start(config *Config) (*Server, func(), error) {
 		}
 		opts = append(opts, WithProxydIP(os.Getenv("PROXYD_IP")))
 		opts = append(opts, WithConsensusSkipPeerCountCheck(cfg.ConsensusSkipPeerCountCheck))
+		opts = append(opts, WithConsensusForcedCandidate(cfg.ConsensusForcedCandidate))
 
 		receiptsTarget, err := ReadFromEnvOrConfig(cfg.ConsensusReceiptsTarget)
 		if err != nil {
@@ -308,6 +309,9 @@ func Start(config *Config) (*Server, func(), error) {
 			if bgcfg.ConsensusMinPeerCount > 0 {
 				copts = append(copts, WithMinPeerCount(uint64(bgcfg.ConsensusMinPeerCount)))
 			}
+			if bgcfg.ConsensusMaxBlockRange > 0 {
+				copts = append(copts, WithMaxBlockRange(bgcfg.ConsensusMaxBlockRange))
+			}
 
 			cp := NewConsensusPoller(bg, copts...)
 			bg.Consensus = cp

proxyd/rewriter.go

@@ -9,9 +9,10 @@ import (
 )
 
 type RewriteContext struct {
-	latest    hexutil.Uint64
-	safe      hexutil.Uint64
-	finalized hexutil.Uint64
+	latest        hexutil.Uint64
+	safe          hexutil.Uint64
+	finalized     hexutil.Uint64
+	maxBlockRange uint64
 }
 
 type RewriteResult uint8
@@ -32,6 +33,7 @@ const (
 
 var (
 	ErrRewriteBlockOutOfRange = errors.New("block is out of range")
+	ErrRewriteRangeTooLarge   = errors.New("block range is too large")
 )
 
 // RewriteTags modifies the request and the response based on block tags
@@ -121,6 +123,15 @@ func rewriteRange(rctx RewriteContext, req *RPCReq, res *RPCRes, pos int) (Rewri
 		return RewriteOverrideError, err
 	}
 
+	// if either fromBlock or toBlock is defined, default the other to "latest" if unset
+	_, hasFrom := p[pos]["fromBlock"]
+	_, hasTo := p[pos]["toBlock"]
+	if hasFrom && !hasTo {
+		p[pos]["toBlock"] = "latest"
+	} else if hasTo && !hasFrom {
+		p[pos]["fromBlock"] = "latest"
+	}
+
 	modifiedFrom, err := rewriteTagMap(rctx, p[pos], "fromBlock")
 	if err != nil {
 		return RewriteOverrideError, err
@@ -131,6 +142,20 @@ func rewriteRange(rctx RewriteContext, req *RPCReq, res *RPCRes, pos int) (Rewri
 		return RewriteOverrideError, err
 	}
 
+	if rctx.maxBlockRange > 0 && (hasFrom || hasTo) {
+		from, err := blockNumber(p[pos], "fromBlock", uint64(rctx.latest))
+		if err != nil {
+			return RewriteOverrideError, err
+		}
+		to, err := blockNumber(p[pos], "toBlock", uint64(rctx.latest))
+		if err != nil {
+			return RewriteOverrideError, err
+		}
+		if to-from > rctx.maxBlockRange {
+			return RewriteOverrideError, ErrRewriteRangeTooLarge
+		}
+	}
+
 	// if any of the fields the request have been changed, re-marshal the params
 	if modifiedFrom || modifiedTo {
 		paramsRaw, err := json.Marshal(p)
@@ -144,6 +169,21 @@ func rewriteRange(rctx RewriteContext, req *RPCReq, res *RPCRes, pos int) (Rewri
 	return RewriteNone, nil
 }
 
+func blockNumber(m map[string]interface{}, key string, latest uint64) (uint64, error) {
+	current, ok := m[key].(string)
+	if !ok {
+		return 0, errors.New("expected string")
+	}
+	// the latest/safe/finalized tags are already replaced by rewriteTag
+	if current == "earliest" {
+		return 0, nil
+	}
+	if current == "pending" {
+		return latest + 1, nil
+	}
+	return hexutil.DecodeUint64(current)
+}
+
 func rewriteTagMap(rctx RewriteContext, m map[string]interface{}, key string) (bool, error) {
 	if m[key] == nil || m[key] == "" {
 		return false, nil

proxyd/rewriter_test.go

@@ -48,7 +48,7 @@ func TestRewriteRequest(t *testing.T) {
 				req:  &RPCReq{Method: "eth_getLogs", Params: mustMarshalJSON([]map[string]interface{}{{"fromBlock": hexutil.Uint64(55).String()}})},
 				res:  nil,
 			},
-			expected: RewriteNone,
+			expected: RewriteOverrideRequest,
 			check: func(t *testing.T, args args) {
 				var p []map[string]interface{}
 				err := json.Unmarshal(args.req.Params, &p)
@@ -88,7 +88,7 @@ func TestRewriteRequest(t *testing.T) {
 				req:  &RPCReq{Method: "eth_getLogs", Params: mustMarshalJSON([]map[string]interface{}{{"toBlock": hexutil.Uint64(55).String()}})},
 				res:  nil,
 			},
-			expected: RewriteNone,
+			expected: RewriteOverrideRequest,
 			check: func(t *testing.T, args args) {
 				var p []map[string]interface{}
 				err := json.Unmarshal(args.req.Params, &p)
@@ -148,6 +148,62 @@ func TestRewriteRequest(t *testing.T) {
 			expected:    RewriteOverrideError,
 			expectedErr: ErrRewriteBlockOutOfRange,
 		},
+		{
+			name: "eth_getLogs fromBlock -> toBlock above max range",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100), maxBlockRange: 30},
+				req:  &RPCReq{Method: "eth_getLogs", Params: mustMarshalJSON([]map[string]interface{}{{"fromBlock": hexutil.Uint64(20).String(), "toBlock": hexutil.Uint64(80).String()}})},
+				res:  nil,
+			},
+			expected:    RewriteOverrideError,
+			expectedErr: ErrRewriteRangeTooLarge,
+		},
+		{
+			name: "eth_getLogs earliest -> latest above max range",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100), maxBlockRange: 30},
+				req:  &RPCReq{Method: "eth_getLogs", Params: mustMarshalJSON([]map[string]interface{}{{"fromBlock": "earliest", "toBlock": "latest"}})},
+				res:  nil,
+			},
+			expected:    RewriteOverrideError,
+			expectedErr: ErrRewriteRangeTooLarge,
+		},
+		{
+			name: "eth_getLogs earliest -> pending above max range",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100), maxBlockRange: 30},
+				req:  &RPCReq{Method: "eth_getLogs", Params: mustMarshalJSON([]map[string]interface{}{{"fromBlock": "earliest", "toBlock": "pending"}})},
+				res:  nil,
+			},
+			expected:    RewriteOverrideError,
+			expectedErr: ErrRewriteRangeTooLarge,
+		},
+		{
+			name: "eth_getLogs earliest -> default above max range",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100), maxBlockRange: 30},
+				req:  &RPCReq{Method: "eth_getLogs", Params: mustMarshalJSON([]map[string]interface{}{{"fromBlock": "earliest"}})},
+				res:  nil,
+			},
+			expected:    RewriteOverrideError,
+			expectedErr: ErrRewriteRangeTooLarge,
+		},
+		{
+			name: "eth_getLogs default -> latest within range",
+			args: args{
+				rctx: RewriteContext{latest: hexutil.Uint64(100), maxBlockRange: 30},
+				req:  &RPCReq{Method: "eth_getLogs", Params: mustMarshalJSON([]map[string]interface{}{{"toBlock": "latest"}})},
+				res:  nil,
+			},
+			expected: RewriteOverrideRequest,
+			check: func(t *testing.T, args args) {
+				var p []map[string]interface{}
+				err := json.Unmarshal(args.req.Params, &p)
+				require.Nil(t, err)
+				require.Equal(t, hexutil.Uint64(100).String(), p[0]["fromBlock"])
+				require.Equal(t, hexutil.Uint64(100).String(), p[0]["toBlock"])
+			},
+		},
 		/* required parameter at pos 0 */
 		{
 			name: "debug_getRawReceipts latest",