op-challenger: Initial support for registering output cannon trace types

op-challenger/game/fault/register.go

@@ -9,6 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/alphabet"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/cannon"
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/outputs"
 	faultTypes "github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/scheduler"
 	"github.com/ethereum-optimism/optimism/op-challenger/game/types"
@@ -20,8 +21,9 @@ import (
 )
 
 var (
-	cannonGameType   = uint8(0)
-	alphabetGameType = uint8(255)
+	cannonGameType       = uint8(0)
+	outputCannonGameType = uint8(0) // TODO(client-pod#43): This should be a unique game type
+	alphabetGameType     = uint8(255)
 )
 
 type Registry interface {
@@ -37,38 +39,96 @@ func RegisterGameTypes(
 	txMgr txmgr.TxManager,
 	client *ethclient.Client,
 ) {
+	if cfg.TraceTypeEnabled(config.TraceTypeOutputCannon) {
+		registerOutputCannon(registry, ctx, logger, m, cfg, txMgr, client)
+	}
 	if cfg.TraceTypeEnabled(config.TraceTypeCannon) {
-		resourceCreator := func(addr common.Address, contract *contracts.FaultDisputeGameContract, gameDepth uint64, dir string) (faultTypes.TraceAccessor, faultTypes.OracleUpdater, gameValidator, error) {
-			provider, err := cannon.NewTraceProvider(ctx, logger, m, cfg, contract, dir, gameDepth)
-			if err != nil {
-				return nil, nil, nil, fmt.Errorf("create cannon trace provider: %w", err)
-			}
-			updater, err := cannon.NewOracleUpdater(ctx, logger, txMgr, addr, client)
-			if err != nil {
-				return nil, nil, nil, fmt.Errorf("failed to create the cannon updater: %w", err)
-			}
-			validator := func(ctx context.Context, contract *contracts.FaultDisputeGameContract) error {
-				return ValidateAbsolutePrestate(ctx, provider, contract)
-			}
-			return trace.NewSimpleTraceAccessor(provider), updater, validator, nil
+		registerCannon(registry, ctx, logger, m, cfg, txMgr, client)
+	}
+	if cfg.TraceTypeEnabled(config.TraceTypeAlphabet) {
+		registerAlphabet(registry, ctx, logger, m, cfg, txMgr, client)
+	}
+}
+
+func registerOutputCannon(
+	registry Registry,
+	ctx context.Context,
+	logger log.Logger,
+	m metrics.Metricer,
+	cfg *config.Config,
+	txMgr txmgr.TxManager,
+	client *ethclient.Client) {
+	resourceCreator := func(addr common.Address, contract *contracts.FaultDisputeGameContract, gameDepth uint64, dir string) (faultTypes.TraceAccessor, faultTypes.OracleUpdater, gameValidator, error) {
+		// TODO(client-pod#43): Updated contracts should expose this as the pre and post state blocks
+		agreed, disputed, err := contract.GetProposals(ctx)
+		if err != nil {
+			return nil, nil, nil, err
+		}
+		accessor, err := outputs.NewOutputCannonTraceAccessor(ctx, logger, cfg.RollupRpc, gameDepth, agreed.L2BlockNumber.Uint64(), disputed.L2BlockNumber.Uint64())
+		if err != nil {
+			return nil, nil, nil, err
 		}
-		playerCreator := func(game types.GameMetadata, dir string) (scheduler.GamePlayer, error) {
-			return NewGamePlayer(ctx, logger, m, cfg, dir, game.Proxy, txMgr, client, resourceCreator)
+		updater, err := cannon.NewOracleUpdater(ctx, logger, txMgr, addr, client)
+		if err != nil {
+			return nil, nil, nil, fmt.Errorf("failed to create the cannon updater: %w", err)
 		}
-		registry.RegisterGameType(cannonGameType, playerCreator)
+		noopValidator := func(ctx context.Context, gameContract *contracts.FaultDisputeGameContract) error {
+			return nil
+		}
+		return accessor, updater, noopValidator, nil
 	}
-	if cfg.TraceTypeEnabled(config.TraceTypeAlphabet) {
-		resourceCreator := func(addr common.Address, contract *contracts.FaultDisputeGameContract, gameDepth uint64, dir string) (faultTypes.TraceAccessor, faultTypes.OracleUpdater, gameValidator, error) {
-			provider := alphabet.NewTraceProvider(cfg.AlphabetTrace, gameDepth)
-			updater := alphabet.NewOracleUpdater(logger)
-			validator := func(ctx context.Context, contract *contracts.FaultDisputeGameContract) error {
-				return ValidateAbsolutePrestate(ctx, provider, contract)
-			}
-			return trace.NewSimpleTraceAccessor(provider), updater, validator, nil
+	playerCreator := func(game types.GameMetadata, dir string) (scheduler.GamePlayer, error) {
+		return NewGamePlayer(ctx, logger, m, cfg, dir, game.Proxy, txMgr, client, resourceCreator)
+	}
+	registry.RegisterGameType(outputCannonGameType, playerCreator)
+}
+
+func registerCannon(
+	registry Registry,
+	ctx context.Context,
+	logger log.Logger,
+	m metrics.Metricer,
+	cfg *config.Config,
+	txMgr txmgr.TxManager,
+	client *ethclient.Client) {
+	resourceCreator := func(addr common.Address, contract *contracts.FaultDisputeGameContract, gameDepth uint64, dir string) (faultTypes.TraceAccessor, faultTypes.OracleUpdater, gameValidator, error) {
+		provider, err := cannon.NewTraceProvider(ctx, logger, m, cfg, contract, dir, gameDepth)
+		if err != nil {
+			return nil, nil, nil, fmt.Errorf("create cannon trace provider: %w", err)
 		}
-		playerCreator := func(game types.GameMetadata, dir string) (scheduler.GamePlayer, error) {
-			return NewGamePlayer(ctx, logger, m, cfg, dir, game.Proxy, txMgr, client, resourceCreator)
+		updater, err := cannon.NewOracleUpdater(ctx, logger, txMgr, addr, client)
+		if err != nil {
+			return nil, nil, nil, fmt.Errorf("failed to create the cannon updater: %w", err)
+		}
+		validator := func(ctx context.Context, contract *contracts.FaultDisputeGameContract) error {
+			return ValidateAbsolutePrestate(ctx, provider, contract)
+		}
+		return trace.NewSimpleTraceAccessor(provider), updater, validator, nil
+	}
+	playerCreator := func(game types.GameMetadata, dir string) (scheduler.GamePlayer, error) {
+		return NewGamePlayer(ctx, logger, m, cfg, dir, game.Proxy, txMgr, client, resourceCreator)
+	}
+	registry.RegisterGameType(cannonGameType, playerCreator)
+}
+
+func registerAlphabet(
+	registry Registry,
+	ctx context.Context,
+	logger log.Logger,
+	m metrics.Metricer,
+	cfg *config.Config,
+	txMgr txmgr.TxManager,
+	client *ethclient.Client) {
+	resourceCreator := func(addr common.Address, contract *contracts.FaultDisputeGameContract, gameDepth uint64, dir string) (faultTypes.TraceAccessor, faultTypes.OracleUpdater, gameValidator, error) {
+		provider := alphabet.NewTraceProvider(cfg.AlphabetTrace, gameDepth)
+		updater := alphabet.NewOracleUpdater(logger)
+		validator := func(ctx context.Context, contract *contracts.FaultDisputeGameContract) error {
+			return ValidateAbsolutePrestate(ctx, provider, contract)
 		}
-		registry.RegisterGameType(alphabetGameType, playerCreator)
+		return trace.NewSimpleTraceAccessor(provider), updater, validator, nil
+	}
+	playerCreator := func(game types.GameMetadata, dir string) (scheduler.GamePlayer, error) {
+		return NewGamePlayer(ctx, logger, m, cfg, dir, game.Proxy, txMgr, client, resourceCreator)
 	}
+	registry.RegisterGameType(alphabetGameType, playerCreator)
 }

op-challenger/game/fault/trace/access.go

@@ -11,11 +11,15 @@ func NewSimpleTraceAccessor(trace types.TraceProvider) *Accessor {
 	selector := func(_ context.Context, _ types.Game, _ types.Claim, _ types.Position) (types.TraceProvider, error) {
 		return trace, nil
 	}
-	return &Accessor{selector}
+	return NewAccessor(selector)
 }
 
 type ProviderSelector func(ctx context.Context, game types.Game, ref types.Claim, pos types.Position) (types.TraceProvider, error)
 
+func NewAccessor(selector ProviderSelector) *Accessor {
+	return &Accessor{selector}
+}
+
 type Accessor struct {
 	selector ProviderSelector
 }

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

+package outputs
+
+import (
+	"context"
+	"errors"
+
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace"
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
+	"github.com/ethereum/go-ethereum/log"
+)
+
+func NewOutputCannonTraceAccessor(ctx context.Context, logger log.Logger, rollupRpc string, gameDepth uint64, prestateBlock uint64, poststateBlock uint64) (*trace.Accessor, error) {
+	topDepth := gameDepth / 2 // TODO(client-pod#43): Load this from the contract
+	outputProvider, err := NewTraceProvider(ctx, logger, rollupRpc, topDepth, prestateBlock, poststateBlock)
+	if err != nil {
+		return nil, err
+	}
+
+	cannonCreator := func(ctx context.Context, pre types.Claim, post types.Claim) (types.TraceProvider, error) {
+		// TODO(client-pod#43): Implement this.
+		return nil, errors.New("not implemented")
+	}
+
+	selector := newSplitProviderSelector(outputProvider, int(topDepth), cannonCreator)
+	return trace.NewAccessor(selector), nil
+}