op-challenger: Separate fetching local inputs from the constructor.

op-challenger/game/fault/register.go

@@ -42,26 +42,19 @@ func RegisterGameTypes(
 	client *ethclient.Client,
 ) (CloseFunc, error) {
 	var closer CloseFunc
-	createL2Client := func() (cannon.L2HeaderSource, error) {
-		l2Client, err := ethclient.DialContext(ctx, cfg.CannonL2)
+	var l2Client *ethclient.Client
+	if cfg.TraceTypeEnabled(config.TraceTypeCannon) || cfg.TraceTypeEnabled(config.TraceTypeOutputCannon) {
+		l2, err := ethclient.DialContext(ctx, cfg.CannonL2)
 		if err != nil {
 			return nil, fmt.Errorf("dial l2 client %v: %w", cfg.CannonL2, err)
 		}
+		l2Client = l2
 		closer = l2Client.Close
-		return l2Client, nil
 	}
 	if cfg.TraceTypeEnabled(config.TraceTypeOutputCannon) {
-		l2Client, err := createL2Client()
-		if err != nil {
-			return nil, err
-		}
 		registerOutputCannon(registry, ctx, logger, m, cfg, txMgr, client, l2Client)
 	}
 	if cfg.TraceTypeEnabled(config.TraceTypeCannon) {
-		l2Client, err := createL2Client()
-		if err != nil {
-			return nil, err
-		}
 		registerCannon(registry, ctx, logger, m, cfg, txMgr, client, l2Client)
 	}
 	if cfg.TraceTypeEnabled(config.TraceTypeAlphabet) {
@@ -113,10 +106,11 @@ func registerCannon(
 	l2Client cannon.L2HeaderSource) {
 	resourceCreator := func(addr common.Address, contract *contracts.FaultDisputeGameContract, gameDepth uint64, dir string) (faultTypes.TraceAccessor, gameValidator, error) {
 		logger := logger.New("game", addr)
-		provider, err := cannon.NewTraceProvider(ctx, logger, m, cfg, l2Client, contract, faultTypes.NoLocalContext, dir, gameDepth)
+		localInputs, err := cannon.FetchLocalInputs(ctx, contract, l2Client)
 		if err != nil {
-			return nil, nil, fmt.Errorf("create cannon trace provider: %w", err)
+			return nil, nil, fmt.Errorf("failed to fetch cannon local inputs: %w", err)
 		}
+		provider := cannon.NewTraceProvider(logger, m, cfg, faultTypes.NoLocalContext, localInputs, dir, gameDepth)
 		validator := func(ctx context.Context, contract *contracts.FaultDisputeGameContract) error {
 			return ValidateAbsolutePrestate(ctx, provider, contract)
 		}

op-challenger/game/fault/trace/cannon/local.go

@@ -31,15 +31,15 @@ type GameInputsSource interface {
 	GetProposals(ctx context.Context) (agreed contracts.Proposal, disputed contracts.Proposal, err error)
 }
 
-func fetchLocalInputs(ctx context.Context, caller GameInputsSource, l2Client L2HeaderSource) (LocalGameInputs, error) {
+func FetchLocalInputs(ctx context.Context, caller GameInputsSource, l2Client L2HeaderSource) (LocalGameInputs, error) {
 	agreedOutput, claimedOutput, err := caller.GetProposals(ctx)
 	if err != nil {
 		return LocalGameInputs{}, fmt.Errorf("fetch proposals: %w", err)
 	}
-	return fetchLocalInputsFromProposals(ctx, caller, l2Client, agreedOutput, claimedOutput)
+	return FetchLocalInputsFromProposals(ctx, caller, l2Client, agreedOutput, claimedOutput)
 }
 
-func fetchLocalInputsFromProposals(ctx context.Context, caller L1HeadSource, l2Client L2HeaderSource, agreedOutput contracts.Proposal, claimedOutput contracts.Proposal) (LocalGameInputs, error) {
+func FetchLocalInputsFromProposals(ctx context.Context, caller L1HeadSource, l2Client L2HeaderSource, agreedOutput contracts.Proposal, claimedOutput contracts.Proposal) (LocalGameInputs, error) {
 	l1Head, err := caller.GetL1Head(ctx)
 	if err != nil {
 		return LocalGameInputs{}, fmt.Errorf("fetch L1 head: %w", err)

op-challenger/game/fault/trace/cannon/local_test.go

@@ -32,7 +32,7 @@ func TestFetchLocalInputs(t *testing.T) {
 		},
 	}
 
-	inputs, err := fetchLocalInputs(ctx, contract, l2Client)
+	inputs, err := FetchLocalInputs(ctx, contract, l2Client)
 	require.NoError(t, err)
 
 	require.Equal(t, contract.l1Head, inputs.L1Head)
@@ -62,7 +62,7 @@ func TestFetchLocalInputsFromProposals(t *testing.T) {
 		},
 	}
 
-	inputs, err := fetchLocalInputsFromProposals(ctx, contract, l2Client, agreed, claimed)
+	inputs, err := FetchLocalInputsFromProposals(ctx, contract, l2Client, agreed, claimed)
 	require.NoError(t, err)
 
 	require.Equal(t, contract.l1Head, inputs.L1Head)
@@ -91,11 +91,11 @@ type mockL2DataSource struct {
 	header  ethtypes.Header
 }
 
-func (s *mockL2DataSource) ChainID(ctx context.Context) (*big.Int, error) {
+func (s *mockL2DataSource) ChainID(_ context.Context) (*big.Int, error) {
 	return s.chainID, nil
 }
 
-func (s *mockL2DataSource) HeaderByNumber(ctx context.Context, num *big.Int) (*ethtypes.Header, error) {
+func (s *mockL2DataSource) HeaderByNumber(_ context.Context, num *big.Int) (*ethtypes.Header, error) {
 	if s.header.Number.Cmp(num) == 0 {
 		return &s.header, nil
 	}

op-challenger/game/fault/trace/cannon/provider.go

@@ -9,7 +9,6 @@ import (
 	"path/filepath"
 
 	"github.com/ethereum-optimism/optimism/op-challenger/config"
-	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/contracts"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
 	"github.com/ethereum-optimism/optimism/op-service/ioutil"
 	"github.com/ethereum/go-ethereum/common"
@@ -55,35 +54,7 @@ type CannonTraceProvider struct {
 	lastStep uint64
 }
 
-func NewTraceProvider(ctx context.Context, logger log.Logger, m CannonMetricer, cfg *config.Config, l2Client L2HeaderSource, gameContract *contracts.FaultDisputeGameContract, localContext common.Hash, dir string, gameDepth uint64) (*CannonTraceProvider, error) {
-	localInputs, err := fetchLocalInputs(ctx, gameContract, l2Client)
-	if err != nil {
-		return nil, fmt.Errorf("fetch local game inputs: %w", err)
-	}
-	return NewTraceProviderFromInputs(logger, m, cfg, localContext, localInputs, dir, gameDepth), nil
-}
-
-func NewTraceProviderFromProposals(
-	ctx context.Context,
-	logger log.Logger,
-	m CannonMetricer,
-	cfg *config.Config,
-	l2Client L2HeaderSource,
-	gameContract *contracts.FaultDisputeGameContract,
-	localContext common.Hash,
-	agreed contracts.Proposal,
-	claimed contracts.Proposal,
-	dir string,
-	gameDepth uint64,
-) (*CannonTraceProvider, error) {
-	localInputs, err := fetchLocalInputsFromProposals(ctx, gameContract, l2Client, agreed, claimed)
-	if err != nil {
-		return nil, fmt.Errorf("fetch local game inputs: %w", err)
-	}
-	return NewTraceProviderFromInputs(logger, m, cfg, localContext, localInputs, dir, gameDepth), nil
-}
-
-func NewTraceProviderFromInputs(logger log.Logger, m CannonMetricer, cfg *config.Config, localContext common.Hash, localInputs LocalGameInputs, dir string, gameDepth uint64) *CannonTraceProvider {
+func NewTraceProvider(logger log.Logger, m CannonMetricer, cfg *config.Config, localContext common.Hash, localInputs LocalGameInputs, dir string, gameDepth uint64) *CannonTraceProvider {
 	return &CannonTraceProvider{
 		logger:       logger,
 		dir:          dir,

op-challenger/game/fault/trace/outputs/output_cannon.go

@@ -39,10 +39,11 @@ func NewOutputCannonTraceAccessor(
 	cannonCreator := func(ctx context.Context, localContext common.Hash, agreed contracts.Proposal, claimed contracts.Proposal) (types.TraceProvider, error) {
 		logger := logger.New("pre", agreed.OutputRoot, "post", claimed.OutputRoot, "localContext", localContext)
 		subdir := filepath.Join(dir, localContext.Hex())
-		provider, err := cannon.NewTraceProviderFromProposals(ctx, logger, m, cfg, l2Client, contract, localContext, agreed, claimed, subdir, bottomDepth)
+		localInputs, err := cannon.FetchLocalInputsFromProposals(ctx, contract, l2Client, agreed, claimed)
 		if err != nil {
-			return nil, fmt.Errorf("failed to create cannon trace provider: %w", err)
+			return nil, fmt.Errorf("failed to fetch cannon local inputs: %w", err)
 		}
+		provider := cannon.NewTraceProvider(logger, m, cfg, localContext, localInputs, subdir, bottomDepth)
 		return provider, nil
 	}
 

op-e2e/e2eutils/disputegame/cannon_helper.go

@@ -50,8 +50,9 @@ func (g *CannonGameHelper) CreateHonestActor(ctx context.Context, rollupCfg *rol
 	l2Client, err := ethclient.DialContext(ctx, cfg.CannonL2)
 	g.require.NoErrorf(err, "dial l2 client %v", cfg.CannonL2)
 	defer l2Client.Close() // Not needed after fetching the inputs
-	provider, err := cannon.NewTraceProvider(ctx, logger, metrics.NoopMetrics, cfg, l2Client, gameContract, types.NoLocalContext, filepath.Join(cfg.Datadir, "honest"), uint64(maxDepth))
-	g.require.NoError(err, "create cannon trace provider")
+	localInputs, err := cannon.FetchLocalInputs(ctx, gameContract, l2Client)
+	g.require.NoError(err, "fetch cannon local inputs")
+	provider := cannon.NewTraceProvider(logger, metrics.NoopMetrics, cfg, types.NoLocalContext, localInputs, filepath.Join(cfg.Datadir, "honest"), uint64(maxDepth))
 
 	return &HonestHelper{
 		t:            g.t,

op-e2e/e2eutils/disputegame/helper.go

@@ -221,7 +221,7 @@ func (h *FactoryHelper) StartCannonGameWithCorrectRoot(ctx context.Context, roll
 	maxDepth, err := gameImpl.MAXGAMEDEPTH(opts)
 	h.require.NoError(err, "fetch max game depth")
 
-	provider := cannon.NewTraceProviderFromInputs(
+	provider := cannon.NewTraceProvider(
 		testlog.Logger(h.t, log.LvlInfo).New("role", "CorrectTrace"),
 		metrics.NoopMetrics,
 		cfg,