op-challenger: Add --game-factory-address CLI option.

Actual config value isn't actually used yet.

op-challenger/cmd/main_test.go

@@ -15,7 +15,7 @@ import (
 
 var (
 	l1EthRpc                = "http://example.com:8545"
-	gameAddressValue        = "0xaa00000000000000000000000000000000000000"
+	gameFactoryAddressValue = "0xbb00000000000000000000000000000000000000"
 	cannonNetwork           = chaincfg.AvailableNetworks()[0]
 	otherCannonNetwork      = chaincfg.AvailableNetworks()[1]
 	cannonBin               = "./bin/cannon"
@@ -44,14 +44,14 @@ func TestLogLevel(t *testing.T) {
 
 func TestDefaultCLIOptionsMatchDefaultConfig(t *testing.T) {
 	cfg := configForArgs(t, addRequiredArgs(config.TraceTypeAlphabet))
-	defaultCfg := config.NewConfig(l1EthRpc, common.HexToAddress(gameAddressValue), config.TraceTypeAlphabet, true)
+	defaultCfg := config.NewConfig(common.HexToAddress(gameFactoryAddressValue), l1EthRpc, config.TraceTypeAlphabet, true)
 	// Add in the extra CLI options required when using alphabet trace type
 	defaultCfg.AlphabetTrace = alphabetTrace
 	require.Equal(t, defaultCfg, cfg)
 }
 
 func TestDefaultConfigIsValid(t *testing.T) {
-	cfg := config.NewConfig(l1EthRpc, common.HexToAddress(gameAddressValue), config.TraceTypeAlphabet, true)
+	cfg := config.NewConfig(common.HexToAddress(gameFactoryAddressValue), l1EthRpc, config.TraceTypeAlphabet, true)
 	// Add in options that are required based on the specific trace type
 	// To avoid needing to specify unused options, these aren't included in the params for NewConfig
 	cfg.AlphabetTrace = alphabetTrace
@@ -89,9 +89,26 @@ func TestTraceType(t *testing.T) {
 	})
 }
 
-func TestGameAddress(t *testing.T) {
+func TestGameFactoryAddress(t *testing.T) {
 	t.Run("Required", func(t *testing.T) {
-		verifyArgsInvalid(t, "flag game-address is required", addRequiredArgsExcept(config.TraceTypeAlphabet, "--game-address"))
+		verifyArgsInvalid(t, "flag game-factory-address is required", addRequiredArgsExcept(config.TraceTypeAlphabet, "--game-factory-address"))
+	})
+
+	t.Run("Valid", func(t *testing.T) {
+		addr := common.Address{0xbb, 0xcc, 0xdd}
+		cfg := configForArgs(t, addRequiredArgsExcept(config.TraceTypeAlphabet, "--game-factory-address", "--game-factory-address="+addr.Hex()))
+		require.Equal(t, addr, cfg.GameFactoryAddress)
+	})
+
+	t.Run("Invalid", func(t *testing.T) {
+		verifyArgsInvalid(t, "invalid address: foo", addRequiredArgsExcept(config.TraceTypeAlphabet, "--game-factory-address", "--game-factory-address=foo"))
+	})
+}
+
+func TestGameAddress(t *testing.T) {
+	t.Run("Optional", func(t *testing.T) {
+		cfg := configForArgs(t, addRequiredArgsExcept(config.TraceTypeAlphabet, "--game-address"))
+		require.NoError(t, cfg.Check())
 	})
 
 	t.Run("Valid", func(t *testing.T) {
@@ -316,7 +333,7 @@ func requiredArgs(traceType config.TraceType) map[string]string {
 	args := map[string]string{
 		"--agree-with-proposed-output": agreeWithProposedOutput,
 		"--l1-eth-rpc":                 l1EthRpc,
-		"--game-address":               gameAddressValue,
+		"--game-factory-address":       gameFactoryAddressValue,
 		"--trace-type":                 traceType.String(),
 	}
 	switch traceType {

op-challenger/config/config.go

@@ -18,7 +18,7 @@ var (
 	ErrMissingCannonAbsolutePreState = errors.New("missing cannon absolute pre-state")
 	ErrMissingAlphabetTrace          = errors.New("missing alphabet trace")
 	ErrMissingL1EthRPC               = errors.New("missing l1 eth rpc url")
-	ErrMissingGameAddress            = errors.New("missing game address")
+	ErrMissingGameFactoryAddress     = errors.New("missing game factory address")
 	ErrMissingCannonSnapshotFreq     = errors.New("missing cannon snapshot freq")
 	ErrMissingCannonRollupConfig     = errors.New("missing cannon network or rollup config path")
 	ErrMissingCannonL2Genesis        = errors.New("missing cannon network or l2 genesis path")
@@ -65,6 +65,7 @@ const DefaultCannonSnapshotFreq = uint(1_000_000_000)
 // It is used to initialize the challenger.
 type Config struct {
 	L1EthRpc                string         // L1 RPC Url
+	GameFactoryAddress      common.Address // Address of the dispute game factory
 	GameAddress             common.Address // Address of the fault game
 	AgreeWithProposedOutput bool           // Temporary config if we agree or disagree with the posted output
 
@@ -88,14 +89,14 @@ type Config struct {
 }
 
 func NewConfig(
+	gameFactoryAddress common.Address,
 	l1EthRpc string,
-	gameAddress common.Address,
 	traceType TraceType,
 	agreeWithProposedOutput bool,
 ) Config {
 	return Config{
-		L1EthRpc:    l1EthRpc,
-		GameAddress: gameAddress,
+		L1EthRpc:           l1EthRpc,
+		GameFactoryAddress: gameFactoryAddress,
 
 		AgreeWithProposedOutput: agreeWithProposedOutput,
 
@@ -111,8 +112,8 @@ func (c Config) Check() error {
 	if c.L1EthRpc == "" {
 		return ErrMissingL1EthRPC
 	}
-	if c.GameAddress == (common.Address{}) {
-		return ErrMissingGameAddress
+	if c.GameFactoryAddress == (common.Address{}) {
+		return ErrMissingGameFactoryAddress
 	}
 	if c.TraceType == "" {
 		return ErrMissingTraceType

op-challenger/config/config_test.go

@@ -10,7 +10,7 @@ import (
 
 var (
 	validL1EthRpc              = "http://localhost:8545"
-	validGameAddress           = common.HexToAddress("0x7bdd3b028C4796eF0EAf07d11394d0d9d8c24139")
+	validGameFactoryAddress    = common.Address{0x23}
 	validAlphabetTrace         = "abcdefgh"
 	validCannonBin             = "./bin/cannon"
 	validCannonOpProgramBin    = "./bin/op-program"
@@ -22,7 +22,7 @@ var (
 )
 
 func validConfig(traceType TraceType) Config {
-	cfg := NewConfig(validL1EthRpc, validGameAddress, traceType, agreeWithProposedOutput)
+	cfg := NewConfig(validGameFactoryAddress, validL1EthRpc, traceType, agreeWithProposedOutput)
 	switch traceType {
 	case TraceTypeAlphabet:
 		cfg.AlphabetTrace = validAlphabetTrace
@@ -62,10 +62,16 @@ func TestL1EthRpcRequired(t *testing.T) {
 	require.ErrorIs(t, config.Check(), ErrMissingL1EthRPC)
 }
 
-func TestGameAddressRequired(t *testing.T) {
+func TestGameFactoryAddressRequired(t *testing.T) {
+	config := validConfig(TraceTypeCannon)
+	config.GameFactoryAddress = common.Address{}
+	require.ErrorIs(t, config.Check(), ErrMissingGameFactoryAddress)
+}
+
+func TestGameAddressNotRequired(t *testing.T) {
 	config := validConfig(TraceTypeCannon)
 	config.GameAddress = common.Address{}
-	require.ErrorIs(t, config.Check(), ErrMissingGameAddress)
+	require.NoError(t, config.Check())
 }
 
 func TestAlphabetTraceRequired(t *testing.T) {

op-challenger/fault/cannon/executor_test.go

@@ -21,7 +21,7 @@ const execTestCannonPrestate = "/foo/pre.json"
 
 func TestGenerateProof(t *testing.T) {
 	input := "starting.json"
-	cfg := config.NewConfig("http://localhost:8888", common.Address{0xaa}, config.TraceTypeCannon, true)
+	cfg := config.NewConfig(common.Address{0xbb}, "http://localhost:8888", config.TraceTypeCannon, true)
 	cfg.CannonDatadir = t.TempDir()
 	cfg.CannonAbsolutePreState = "pre.json"
 	cfg.CannonBin = "./bin/cannon"

op-challenger/flags/flags.go

@@ -10,6 +10,7 @@ import (
 	openum "github.com/ethereum-optimism/optimism/op-service/enum"
 	oplog "github.com/ethereum-optimism/optimism/op-service/log"
 	"github.com/ethereum-optimism/optimism/op-service/txmgr"
+	"github.com/ethereum/go-ethereum/common"
 
 	"github.com/urfave/cli/v2"
 )
@@ -29,6 +30,11 @@ var (
 		Usage:   "HTTP provider URL for L1.",
 		EnvVars: prefixEnvVars("L1_ETH_RPC"),
 	}
+	FactoryAddressFlag = &cli.StringFlag{
+		Name:    "game-factory-address",
+		Usage:   "Address of the fault game factory contract.",
+		EnvVars: prefixEnvVars("GAME_FACTORY_ADDRESS"),
+	}
 	DGFAddressFlag = &cli.StringFlag{
 		Name:    "game-address",
 		Usage:   "Address of the Fault Game contract.",
@@ -105,7 +111,7 @@ var (
 // requiredFlags are checked by [CheckRequired]
 var requiredFlags = []cli.Flag{
 	L1EthRpcFlag,
-	DGFAddressFlag,
+	FactoryAddressFlag,
 	TraceTypeFlag,
 	AgreeWithProposedOutputFlag,
 }
@@ -113,6 +119,7 @@ var requiredFlags = []cli.Flag{
 // optionalFlags is a list of unchecked cli flags
 var optionalFlags = []cli.Flag{
 	AlphabetFlag,
+	DGFAddressFlag,
 	CannonNetworkFlag,
 	CannonRollupConfigFlag,
 	CannonL2GenesisFlag,
@@ -181,10 +188,17 @@ func NewConfigFromCLI(ctx *cli.Context) (*config.Config, error) {
 	if err := CheckRequired(ctx); err != nil {
 		return nil, err
 	}
-	dgfAddress, err := opservice.ParseAddress(ctx.String(DGFAddressFlag.Name))
+	gameFactoryAddress, err := opservice.ParseAddress(ctx.String(FactoryAddressFlag.Name))
 	if err != nil {
 		return nil, err
 	}
+	var dgfAddress common.Address
+	if ctx.IsSet(DGFAddressFlag.Name) {
+		dgfAddress, err = opservice.ParseAddress(ctx.String(DGFAddressFlag.Name))
+		if err != nil {
+			return nil, err
+		}
+	}
 
 	txMgrConfig := txmgr.ReadCLIConfig(ctx)
 
@@ -194,6 +208,7 @@ func NewConfigFromCLI(ctx *cli.Context) (*config.Config, error) {
 		// Required Flags
 		L1EthRpc:                ctx.String(L1EthRpcFlag.Name),
 		TraceType:               traceTypeFlag,
+		GameFactoryAddress:      gameFactoryAddress,
 		GameAddress:             dgfAddress,
 		AlphabetTrace:           ctx.String(AlphabetFlag.Name),
 		CannonNetwork:           ctx.String(CannonNetworkFlag.Name),

op-challenger/scripts/alphabet/charlie.sh

@@ -3,6 +3,7 @@ set -euo pipefail
 
 SOURCE_DIR=$(cd $(dirname "${BASH_SOURCE[0]}") && pwd)
 CHALLENGER_DIR=$(echo ${SOURCE_DIR%/*/*})
+MONOREPO_DIR=$(echo ${SOURCE_DIR%/*/*/*})
 
 # Check that the fault game address file exists
 FAULT_GAME_ADDR_FILE="$CHALLENGER_DIR/.fault-game-address"
@@ -14,6 +15,7 @@ fi
 # Charlie's Address: 0xF45B7537828CB2fffBC69996B054c2Aaf36DC778
 CHARLIE_KEY="74feb147d72bfae943e6b4e483410933d9e447d5dc47d52432dcc2c1454dabb7"
 
+DISPUTE_GAME_PROXY=$(jq -r .DisputeGameFactoryProxy $MONOREPO_DIR/.devnet/addresses.json)
 FAULT_GAME_ADDRESS=$(cat $FAULT_GAME_ADDR_FILE)
 echo "Fault dispute game address: $FAULT_GAME_ADDRESS"
 
@@ -21,6 +23,7 @@ $CHALLENGER_DIR/bin/op-challenger \
   --l1-eth-rpc http://localhost:8545 \
   --trace-type="alphabet" \
   --alphabet "abcdefgh" \
+  --game-factory-address $DISPUTE_GAME_PROXY \
   --game-address $FAULT_GAME_ADDRESS \
   --private-key $CHARLIE_KEY \
   --num-confirmations 1 \

op-challenger/scripts/alphabet/mallory.sh

@@ -3,6 +3,7 @@ set -euo pipefail
 
 SOURCE_DIR=$(cd $(dirname "${BASH_SOURCE[0]}") && pwd)
 CHALLENGER_DIR=$(echo ${SOURCE_DIR%/*/*})
+MONOREPO_DIR=$(echo ${SOURCE_DIR%/*/*/*})
 
 # Check that the fault game address file exists
 FAULT_GAME_ADDR_FILE="$CHALLENGER_DIR/.fault-game-address"
@@ -14,6 +15,7 @@ fi
 # Mallory's Address: 0x4641c704a6c743f73ee1f36C7568Fbf4b80681e4
 MALLORY_KEY="28d7045146193f5f4eeb151c4843544b1b0d30a7ac1680c845a416fac65a7715"
 
+DISPUTE_GAME_PROXY=$(jq -r .DisputeGameFactoryProxy $MONOREPO_DIR/.devnet/addresses.json)
 FAULT_GAME_ADDRESS=$(cat $FAULT_GAME_ADDR_FILE)
 echo "Fault dispute game address: $FAULT_GAME_ADDRESS"
 
@@ -21,6 +23,7 @@ $CHALLENGER_DIR/bin/op-challenger \
   --l1-eth-rpc http://localhost:8545 \
   --trace-type="alphabet" \
   --alphabet "abcdexyz" \
+  --game-factory-address $DISPUTE_GAME_PROXY \
   --game-address $FAULT_GAME_ADDRESS \
   --private-key $MALLORY_KEY \
   --num-confirmations 1 \

op-e2e/e2eutils/disputegame/alphabet_helper.go

@@ -15,6 +15,7 @@ type AlphabetGameHelper struct {
 func (g *AlphabetGameHelper) StartChallenger(ctx context.Context, l1Endpoint string, name string, options ...challenger.Option) *challenger.Helper {
 	opts := []challenger.Option{
 		func(c *config.Config) {
+			c.GameFactoryAddress = g.factoryAddr
 			c.GameAddress = g.addr
 			c.TraceType = config.TraceTypeAlphabet
 			// By default the challenger agrees with the root claim (thus disagrees with the proposed output)

op-e2e/e2eutils/disputegame/cannon_helper.go

@@ -24,7 +24,7 @@ type CannonGameHelper struct {
 }
 
 func (g *CannonGameHelper) StartChallenger(ctx context.Context, rollupCfg *rollup.Config, l2Genesis *core.Genesis, l1Endpoint string, l2Endpoint string, name string, options ...challenger.Option) *challenger.Helper {
-	opts := []challenger.Option{createConfigOption(g.t, rollupCfg, l2Genesis, g.addr, l2Endpoint)}
+	opts := []challenger.Option{createConfigOption(g.t, rollupCfg, l2Genesis, g.factoryAddr, g.addr, l2Endpoint)}
 	opts = append(opts, options...)
 	c := challenger.NewChallenger(g.t, ctx, l1Endpoint, name, opts...)
 	g.t.Cleanup(func() {
@@ -34,7 +34,7 @@ func (g *CannonGameHelper) StartChallenger(ctx context.Context, rollupCfg *rollu
 }
 
 func (g *CannonGameHelper) CreateHonestActor(ctx context.Context, rollupCfg *rollup.Config, l2Genesis *core.Genesis, l1Client bind.ContractCaller, l1Endpoint string, l2Endpoint string, options ...challenger.Option) *HonestHelper {
-	opts := []challenger.Option{createConfigOption(g.t, rollupCfg, l2Genesis, g.addr, l2Endpoint)}
+	opts := []challenger.Option{createConfigOption(g.t, rollupCfg, l2Genesis, g.factoryAddr, g.addr, l2Endpoint)}
 	opts = append(opts, options...)
 	cfg := challenger.NewChallengerConfig(g.t, l1Endpoint, opts...)
 	provider, err := cannon.NewTraceProvider(ctx, testlog.Logger(g.t, log.LvlInfo).New("role", "CorrectTrace"), cfg, l1Client)
@@ -48,9 +48,17 @@ func (g *CannonGameHelper) CreateHonestActor(ctx context.Context, rollupCfg *rol
 	}
 }
 
-func createConfigOption(t *testing.T, rollupCfg *rollup.Config, l2Genesis *core.Genesis, gameAddr common.Address, l2Endpoint string) challenger.Option {
+func createConfigOption(
+	t *testing.T,
+	rollupCfg *rollup.Config,
+	l2Genesis *core.Genesis,
+	factoryAddr common.Address,
+	gameAddr common.Address,
+	l2Endpoint string,
+) challenger.Option {
 	return func(c *config.Config) {
 		require := require.New(t)
+		c.GameFactoryAddress = factoryAddr
 		c.GameAddress = gameAddr
 		c.TraceType = config.TraceTypeCannon
 		c.AgreeWithProposedOutput = false

op-e2e/e2eutils/disputegame/game_helper.go

@@ -17,12 +17,13 @@ import (
 )
 
 type FaultGameHelper struct {
-	t       *testing.T
-	require *require.Assertions
-	client  *ethclient.Client
-	opts    *bind.TransactOpts
-	game    *bindings.FaultDisputeGame
-	addr    common.Address
+	t           *testing.T
+	require     *require.Assertions
+	client      *ethclient.Client
+	opts        *bind.TransactOpts
+	game        *bindings.FaultDisputeGame
+	factoryAddr common.Address
+	addr        common.Address
 }
 
 func (g *FaultGameHelper) GameDuration(ctx context.Context) time.Duration {

op-e2e/e2eutils/disputegame/helper.go

@@ -119,12 +119,13 @@ func (h *FactoryHelper) StartAlphabetGame(ctx context.Context, claimedAlphabet s
 
 	return &AlphabetGameHelper{
 		FaultGameHelper: FaultGameHelper{
-			t:       h.t,
-			require: h.require,
-			client:  h.client,
-			opts:    h.opts,
-			game:    game,
-			addr:    createdEvent.DisputeProxy,
+			t:           h.t,
+			require:     h.require,
+			client:      h.client,
+			opts:        h.opts,
+			game:        game,
+			factoryAddr: h.factoryAddr,
+			addr:        createdEvent.DisputeProxy,
 		},
 		claimedAlphabet: claimedAlphabet,
 	}
@@ -137,7 +138,7 @@ func (h *FactoryHelper) StartCannonGame(ctx context.Context, rootClaim common.Ha
 
 func (h *FactoryHelper) StartCannonGameWithCorrectRoot(ctx context.Context, rollupCfg *rollup.Config, l2Genesis *core.Genesis, l1Endpoint string, l2Endpoint string, options ...challenger.Option) (*CannonGameHelper, *HonestHelper) {
 	l2BlockNumber, l1Head := h.prepareCannonGame(ctx)
-	challengerOpts := []challenger.Option{createConfigOption(h.t, rollupCfg, l2Genesis, common.Address{0xaa}, l2Endpoint)}
+	challengerOpts := []challenger.Option{createConfigOption(h.t, rollupCfg, l2Genesis, h.factoryAddr, common.Address{0xaa}, l2Endpoint)}
 	challengerOpts = append(challengerOpts, options...)
 	cfg := challenger.NewChallengerConfig(h.t, l1Endpoint, challengerOpts...)
 	opts := &bind.CallOpts{Context: ctx}
@@ -200,20 +201,20 @@ func (h *FactoryHelper) createCannonGame(ctx context.Context, l2BlockNumber uint
 
 	return &CannonGameHelper{
 		FaultGameHelper: FaultGameHelper{
-			t:       h.t,
-			require: h.require,
-			client:  h.client,
-			opts:    h.opts,
-			game:    game,
-			addr:    createdEvent.DisputeProxy,
+			t:           h.t,
+			require:     h.require,
+			client:      h.client,
+			opts:        h.opts,
+			game:        game,
+			factoryAddr: h.factoryAddr,
+			addr:        createdEvent.DisputeProxy,
 		},
 	}
 }
 func (h *FactoryHelper) StartChallenger(ctx context.Context, l1Endpoint string, name string, options ...challenger.Option) *challenger.Helper {
 	opts := []challenger.Option{
 		func(c *config.Config) {
-			// Uncomment when challenger actually supports setting the game factory address
-			//c.FactoryAddress = h.factoryAddr
+			c.GameFactoryAddress = h.factoryAddr
 			c.TraceType = config.TraceTypeAlphabet
 		},
 	}