diff --git a/op-challenger/game/client/provider.go b/op-challenger/game/client/provider.go new file mode 100644 index 00000000000..d827cae977f --- /dev/null +++ b/op-challenger/game/client/provider.go @@ -0,0 +1,107 @@ +package client + +import ( + "context" + "errors" + "fmt" + + "github.com/ethereum-optimism/optimism/op-challenger/config" + "github.com/ethereum-optimism/optimism/op-service/dial" + "github.com/ethereum-optimism/optimism/op-service/sources" + "github.com/ethereum-optimism/optimism/op-service/sources/batching" + "github.com/ethereum/go-ethereum/ethclient" + "github.com/ethereum/go-ethereum/log" +) + +var ErrNotInSync = errors.New("local node too far behind") + +type Provider struct { + ctx context.Context + logger log.Logger + cfg *config.Config + l1Client *ethclient.Client + caller *batching.MultiCaller + + l2EL *ethclient.Client + rollupClient *sources.RollupClient + syncValidator *RollupSyncStatusValidator + supervisorClient *sources.SupervisorClient + toClose []func() +} + +func NewProvider(ctx context.Context, logger log.Logger, cfg *config.Config, l1Client *ethclient.Client) *Provider { + return &Provider{ + ctx: ctx, + logger: logger, + cfg: cfg, + l1Client: l1Client, + caller: batching.NewMultiCaller(l1Client.Client(), batching.DefaultBatchSize), + } +} + +func (c *Provider) Close() { + for _, closeFunc := range c.toClose { + closeFunc() + } +} + +func (c *Provider) L1Client() *ethclient.Client { + return c.l1Client +} + +func (c *Provider) MultiCaller() *batching.MultiCaller { + return c.caller +} + +func (c *Provider) SingleChainClients() (*ethclient.Client, *sources.RollupClient, *RollupSyncStatusValidator, error) { + headers, err := c.L2HeaderSource() + if err != nil { + return nil, nil, nil, err + } + rollup, syncValidator, err := c.RollupClients() + if err != nil { + return nil, nil, nil, err + } + return headers, rollup, syncValidator, nil +} + +func (c *Provider) L2HeaderSource() (*ethclient.Client, error) { + if c.l2EL != nil { + return c.l2EL, nil + } + if len(c.cfg.L2Rpcs) != 1 { + return nil, fmt.Errorf("incorrect number of L2 RPCs configured, expected 1 but got %d", len(c.cfg.L2Rpcs)) + } + + l2Client, err := ethclient.DialContext(c.ctx, c.cfg.L2Rpcs[0]) + if err != nil { + return nil, fmt.Errorf("dial l2 client %v: %w", c.cfg.L2Rpcs[0], err) + } + c.l2EL = l2Client + c.toClose = append(c.toClose, l2Client.Close) + return l2Client, nil +} + +func (c *Provider) RollupClients() (*sources.RollupClient, *RollupSyncStatusValidator, error) { + if c.rollupClient != nil { + return c.rollupClient, c.syncValidator, nil + } + rollupClient, err := dial.DialRollupClientWithTimeout(c.ctx, c.logger, c.cfg.RollupRpc) + if err != nil { + return nil, nil, fmt.Errorf("dial rollup client %v: %w", c.cfg.RollupRpc, err) + } + c.rollupClient = rollupClient + c.syncValidator = NewRollupSyncStatusValidator(rollupClient) + c.toClose = append(c.toClose, rollupClient.Close) + return rollupClient, c.syncValidator, nil +} + +func (c *Provider) SuperchainClients() (*sources.SupervisorClient, *SupervisorSyncValidator, error) { + supervisorClient, err := dial.DialSupervisorClientWithTimeout(c.ctx, c.logger, c.cfg.SupervisorRPC) + if err != nil { + return nil, nil, fmt.Errorf("failed to dial supervisor: %w", err) + } + c.supervisorClient = supervisorClient + c.toClose = append(c.toClose, supervisorClient.Close) + return supervisorClient, NewSupervisorSyncValidator(supervisorClient), nil +} diff --git a/op-challenger/game/client/rollup_sync.go b/op-challenger/game/client/rollup_sync.go new file mode 100644 index 00000000000..2b0d47c2214 --- /dev/null +++ b/op-challenger/game/client/rollup_sync.go @@ -0,0 +1,33 @@ +package client + +import ( + "context" + "fmt" + + "github.com/ethereum-optimism/optimism/op-service/eth" +) + +type syncStatusProvider interface { + SyncStatus(context.Context) (*eth.SyncStatus, error) +} + +type RollupSyncStatusValidator struct { + statusProvider syncStatusProvider +} + +func NewRollupSyncStatusValidator(statusProvider syncStatusProvider) *RollupSyncStatusValidator { + return &RollupSyncStatusValidator{ + statusProvider: statusProvider, + } +} + +func (s *RollupSyncStatusValidator) ValidateNodeSynced(ctx context.Context, gameL1Head eth.BlockID) error { + syncStatus, err := s.statusProvider.SyncStatus(ctx) + if err != nil { + return fmt.Errorf("failed to retrieve local node sync status: %w", err) + } + if syncStatus.CurrentL1.Number <= gameL1Head.Number { + return fmt.Errorf("%w require L1 block above %v but at %v", ErrNotInSync, gameL1Head.Number, syncStatus.CurrentL1.Number) + } + return nil +} diff --git a/op-challenger/game/fault/sync_test.go b/op-challenger/game/client/rollup_sync_test.go similarity index 89% rename from op-challenger/game/fault/sync_test.go rename to op-challenger/game/client/rollup_sync_test.go index 59a98957c1d..8914a1956f4 100644 --- a/op-challenger/game/fault/sync_test.go +++ b/op-challenger/game/client/rollup_sync_test.go @@ -1,11 +1,10 @@ -package fault +package client import ( "context" "errors" "testing" - "github.com/ethereum-optimism/optimism/op-challenger/game/fault/types" "github.com/ethereum-optimism/optimism/op-service/eth" "github.com/stretchr/testify/require" ) @@ -35,7 +34,7 @@ func TestSyncStatusProvider(t *testing.T) { }, }, statusReqErr: nil, - expected: types.ErrNotInSync, + expected: ErrNotInSync, }, { name: "CurrentL1EqualToGameL1Head", @@ -46,7 +45,7 @@ func TestSyncStatusProvider(t *testing.T) { }, }, statusReqErr: nil, - expected: types.ErrNotInSync, + expected: ErrNotInSync, }, { name: "CurrentL1AboveGameL1Head", @@ -67,7 +66,7 @@ func TestSyncStatusProvider(t *testing.T) { status: test.syncStatus, err: test.statusReqErr, } - validator := newSyncStatusValidator(provider) + validator := NewRollupSyncStatusValidator(provider) err := validator.ValidateNodeSynced(context.Background(), test.gameL1Head) require.ErrorIs(t, err, test.expected) }) diff --git a/op-challenger/game/client/supervisor.go b/op-challenger/game/client/supervisor.go new file mode 100644 index 00000000000..f4a57ed2519 --- /dev/null +++ b/op-challenger/game/client/supervisor.go @@ -0,0 +1,33 @@ +package client + +import ( + "context" + "fmt" + + "github.com/ethereum-optimism/optimism/op-service/eth" +) + +type SupervisorSyncStatusProvider interface { + SyncStatus(ctx context.Context) (eth.SupervisorSyncStatus, error) +} + +type SupervisorSyncValidator struct { + syncStatusProvider SupervisorSyncStatusProvider +} + +func NewSupervisorSyncValidator(syncStatusProvider SupervisorSyncStatusProvider) *SupervisorSyncValidator { + return &SupervisorSyncValidator{ + syncStatusProvider: syncStatusProvider, + } +} + +func (s SupervisorSyncValidator) ValidateNodeSynced(ctx context.Context, gameL1Head eth.BlockID) error { + syncStatus, err := s.syncStatusProvider.SyncStatus(ctx) + if err != nil { + return fmt.Errorf("failed to retrieve sync status: %w", err) + } + if syncStatus.MinSyncedL1.Number <= gameL1Head.Number { + return fmt.Errorf("%w require L1 block above %v but at %v", ErrNotInSync, gameL1Head.Number, syncStatus.MinSyncedL1.Number) + } + return nil +} diff --git a/op-challenger/game/fault/trace/super/sync_test.go b/op-challenger/game/client/supervisor_test.go similarity index 76% rename from op-challenger/game/fault/trace/super/sync_test.go rename to op-challenger/game/client/supervisor_test.go index 300b52c90ea..44bf124af27 100644 --- a/op-challenger/game/fault/trace/super/sync_test.go +++ b/op-challenger/game/client/supervisor_test.go @@ -1,16 +1,15 @@ -package super +package client import ( "context" "errors" "testing" - "github.com/ethereum-optimism/optimism/op-challenger/game/fault/types" "github.com/ethereum-optimism/optimism/op-service/eth" "github.com/stretchr/testify/require" ) -func TestSyncStatusProvider(t *testing.T) { +func TestSupervisorSyncStatusProvider(t *testing.T) { requestErr := errors.New("boom") tests := []struct { name string @@ -31,7 +30,7 @@ func TestSyncStatusProvider(t *testing.T) { syncStatus: eth.SupervisorSyncStatus{ MinSyncedL1: eth.L1BlockRef{Number: 99}, }, - expectedError: types.ErrNotInSync, + expectedError: ErrNotInSync, }, { name: "MinSyncedL1EqualToGameHead", @@ -39,7 +38,7 @@ func TestSyncStatusProvider(t *testing.T) { syncStatus: eth.SupervisorSyncStatus{ MinSyncedL1: eth.L1BlockRef{Number: 100}, }, - expectedError: types.ErrNotInSync, + expectedError: ErrNotInSync, }, { name: "InSync", @@ -54,22 +53,22 @@ func TestSyncStatusProvider(t *testing.T) { for _, test := range tests { test := test // capture range variable t.Run(test.name, func(t *testing.T) { - stubProvider := &stubSyncStatusProvider{ + stubProvider := &stubSupervisorSyncStatusProvider{ status: test.syncStatus, err: test.statusReqErr, } - validator := NewSyncValidator(stubProvider) + validator := NewSupervisorSyncValidator(stubProvider) err := validator.ValidateNodeSynced(context.Background(), eth.BlockID{Number: test.gameL1Head}) require.ErrorIs(t, err, test.expectedError, "expected error to be %v, got %v", test.expectedError, err) }) } } -type stubSyncStatusProvider struct { +type stubSupervisorSyncStatusProvider struct { status eth.SupervisorSyncStatus err error } -func (f *stubSyncStatusProvider) SyncStatus(ctx context.Context) (eth.SupervisorSyncStatus, error) { +func (f *stubSupervisorSyncStatusProvider) SyncStatus(ctx context.Context) (eth.SupervisorSyncStatus, error) { return f.status, f.err } diff --git a/op-challenger/game/fault/clients.go b/op-challenger/game/fault/clients.go deleted file mode 100644 index edb18e9bdea..00000000000 --- a/op-challenger/game/fault/clients.go +++ /dev/null @@ -1,83 +0,0 @@ -package fault - -import ( - "context" - "fmt" - - "github.com/ethereum-optimism/optimism/op-challenger/config" - "github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/super" - "github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/utils" - "github.com/ethereum-optimism/optimism/op-service/dial" - "github.com/ethereum/go-ethereum/ethclient" - "github.com/ethereum/go-ethereum/log" -) - -type clientProvider struct { - ctx context.Context - logger log.Logger - cfg *config.Config - l2HeaderSource utils.L2HeaderSource - rollupClient RollupClient - syncValidator *syncStatusValidator - rootProvider super.RootProvider - toClose []CloseFunc -} - -func (c *clientProvider) Close() { - for _, closeFunc := range c.toClose { - closeFunc() - } -} - -func (c *clientProvider) SingleChainClients() (utils.L2HeaderSource, RollupClient, *syncStatusValidator, error) { - headers, err := c.L2HeaderSource() - if err != nil { - return nil, nil, nil, err - } - rollup, err := c.RollupClient() - if err != nil { - return nil, nil, nil, err - } - return headers, rollup, c.syncValidator, nil -} - -func (c *clientProvider) L2HeaderSource() (utils.L2HeaderSource, error) { - if c.l2HeaderSource != nil { - return c.l2HeaderSource, nil - } - if len(c.cfg.L2Rpcs) != 1 { - return nil, fmt.Errorf("incorrect number of L2 RPCs configured, expected 1 but got %d", len(c.cfg.L2Rpcs)) - } - - l2Client, err := ethclient.DialContext(c.ctx, c.cfg.L2Rpcs[0]) - if err != nil { - return nil, fmt.Errorf("dial l2 client %v: %w", c.cfg.L2Rpcs[0], err) - } - c.l2HeaderSource = l2Client - c.toClose = append(c.toClose, l2Client.Close) - return l2Client, nil -} - -func (c *clientProvider) RollupClient() (RollupClient, error) { - if c.rollupClient != nil { - return c.rollupClient, nil - } - rollupClient, err := dial.DialRollupClientWithTimeout(c.ctx, c.logger, c.cfg.RollupRpc) - if err != nil { - return nil, fmt.Errorf("dial rollup client %v: %w", c.cfg.RollupRpc, err) - } - c.rollupClient = rollupClient - c.syncValidator = newSyncStatusValidator(rollupClient) - c.toClose = append(c.toClose, rollupClient.Close) - return rollupClient, nil -} - -func (c *clientProvider) SuperchainClients() (super.RootProvider, *super.SyncValidator, error) { - supervisorClient, err := dial.DialSupervisorClientWithTimeout(c.ctx, c.logger, c.cfg.SupervisorRPC) - if err != nil { - return nil, nil, fmt.Errorf("failed to dial supervisor: %w", err) - } - c.rootProvider = supervisorClient - c.toClose = append(c.toClose, supervisorClient.Close) - return supervisorClient, super.NewSyncValidator(supervisorClient), nil -} diff --git a/op-challenger/game/fault/player.go b/op-challenger/game/fault/player.go index 7094696af2d..b1b83738b0f 100644 --- a/op-challenger/game/fault/player.go +++ b/op-challenger/game/fault/player.go @@ -6,6 +6,7 @@ import ( "fmt" "time" + "github.com/ethereum-optimism/optimism/op-challenger/game/client" "github.com/ethereum-optimism/optimism/op-challenger/game/fault/claims" "github.com/ethereum-optimism/optimism/op-challenger/game/fault/contracts" "github.com/ethereum-optimism/optimism/op-challenger/game/fault/preimages" @@ -183,7 +184,7 @@ func (g *GamePlayer) ProgressGame(ctx context.Context) gameTypes.GameStatus { g.logger.Trace("Skipping completed game") return g.status } - if err := g.syncValidator.ValidateNodeSynced(ctx, g.gameL1Head); errors.Is(err, types.ErrNotInSync) { + if err := g.syncValidator.ValidateNodeSynced(ctx, g.gameL1Head); errors.Is(err, client.ErrNotInSync) { g.logger.Warn("Local node not sufficiently up to date", "err", err) return g.status } else if err != nil { diff --git a/op-challenger/game/fault/register.go b/op-challenger/game/fault/register.go index 1fb0e66e9c0..4373a371159 100644 --- a/op-challenger/game/fault/register.go +++ b/op-challenger/game/fault/register.go @@ -5,9 +5,9 @@ import ( "fmt" "github.com/ethereum-optimism/optimism/op-challenger/config" + "github.com/ethereum-optimism/optimism/op-challenger/game/client" "github.com/ethereum-optimism/optimism/op-challenger/game/fault/claims" "github.com/ethereum-optimism/optimism/op-challenger/game/fault/contracts" - "github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/outputs" "github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/vm" faultTypes "github.com/ethereum-optimism/optimism/op-challenger/game/fault/types" keccakTypes "github.com/ethereum-optimism/optimism/op-challenger/game/keccak/types" @@ -15,7 +15,6 @@ import ( gameTypes "github.com/ethereum-optimism/optimism/op-challenger/game/types" "github.com/ethereum-optimism/optimism/op-challenger/metrics" "github.com/ethereum-optimism/optimism/op-service/clock" - "github.com/ethereum-optimism/optimism/op-service/sources/batching" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/log" ) @@ -38,11 +37,6 @@ type PrestateSource interface { PrestatePath(ctx context.Context, prestateHash common.Hash) (string, error) } -type RollupClient interface { - outputs.OutputRollupClient - SyncStatusProvider -} - func RegisterGameTypes( ctx context.Context, systemClock clock.Clock, @@ -54,94 +48,92 @@ func RegisterGameTypes( oracles OracleRegistry, txSender TxSender, gameFactory *contracts.DisputeGameFactoryContract, - caller *batching.MultiCaller, - l1HeaderSource L1HeaderSource, + clients *client.Provider, selective bool, claimants []common.Address, -) (CloseFunc, error) { - clients := &clientProvider{ctx: ctx, logger: logger, cfg: cfg} +) error { var registerTasks []*RegisterTask if cfg.GameTypeEnabled(gameTypes.CannonGameType) { l2HeaderSource, rollupClient, syncValidator, err := clients.SingleChainClients() if err != nil { - return nil, err + return err } registerTasks = append(registerTasks, NewCannonRegisterTask(gameTypes.CannonGameType, cfg, m, vm.NewOpProgramServerExecutor(logger), l2HeaderSource, rollupClient, syncValidator)) } if cfg.GameTypeEnabled(gameTypes.CannonKonaGameType) { l2HeaderSource, rollupClient, syncValidator, err := clients.SingleChainClients() if err != nil { - return nil, err + return err } registerTasks = append(registerTasks, NewCannonKonaRegisterTask(gameTypes.CannonKonaGameType, cfg, m, vm.NewKonaExecutor(), l2HeaderSource, rollupClient, syncValidator)) } if cfg.GameTypeEnabled(gameTypes.SuperCannonGameType) { rootProvider, syncValidator, err := clients.SuperchainClients() if err != nil { - return nil, err + return err } registerTasks = append(registerTasks, NewSuperCannonRegisterTask(gameTypes.SuperCannonGameType, cfg, m, vm.NewOpProgramServerExecutor(logger), rootProvider, syncValidator)) } if cfg.GameTypeEnabled(gameTypes.SuperCannonKonaGameType) { rootProvider, syncValidator, err := clients.SuperchainClients() if err != nil { - return nil, err + return err } registerTasks = append(registerTasks, NewSuperCannonKonaRegisterTask(gameTypes.SuperCannonKonaGameType, cfg, m, vm.NewKonaSuperExecutor(), rootProvider, syncValidator)) } if cfg.GameTypeEnabled(gameTypes.PermissionedGameType) { l2HeaderSource, rollupClient, syncValidator, err := clients.SingleChainClients() if err != nil { - return nil, err + return err } registerTasks = append(registerTasks, NewCannonRegisterTask(gameTypes.PermissionedGameType, cfg, m, vm.NewOpProgramServerExecutor(logger), l2HeaderSource, rollupClient, syncValidator)) } if cfg.GameTypeEnabled(gameTypes.SuperPermissionedGameType) { rootProvider, syncValidator, err := clients.SuperchainClients() if err != nil { - return nil, err + return err } registerTasks = append(registerTasks, NewSuperCannonRegisterTask(gameTypes.SuperPermissionedGameType, cfg, m, vm.NewOpProgramServerExecutor(logger), rootProvider, syncValidator)) } if cfg.GameTypeEnabled(gameTypes.AsteriscGameType) { l2HeaderSource, rollupClient, syncValidator, err := clients.SingleChainClients() if err != nil { - return nil, err + return err } registerTasks = append(registerTasks, NewAsteriscRegisterTask(gameTypes.AsteriscGameType, cfg, m, vm.NewOpProgramServerExecutor(logger), l2HeaderSource, rollupClient, syncValidator)) } if cfg.GameTypeEnabled(gameTypes.AsteriscKonaGameType) { l2HeaderSource, rollupClient, syncValidator, err := clients.SingleChainClients() if err != nil { - return nil, err + return err } registerTasks = append(registerTasks, NewAsteriscKonaRegisterTask(gameTypes.AsteriscKonaGameType, cfg, m, vm.NewKonaExecutor(), l2HeaderSource, rollupClient, syncValidator)) } if cfg.GameTypeEnabled(gameTypes.SuperAsteriscKonaGameType) { rootProvider, syncValidator, err := clients.SuperchainClients() if err != nil { - return nil, err + return err } registerTasks = append(registerTasks, NewSuperAsteriscKonaRegisterTask(gameTypes.SuperAsteriscKonaGameType, cfg, m, vm.NewKonaSuperExecutor(), rootProvider, syncValidator)) } if cfg.GameTypeEnabled(gameTypes.FastGameType) { l2HeaderSource, rollupClient, syncValidator, err := clients.SingleChainClients() if err != nil { - return nil, err + return err } registerTasks = append(registerTasks, NewAlphabetRegisterTask(gameTypes.FastGameType, l2HeaderSource, rollupClient, syncValidator)) } if cfg.GameTypeEnabled(gameTypes.AlphabetGameType) { l2HeaderSource, rollupClient, syncValidator, err := clients.SingleChainClients() if err != nil { - return nil, err + return err } registerTasks = append(registerTasks, NewAlphabetRegisterTask(gameTypes.AlphabetGameType, l2HeaderSource, rollupClient, syncValidator)) } for _, task := range registerTasks { - if err := task.Register(ctx, registry, oracles, systemClock, l1Clock, logger, m, txSender, gameFactory, caller, l1HeaderSource, selective, claimants, cfg.ResponseDelay, cfg.ResponseDelayAfter); err != nil { - return clients.Close, fmt.Errorf("failed to register %v game type: %w", task.gameType, err) + if err := task.Register(ctx, registry, oracles, systemClock, l1Clock, logger, m, txSender, gameFactory, clients.MultiCaller(), clients.L1Client(), selective, claimants, cfg.ResponseDelay, cfg.ResponseDelayAfter); err != nil { + return fmt.Errorf("failed to register %v game type: %w", task.gameType, err) } } - return clients.Close, nil + return nil } diff --git a/op-challenger/game/fault/register_task.go b/op-challenger/game/fault/register_task.go index b575d1b538f..f87aee3b27b 100644 --- a/op-challenger/game/fault/register_task.go +++ b/op-challenger/game/fault/register_task.go @@ -51,11 +51,11 @@ type RegisterTask struct { poststateBlock uint64) (*trace.Accessor, error) } -func NewSuperCannonRegisterTask(gameType gameTypes.GameType, cfg *config.Config, m caching.Metrics, serverExecutor vm.OracleServerExecutor, rootProvider super.RootProvider, syncValidator *super.SyncValidator) *RegisterTask { +func NewSuperCannonRegisterTask(gameType gameTypes.GameType, cfg *config.Config, m caching.Metrics, serverExecutor vm.OracleServerExecutor, rootProvider super.RootProvider, syncValidator SyncValidator) *RegisterTask { return newSuperCannonVMRegisterTaskWithConfig(gameType, cfg, m, serverExecutor, rootProvider, syncValidator, cfg.Cannon, cfg.CannonAbsolutePreStateBaseURL, cfg.CannonAbsolutePreState) } -func NewSuperCannonKonaRegisterTask(gameType gameTypes.GameType, cfg *config.Config, m caching.Metrics, serverExecutor vm.OracleServerExecutor, rootProvider super.RootProvider, syncValidator *super.SyncValidator) *RegisterTask { +func NewSuperCannonKonaRegisterTask(gameType gameTypes.GameType, cfg *config.Config, m caching.Metrics, serverExecutor vm.OracleServerExecutor, rootProvider super.RootProvider, syncValidator SyncValidator) *RegisterTask { return newSuperCannonVMRegisterTaskWithConfig(gameType, cfg, m, serverExecutor, rootProvider, syncValidator, cfg.CannonKona, cfg.CannonKonaAbsolutePreStateBaseURL, cfg.CannonKonaAbsolutePreState) } @@ -230,7 +230,7 @@ func NewAsteriscKonaRegisterTask(gameType gameTypes.GameType, cfg *config.Config } } -func NewSuperAsteriscKonaRegisterTask(gameType gameTypes.GameType, cfg *config.Config, m caching.Metrics, serverExecutor vm.OracleServerExecutor, rootProvider super.RootProvider, syncValidator *super.SyncValidator) *RegisterTask { +func NewSuperAsteriscKonaRegisterTask(gameType gameTypes.GameType, cfg *config.Config, m caching.Metrics, serverExecutor vm.OracleServerExecutor, rootProvider super.RootProvider, syncValidator SyncValidator) *RegisterTask { stateConverter := asterisc.NewStateConverter(cfg.AsteriscKona) return &RegisterTask{ gameType: gameType, diff --git a/op-challenger/game/fault/sync.go b/op-challenger/game/fault/sync.go deleted file mode 100644 index badbca1bc40..00000000000 --- a/op-challenger/game/fault/sync.go +++ /dev/null @@ -1,34 +0,0 @@ -package fault - -import ( - "context" - "fmt" - - "github.com/ethereum-optimism/optimism/op-challenger/game/fault/types" - "github.com/ethereum-optimism/optimism/op-service/eth" -) - -type SyncStatusProvider interface { - SyncStatus(context.Context) (*eth.SyncStatus, error) -} - -type syncStatusValidator struct { - statusProvider SyncStatusProvider -} - -func newSyncStatusValidator(statusProvider SyncStatusProvider) *syncStatusValidator { - return &syncStatusValidator{ - statusProvider: statusProvider, - } -} - -func (s *syncStatusValidator) ValidateNodeSynced(ctx context.Context, gameL1Head eth.BlockID) error { - syncStatus, err := s.statusProvider.SyncStatus(ctx) - if err != nil { - return fmt.Errorf("failed to retrieve local node sync status: %w", err) - } - if syncStatus.CurrentL1.Number <= gameL1Head.Number { - return fmt.Errorf("%w require L1 block above %v but at %v", types.ErrNotInSync, gameL1Head.Number, syncStatus.CurrentL1.Number) - } - return nil -} diff --git a/op-challenger/game/fault/trace/super/sync.go b/op-challenger/game/fault/trace/super/sync.go deleted file mode 100644 index ec7348c739b..00000000000 --- a/op-challenger/game/fault/trace/super/sync.go +++ /dev/null @@ -1,34 +0,0 @@ -package super - -import ( - "context" - "fmt" - - "github.com/ethereum-optimism/optimism/op-challenger/game/fault/types" - "github.com/ethereum-optimism/optimism/op-service/eth" -) - -type SyncValidator struct { - syncStatusProvider SyncStatusProvider -} - -type SyncStatusProvider interface { - SyncStatus(ctx context.Context) (eth.SupervisorSyncStatus, error) -} - -func NewSyncValidator(syncStatusProvider SyncStatusProvider) *SyncValidator { - return &SyncValidator{ - syncStatusProvider: syncStatusProvider, - } -} - -func (s SyncValidator) ValidateNodeSynced(ctx context.Context, gameL1Head eth.BlockID) error { - syncStatus, err := s.syncStatusProvider.SyncStatus(ctx) - if err != nil { - return fmt.Errorf("failed to retrieve sync status: %w", err) - } - if syncStatus.MinSyncedL1.Number <= gameL1Head.Number { - return fmt.Errorf("%w require L1 block above %v but at %v", types.ErrNotInSync, gameL1Head.Number, syncStatus.MinSyncedL1.Number) - } - return nil -} diff --git a/op-challenger/game/fault/types/types.go b/op-challenger/game/fault/types/types.go index a6be5d5c158..04269b4b7c2 100644 --- a/op-challenger/game/fault/types/types.go +++ b/op-challenger/game/fault/types/types.go @@ -18,7 +18,6 @@ import ( var ( ErrGameDepthReached = errors.New("game depth reached") ErrL2BlockNumberValid = errors.New("l2 block number is valid") - ErrNotInSync = errors.New("local node too far behind") ) type ClockReader interface { diff --git a/op-challenger/game/service.go b/op-challenger/game/service.go index 28f279d455b..eb7be17c098 100644 --- a/op-challenger/game/service.go +++ b/op-challenger/game/service.go @@ -7,6 +7,7 @@ import ( "io" "sync/atomic" + challengerClient "github.com/ethereum-optimism/optimism/op-challenger/game/client" "github.com/ethereum-optimism/optimism/op-challenger/game/keccak" "github.com/ethereum-optimism/optimism/op-challenger/game/keccak/fetcher" "github.com/ethereum-optimism/optimism/op-challenger/sender" @@ -38,7 +39,7 @@ type Service struct { monitor *gameMonitor sched *scheduler.Scheduler - faultGamesCloser fault.CloseFunc + clientProvider *challengerClient.Provider preimages *keccak.LargePreimageScheduler @@ -211,9 +212,8 @@ func (s *Service) initBondClaims() error { func (s *Service) registerGameTypes(ctx context.Context, cfg *config.Config) error { gameTypeRegistry := registry.NewGameTypeRegistry() oracles := registry.NewOracleRegistry() - caller := batching.NewMultiCaller(s.l1Client.Client(), batching.DefaultBatchSize) - closer, err := fault.RegisterGameTypes(ctx, s.systemClock, s.l1Clock, s.logger, s.metrics, cfg, gameTypeRegistry, oracles, s.txSender, s.factoryContract, caller, s.l1Client, cfg.SelectiveClaimResolution, s.claimants) - s.faultGamesCloser = closer + s.clientProvider = challengerClient.NewProvider(ctx, s.logger, cfg, s.l1Client) + err := fault.RegisterGameTypes(ctx, s.systemClock, s.l1Clock, s.logger, s.metrics, cfg, gameTypeRegistry, oracles, s.txSender, s.factoryContract, s.clientProvider, cfg.SelectiveClaimResolution, s.claimants) if err != nil { return err } @@ -272,8 +272,8 @@ func (s *Service) Stop(ctx context.Context) error { result = errors.Join(result, fmt.Errorf("failed to close claimer: %w", err)) } } - if s.faultGamesCloser != nil { - s.faultGamesCloser() + if s.clientProvider != nil { + s.clientProvider.Close() } if s.pprofService != nil { if err := s.pprofService.Stop(ctx); err != nil {