Skip to content

Commit c6efac2

Browse files
ajsuttonsamlaf
ajsutton
authored and
samlaf
committed
op-challenger: Migrate config over to supporting multiple L2s (ethereum-optimism#13833)
* op-challenger: Migrate config over to supporting multiple L2s * op-challenger: Update flags to support multiple L2s * op-dispute-mon: Keep the single network flag logic
1 parent 761d25c commit c6efac2

File tree

16 files changed

+283
-291
lines changed

16 files changed

+283
-291
lines changed

‎op-challenger/cmd/main_test.go‎

Lines changed: 15 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -173,6 +173,10 @@ func TestGameFactoryAddress(t *testing.T) {
173173
verifyArgsInvalid(t, "flag game-factory-address or network is required", addRequiredArgsExcept(types.TraceTypeAlphabet, "--game-factory-address"))
174174
})
175175

176+
t.Run("RequiredWhenMultipleNetworksSupplied", func(t *testing.T) {
177+
verifyArgsInvalid(t, "flag game-factory-address required when multiple networks specified", addRequiredArgsExcept(types.TraceTypeAlphabet, "--game-factory-address", "--network", "op-sepolia,op-mainnet"))
178+
})
179+
176180
t.Run("Valid", func(t *testing.T) {
177181
addr := common.Address{0xbb, 0xcc, 0xdd}
178182
cfg := configForArgs(t, addRequiredArgsExcept(types.TraceTypeAlphabet, "--game-factory-address", "--game-factory-address="+addr.Hex()))
@@ -205,7 +209,7 @@ func TestNetwork(t *testing.T) {
205209
addr := common.Address{0xbb, 0xcc, 0xdd}
206210
cfg := configForArgs(t, addRequiredArgsExcept(types.TraceTypeAlphabet, "--game-factory-address", "--network=1234", "--game-factory-address="+addr.Hex()))
207211
require.Equal(t, addr, cfg.GameFactoryAddress)
208-
require.Equal(t, "1234", cfg.Cannon.Network)
212+
require.Equal(t, []string{"1234"}, cfg.Cannon.Networks)
209213
})
210214
}
211215

@@ -473,7 +477,7 @@ func TestAsteriscBaseRequiredArgs(t *testing.T) {
473477

474478
t.Run("Valid", func(t *testing.T) {
475479
cfg := configForArgs(t, addRequiredArgs(traceType))
476-
require.Equal(t, l2EthRpc, cfg.L2Rpc)
480+
require.Equal(t, []string{l2EthRpc}, cfg.L2Rpcs)
477481
})
478482
})
479483

@@ -549,12 +553,12 @@ func TestAsteriscBaseRequiredArgs(t *testing.T) {
549553
delete(args, "--game-factory-address")
550554
args["--network"] = "op-sepolia"
551555
cfg := configForArgs(t, toArgList(args))
552-
require.Equal(t, "op-sepolia", cfg.Asterisc.Network)
556+
require.Equal(t, []string{"op-sepolia"}, cfg.Asterisc.Networks)
553557
})
554558

555559
t.Run("Valid", func(t *testing.T) {
556560
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network", "--network", testNetwork))
557-
require.Equal(t, testNetwork, cfg.Asterisc.Network)
561+
require.Equal(t, []string{testNetwork}, cfg.Asterisc.Networks)
558562
})
559563
})
560564

@@ -565,7 +569,7 @@ func TestAsteriscBaseRequiredArgs(t *testing.T) {
565569

566570
t.Run("Valid", func(t *testing.T) {
567571
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network", "--rollup-config=rollup.json", "--l2-genesis=genesis.json"))
568-
require.Equal(t, "rollup.json", cfg.Asterisc.RollupConfigPath)
572+
require.Equal(t, []string{"rollup.json"}, cfg.Asterisc.RollupConfigPaths)
569573
})
570574
})
571575

@@ -576,7 +580,7 @@ func TestAsteriscBaseRequiredArgs(t *testing.T) {
576580

577581
t.Run("Valid", func(t *testing.T) {
578582
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network", "--rollup-config=rollup.json", "--l2-genesis=genesis.json"))
579-
require.Equal(t, "genesis.json", cfg.Asterisc.L2GenesisPath)
583+
require.Equal(t, []string{"genesis.json"}, cfg.Asterisc.L2GenesisPaths)
580584
})
581585
})
582586
}
@@ -590,7 +594,7 @@ func TestAlphabetRequiredArgs(t *testing.T) {
590594

591595
t.Run("Valid", func(t *testing.T) {
592596
cfg := configForArgs(t, addRequiredArgs(types.TraceTypeAlphabet))
593-
require.Equal(t, l2EthRpc, cfg.L2Rpc)
597+
require.Equal(t, []string{l2EthRpc}, cfg.L2Rpcs)
594598
})
595599
})
596600
}
@@ -694,7 +698,7 @@ func TestCannonRequiredArgs(t *testing.T) {
694698

695699
t.Run("Valid", func(t *testing.T) {
696700
cfg := configForArgs(t, addRequiredArgs(traceType))
697-
require.Equal(t, l2EthRpc, cfg.L2Rpc)
701+
require.Equal(t, []string{l2EthRpc}, cfg.L2Rpcs)
698702
})
699703
})
700704

@@ -776,7 +780,7 @@ func TestCannonRequiredArgs(t *testing.T) {
776780

777781
t.Run("Valid", func(t *testing.T) {
778782
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network", "--network", testNetwork))
779-
require.Equal(t, testNetwork, cfg.Cannon.Network)
783+
require.Equal(t, []string{testNetwork}, cfg.Cannon.Networks)
780784
})
781785
})
782786

@@ -795,7 +799,7 @@ func TestCannonRequiredArgs(t *testing.T) {
795799

796800
t.Run("Valid", func(t *testing.T) {
797801
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network", "--cannon-rollup-config=rollup.json", "--cannon-l2-genesis=genesis.json"))
798-
require.Equal(t, "rollup.json", cfg.Cannon.RollupConfigPath)
802+
require.Equal(t, []string{"rollup.json"}, cfg.Cannon.RollupConfigPaths)
799803
})
800804
})
801805

@@ -806,7 +810,7 @@ func TestCannonRequiredArgs(t *testing.T) {
806810

807811
t.Run("Valid", func(t *testing.T) {
808812
cfg := configForArgs(t, addRequiredArgsExcept(traceType, "--network", "--cannon-rollup-config=rollup.json", "--cannon-l2-genesis=genesis.json"))
809-
require.Equal(t, "genesis.json", cfg.Cannon.L2GenesisPath)
813+
require.Equal(t, []string{"genesis.json"}, cfg.Cannon.L2GenesisPaths)
810814
})
811815
})
812816
}

‎op-challenger/config/config.go‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -75,9 +75,9 @@ type Config struct {
7575

7676
TraceTypes []types.TraceType // Type of traces supported
7777

78-
RollupRpc string // L2 Rollup RPC Url
79-
SupervisorRPC string // L2 supervisor RPC URL
80-
L2Rpc string // L2 RPC Url
78+
RollupRpc string // L2 Rollup RPC Url
79+
SupervisorRPC string // L2 supervisor RPC URL
80+
L2Rpcs []string // L2 RPC Url
8181

8282
// Specific to the cannon trace provider
8383
Cannon vm.Config
@@ -112,7 +112,7 @@ func NewConfig(
112112
L1EthRpc: l1EthRpc,
113113
L1Beacon: l1BeaconApi,
114114
RollupRpc: l2RollupRpc,
115-
L2Rpc: l2EthRpc,
115+
L2Rpcs: []string{l2EthRpc},
116116
GameFactoryAddress: gameFactoryAddress,
117117
MaxConcurrency: uint(runtime.NumCPU()),
118118
PollInterval: DefaultPollInterval,
@@ -131,7 +131,7 @@ func NewConfig(
131131
VmType: types.TraceTypeCannon,
132132
L1: l1EthRpc,
133133
L1Beacon: l1BeaconApi,
134-
L2: l2EthRpc,
134+
L2s: []string{l2EthRpc},
135135
SnapshotFreq: DefaultCannonSnapshotFreq,
136136
InfoFreq: DefaultCannonInfoFreq,
137137
DebugInfo: true,
@@ -141,7 +141,7 @@ func NewConfig(
141141
VmType: types.TraceTypeAsterisc,
142142
L1: l1EthRpc,
143143
L1Beacon: l1BeaconApi,
144-
L2: l2EthRpc,
144+
L2s: []string{l2EthRpc},
145145
SnapshotFreq: DefaultAsteriscSnapshotFreq,
146146
InfoFreq: DefaultAsteriscInfoFreq,
147147
BinarySnapshots: true,
@@ -150,7 +150,7 @@ func NewConfig(
150150
VmType: types.TraceTypeAsteriscKona,
151151
L1: l1EthRpc,
152152
L1Beacon: l1BeaconApi,
153-
L2: l2EthRpc,
153+
L2s: []string{l2EthRpc},
154154
SnapshotFreq: DefaultAsteriscSnapshotFreq,
155155
InfoFreq: DefaultAsteriscInfoFreq,
156156
BinarySnapshots: true,
@@ -170,7 +170,7 @@ func (c Config) Check() error {
170170
if c.L1Beacon == "" {
171171
return ErrMissingL1Beacon
172172
}
173-
if c.L2Rpc == "" {
173+
if len(c.L2Rpcs) == 0 {
174174
return ErrMissingL2Rpc
175175
}
176176
if c.GameFactoryAddress == (common.Address{}) {

‎op-challenger/config/config_test.go‎

Lines changed: 44 additions & 68 deletions
Original file line numberDiff line numberDiff line change
@@ -80,7 +80,7 @@ func applyValidConfigForCannon(t *testing.T, cfg *Config) {
8080
cfg.Cannon.VmBin = vmBin
8181
cfg.Cannon.Server = server
8282
cfg.CannonAbsolutePreStateBaseURL = validCannonAbsolutePreStateBaseURL
83-
cfg.Cannon.Network = validCannonNetwork
83+
cfg.Cannon.Networks = []string{validCannonNetwork}
8484
}
8585

8686
func applyValidConfigForAsterisc(t *testing.T, cfg *Config) {
@@ -94,7 +94,7 @@ func applyValidConfigForAsterisc(t *testing.T, cfg *Config) {
9494
cfg.Asterisc.VmBin = vmBin
9595
cfg.Asterisc.Server = server
9696
cfg.AsteriscAbsolutePreStateBaseURL = validAsteriscAbsolutePreStateBaseURL
97-
cfg.Asterisc.Network = validAsteriscNetwork
97+
cfg.Asterisc.Networks = []string{validAsteriscNetwork}
9898
}
9999

100100
func applyValidConfigForAsteriscKona(t *testing.T, cfg *Config) {
@@ -108,7 +108,7 @@ func applyValidConfigForAsteriscKona(t *testing.T, cfg *Config) {
108108
cfg.AsteriscKona.VmBin = vmBin
109109
cfg.AsteriscKona.Server = server
110110
cfg.AsteriscKonaAbsolutePreStateBaseURL = validAsteriscKonaAbsolutePreStateBaseURL
111-
cfg.AsteriscKona.Network = validAsteriscKonaNetwork
111+
cfg.AsteriscKona.Networks = []string{validAsteriscKonaNetwork}
112112
}
113113

114114
func validConfig(t *testing.T, traceType types.TraceType) Config {
@@ -224,7 +224,7 @@ func TestCannonRequiredArgs(t *testing.T) {
224224

225225
t.Run(fmt.Sprintf("TestL2RpcRequired-%v", traceType), func(t *testing.T) {
226226
config := validConfig(t, traceType)
227-
config.L2Rpc = ""
227+
config.L2Rpcs = nil
228228
require.ErrorIs(t, config.Check(), ErrMissingL2Rpc)
229229
})
230230

@@ -246,51 +246,43 @@ func TestCannonRequiredArgs(t *testing.T) {
246246

247247
t.Run(fmt.Sprintf("TestCannonNetworkOrRollupConfigRequired-%v", traceType), func(t *testing.T) {
248248
cfg := validConfig(t, traceType)
249-
cfg.Cannon.Network = ""
250-
cfg.Cannon.RollupConfigPath = ""
251-
cfg.Cannon.L2GenesisPath = "genesis.json"
249+
cfg.Cannon.Networks = nil
250+
cfg.Cannon.RollupConfigPaths = nil
251+
cfg.Cannon.L2GenesisPaths = []string{"genesis.json"}
252252
require.ErrorIs(t, cfg.Check(), vm.ErrMissingRollupConfig)
253253
})
254254

255255
t.Run(fmt.Sprintf("TestCannonNetworkOrL2GenesisRequired-%v", traceType), func(t *testing.T) {
256256
cfg := validConfig(t, traceType)
257-
cfg.Cannon.Network = ""
258-
cfg.Cannon.RollupConfigPath = "foo.json"
259-
cfg.Cannon.L2GenesisPath = ""
257+
cfg.Cannon.Networks = nil
258+
cfg.Cannon.RollupConfigPaths = []string{"foo.json"}
259+
cfg.Cannon.L2GenesisPaths = nil
260260
require.ErrorIs(t, cfg.Check(), vm.ErrMissingL2Genesis)
261261
})
262262

263-
t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) {
263+
t.Run(fmt.Sprintf("TestMaySpecifyNetworkAndCustomConfigs-%v", traceType), func(t *testing.T) {
264264
cfg := validConfig(t, traceType)
265-
cfg.Cannon.Network = validCannonNetwork
266-
cfg.Cannon.RollupConfigPath = "foo.json"
267-
cfg.Cannon.L2GenesisPath = ""
268-
require.ErrorIs(t, cfg.Check(), vm.ErrNetworkAndRollupConfig)
269-
})
270-
271-
t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndL2Genesis-%v", traceType), func(t *testing.T) {
272-
cfg := validConfig(t, traceType)
273-
cfg.Cannon.Network = validCannonNetwork
274-
cfg.Cannon.RollupConfigPath = ""
275-
cfg.Cannon.L2GenesisPath = "foo.json"
276-
require.ErrorIs(t, cfg.Check(), vm.ErrNetworkAndL2Genesis)
265+
cfg.Cannon.Networks = []string{validCannonNetwork}
266+
cfg.Cannon.RollupConfigPaths = []string{"foo.json"}
267+
cfg.Cannon.L2GenesisPaths = []string{"genesis.json"}
268+
require.NoError(t, cfg.Check())
277269
})
278270

279271
t.Run(fmt.Sprintf("TestNetworkMustBeValid-%v", traceType), func(t *testing.T) {
280272
cfg := validConfig(t, traceType)
281-
cfg.Cannon.Network = "unknown"
273+
cfg.Cannon.Networks = []string{"unknown"}
282274
require.ErrorIs(t, cfg.Check(), vm.ErrNetworkUnknown)
283275
})
284276

285277
t.Run(fmt.Sprintf("TestNetworkMayBeAnyChainID-%v", traceType), func(t *testing.T) {
286278
cfg := validConfig(t, traceType)
287-
cfg.Cannon.Network = "467294"
279+
cfg.Cannon.Networks = []string{"467294"}
288280
require.NoError(t, cfg.Check())
289281
})
290282

291283
t.Run(fmt.Sprintf("TestNetworkInvalidWhenNotEntirelyNumeric-%v", traceType), func(t *testing.T) {
292284
cfg := validConfig(t, traceType)
293-
cfg.Cannon.Network = "467294a"
285+
cfg.Cannon.Networks = []string{"467294a"}
294286
require.ErrorIs(t, cfg.Check(), vm.ErrNetworkUnknown)
295287
})
296288

@@ -360,7 +352,7 @@ func TestAsteriscRequiredArgs(t *testing.T) {
360352

361353
t.Run(fmt.Sprintf("TestL2RpcRequired-%v", traceType), func(t *testing.T) {
362354
config := validConfig(t, traceType)
363-
config.L2Rpc = ""
355+
config.L2Rpcs = nil
364356
require.ErrorIs(t, config.Check(), ErrMissingL2Rpc)
365357
})
366358

@@ -382,39 +374,31 @@ func TestAsteriscRequiredArgs(t *testing.T) {
382374

383375
t.Run(fmt.Sprintf("TestAsteriscNetworkOrRollupConfigRequired-%v", traceType), func(t *testing.T) {
384376
cfg := validConfig(t, traceType)
385-
cfg.Asterisc.Network = ""
386-
cfg.Asterisc.RollupConfigPath = ""
387-
cfg.Asterisc.L2GenesisPath = "genesis.json"
377+
cfg.Asterisc.Networks = nil
378+
cfg.Asterisc.RollupConfigPaths = nil
379+
cfg.Asterisc.L2GenesisPaths = []string{"genesis.json"}
388380
require.ErrorIs(t, cfg.Check(), vm.ErrMissingRollupConfig)
389381
})
390382

391383
t.Run(fmt.Sprintf("TestAsteriscNetworkOrL2GenesisRequired-%v", traceType), func(t *testing.T) {
392384
cfg := validConfig(t, traceType)
393-
cfg.Asterisc.Network = ""
394-
cfg.Asterisc.RollupConfigPath = "foo.json"
395-
cfg.Asterisc.L2GenesisPath = ""
385+
cfg.Asterisc.Networks = nil
386+
cfg.Asterisc.RollupConfigPaths = []string{"foo.json"}
387+
cfg.Asterisc.L2GenesisPaths = nil
396388
require.ErrorIs(t, cfg.Check(), vm.ErrMissingL2Genesis)
397389
})
398390

399-
t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) {
400-
cfg := validConfig(t, traceType)
401-
cfg.Asterisc.Network = validAsteriscNetwork
402-
cfg.Asterisc.RollupConfigPath = "foo.json"
403-
cfg.Asterisc.L2GenesisPath = ""
404-
require.ErrorIs(t, cfg.Check(), vm.ErrNetworkAndRollupConfig)
405-
})
406-
407-
t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndL2Genesis-%v", traceType), func(t *testing.T) {
391+
t.Run(fmt.Sprintf("MaySpecifyNetworkAndCustomConfigs-%v", traceType), func(t *testing.T) {
408392
cfg := validConfig(t, traceType)
409-
cfg.Asterisc.Network = validAsteriscNetwork
410-
cfg.Asterisc.RollupConfigPath = ""
411-
cfg.Asterisc.L2GenesisPath = "foo.json"
412-
require.ErrorIs(t, cfg.Check(), vm.ErrNetworkAndL2Genesis)
393+
cfg.Asterisc.Networks = []string{validAsteriscNetwork}
394+
cfg.Asterisc.RollupConfigPaths = []string{"foo.json"}
395+
cfg.Asterisc.L2GenesisPaths = []string{"genesis.json"}
396+
require.NoError(t, cfg.Check())
413397
})
414398

415399
t.Run(fmt.Sprintf("TestNetworkMustBeValid-%v", traceType), func(t *testing.T) {
416400
cfg := validConfig(t, traceType)
417-
cfg.Asterisc.Network = "unknown"
401+
cfg.Asterisc.Networks = []string{"unknown"}
418402
require.ErrorIs(t, cfg.Check(), vm.ErrNetworkUnknown)
419403
})
420404

@@ -484,7 +468,7 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) {
484468

485469
t.Run(fmt.Sprintf("TestL2RpcRequired-%v", traceType), func(t *testing.T) {
486470
config := validConfig(t, traceType)
487-
config.L2Rpc = ""
471+
config.L2Rpcs = nil
488472
require.ErrorIs(t, config.Check(), ErrMissingL2Rpc)
489473
})
490474

@@ -506,39 +490,31 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) {
506490

507491
t.Run(fmt.Sprintf("TestAsteriscKonaNetworkOrRollupConfigRequired-%v", traceType), func(t *testing.T) {
508492
cfg := validConfig(t, traceType)
509-
cfg.AsteriscKona.Network = ""
510-
cfg.AsteriscKona.RollupConfigPath = ""
511-
cfg.AsteriscKona.L2GenesisPath = "genesis.json"
493+
cfg.AsteriscKona.Networks = nil
494+
cfg.AsteriscKona.RollupConfigPaths = nil
495+
cfg.AsteriscKona.L2GenesisPaths = []string{"genesis.json"}
512496
require.ErrorIs(t, cfg.Check(), vm.ErrMissingRollupConfig)
513497
})
514498

515499
t.Run(fmt.Sprintf("TestAsteriscKonaNetworkOrL2GenesisRequired-%v", traceType), func(t *testing.T) {
516500
cfg := validConfig(t, traceType)
517-
cfg.AsteriscKona.Network = ""
518-
cfg.AsteriscKona.RollupConfigPath = "foo.json"
519-
cfg.AsteriscKona.L2GenesisPath = ""
501+
cfg.AsteriscKona.Networks = nil
502+
cfg.AsteriscKona.RollupConfigPaths = []string{"foo.json"}
503+
cfg.AsteriscKona.L2GenesisPaths = nil
520504
require.ErrorIs(t, cfg.Check(), vm.ErrMissingL2Genesis)
521505
})
522506

523-
t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndRollup-%v", traceType), func(t *testing.T) {
524-
cfg := validConfig(t, traceType)
525-
cfg.AsteriscKona.Network = validAsteriscKonaNetwork
526-
cfg.AsteriscKona.RollupConfigPath = "foo.json"
527-
cfg.AsteriscKona.L2GenesisPath = ""
528-
require.ErrorIs(t, cfg.Check(), vm.ErrNetworkAndRollupConfig)
529-
})
530-
531-
t.Run(fmt.Sprintf("TestMustNotSpecifyNetworkAndL2Genesis-%v", traceType), func(t *testing.T) {
507+
t.Run(fmt.Sprintf("MaySpecifyNetworkAndCustomConfig-%v", traceType), func(t *testing.T) {
532508
cfg := validConfig(t, traceType)
533-
cfg.AsteriscKona.Network = validAsteriscKonaNetwork
534-
cfg.AsteriscKona.RollupConfigPath = ""
535-
cfg.AsteriscKona.L2GenesisPath = "foo.json"
536-
require.ErrorIs(t, cfg.Check(), vm.ErrNetworkAndL2Genesis)
509+
cfg.AsteriscKona.Networks = []string{validAsteriscKonaNetwork}
510+
cfg.AsteriscKona.RollupConfigPaths = []string{"foo.json"}
511+
cfg.AsteriscKona.L2GenesisPaths = []string{"genesis.json"}
512+
require.NoError(t, cfg.Check())
537513
})
538514

539515
t.Run(fmt.Sprintf("TestNetworkMustBeValid-%v", traceType), func(t *testing.T) {
540516
cfg := validConfig(t, traceType)
541-
cfg.AsteriscKona.Network = "unknown"
517+
cfg.AsteriscKona.Networks = []string{"unknown"}
542518
require.ErrorIs(t, cfg.Check(), vm.ErrNetworkUnknown)
543519
})
544520

0 commit comments

Comments
 (0)