Skip to content

N
nebula
Commit 5d52bea9 authored by Adrian Sutton's avatar Adrian Sutton Committed by GitHub
Browse files
Options

op-challenger: Remove l2Client and rollupClient from RegisterTask API (#13770) 

Makes RegisterTask generic enough to support interop games
parent 57fcd5d5
Show whitespace changes
Inline Side-by-side
Showing with 59 additions and 64 deletions
op-challenger/game/fault/register.go
View file @ 5d52bea9
......@@ -14,6 +14,7 @@ import (
"github.com/ethereum-optimism/optimism/op-challenger/game/scheduler"
"github.com/ethereum-optimism/optimism/op-challenger/metrics"
"github.com/ethereum-optimism/optimism/op-service/clock"
"github.com/ethereum-optimism/optimism/op-service/dial"
"github.com/ethereum-optimism/optimism/op-service/sources/batching"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/ethclient"
......@@ -52,7 +53,6 @@ func RegisterGameTypes(
cfg *config.Config,
registry Registry,
oracles OracleRegistry,
rollupClient RollupClient,
txSender TxSender,
gameFactory *contracts.DisputeGameFactoryContract,
caller *batching.MultiCaller,
......@@ -64,31 +64,41 @@ func RegisterGameTypes(
if err != nil {
return nil, fmt.Errorf("dial l2 client %v: %w", cfg.L2Rpc, err)
}
closer := l2Client.Close
rollupClient, err := dial.DialRollupClientWithTimeout(ctx, dial.DefaultDialTimeout, logger, cfg.RollupRpc)
if err != nil {
return closer, fmt.Errorf("dial rollup client %v: %w", cfg.RollupRpc, err)
}
closer = func() {
l2Client.Close()
rollupClient.Close()
}
syncValidator := newSyncStatusValidator(rollupClient)
var registerTasks []*RegisterTask
if cfg.TraceTypeEnabled(faultTypes.TraceTypeCannon) {
registerTasks = append(registerTasks, NewCannonRegisterTask(faultTypes.CannonGameType, cfg, m, vm.NewOpProgramServerExecutor(logger)))
registerTasks = append(registerTasks, NewCannonRegisterTask(faultTypes.CannonGameType, cfg, m, vm.NewOpProgramServerExecutor(logger), l2Client, rollupClient))
}
if cfg.TraceTypeEnabled(faultTypes.TraceTypePermissioned) {
registerTasks = append(registerTasks, NewCannonRegisterTask(faultTypes.PermissionedGameType, cfg, m, vm.NewOpProgramServerExecutor(logger)))
registerTasks = append(registerTasks, NewCannonRegisterTask(faultTypes.PermissionedGameType, cfg, m, vm.NewOpProgramServerExecutor(logger), l2Client, rollupClient))
}
if cfg.TraceTypeEnabled(faultTypes.TraceTypeAsterisc) {
registerTasks = append(registerTasks, NewAsteriscRegisterTask(faultTypes.AsteriscGameType, cfg, m, vm.NewOpProgramServerExecutor(logger)))
registerTasks = append(registerTasks, NewAsteriscRegisterTask(faultTypes.AsteriscGameType, cfg, m, vm.NewOpProgramServerExecutor(logger), l2Client, rollupClient))
}
if cfg.TraceTypeEnabled(faultTypes.TraceTypeAsteriscKona) {
registerTasks = append(registerTasks, NewAsteriscKonaRegisterTask(faultTypes.AsteriscKonaGameType, cfg, m, vm.NewKonaExecutor()))
registerTasks = append(registerTasks, NewAsteriscKonaRegisterTask(faultTypes.AsteriscKonaGameType, cfg, m, vm.NewKonaExecutor(), l2Client, rollupClient))
}
if cfg.TraceTypeEnabled(faultTypes.TraceTypeFast) {
registerTasks = append(registerTasks, NewAlphabetRegisterTask(faultTypes.FastGameType))
registerTasks = append(registerTasks, NewAlphabetRegisterTask(faultTypes.FastGameType, l2Client, rollupClient))
}
if cfg.TraceTypeEnabled(faultTypes.TraceTypeAlphabet) {
registerTasks = append(registerTasks, NewAlphabetRegisterTask(faultTypes.AlphabetGameType))
registerTasks = append(registerTasks, NewAlphabetRegisterTask(faultTypes.AlphabetGameType, l2Client, rollupClient))
}
for _, task := range registerTasks {
if err := task.Register(ctx, registry, oracles, systemClock, l1Clock, logger, m, syncValidator, rollupClient, txSender, gameFactory, caller, l2Client, l1HeaderSource, selective, claimants); err != nil {
return nil, fmt.Errorf("failed to register %v game type: %w", task.gameType, err)
if err := task.Register(ctx, registry, oracles, systemClock, l1Clock, logger, m, syncValidator, txSender, gameFactory, caller, l1HeaderSource, selective, claimants); err != nil {
return closer, fmt.Errorf("failed to register %v game type: %w", task.gameType, err)
}
}
return l2Client.Close, nil
return closer, nil
}
op-challenger/game/fault/register_task.go
View file @ 5d52bea9
......@@ -33,14 +33,13 @@ type RegisterTask struct {
gameType faultTypes.GameType
skipPrestateValidation bool
getPrestateProvider func(ctx context.Context, prestateHash common.Hash) (faultTypes.PrestateProvider, error)
getTopPrestateProvider func(ctx context.Context, prestateBlock uint64) (faultTypes.PrestateProvider, error)
getBottomPrestateProvider func(ctx context.Context, prestateHash common.Hash) (faultTypes.PrestateProvider, error)
newTraceAccessor func(
logger log.Logger,
m metrics.Metricer,
l2Client utils.L2HeaderSource,
prestateProvider faultTypes.PrestateProvider,
vmPrestateProvider faultTypes.PrestateProvider,
rollupClient outputs.OutputRollupClient,
dir string,
l1Head eth.BlockID,
splitDepth faultTypes.Depth,
......@@ -48,7 +47,7 @@ type RegisterTask struct {
poststateBlock uint64) (*trace.Accessor, error)
}
func NewCannonRegisterTask(gameType faultTypes.GameType, cfg *config.Config, m caching.Metrics, serverExecutor vm.OracleServerExecutor) *RegisterTask {
func NewCannonRegisterTask(gameType faultTypes.GameType, cfg *config.Config, m caching.Metrics, serverExecutor vm.OracleServerExecutor, l2Client utils.L2HeaderSource, rollupClient outputs.OutputRollupClient) *RegisterTask {
stateConverter := cannon.NewStateConverter(cfg.Cannon)
return &RegisterTask{
gameType: gameType,
......@@ -56,7 +55,10 @@ func NewCannonRegisterTask(gameType faultTypes.GameType, cfg *config.Config, m c
// Only trusted actors participate in these games so they aren't expected to reach the step() call and
// are often configured without valid prestates but the challenger should still resolve the games.
skipPrestateValidation: gameType == faultTypes.PermissionedGameType,
getPrestateProvider: cachePrestates(
getTopPrestateProvider: func(ctx context.Context, prestateBlock uint64) (faultTypes.PrestateProvider, error) {
return outputs.NewPrestateProvider(rollupClient, prestateBlock), nil
},
getBottomPrestateProvider: cachePrestates(
gameType,
stateConverter,
m,
......@@ -69,10 +71,8 @@ func NewCannonRegisterTask(gameType faultTypes.GameType, cfg *config.Config, m c
newTraceAccessor: func(
logger log.Logger,
m metrics.Metricer,
l2Client utils.L2HeaderSource,
prestateProvider faultTypes.PrestateProvider,
vmPrestateProvider faultTypes.PrestateProvider,
rollupClient outputs.OutputRollupClient,
dir string,
l1Head eth.BlockID,
splitDepth faultTypes.Depth,
......@@ -84,11 +84,14 @@ func NewCannonRegisterTask(gameType faultTypes.GameType, cfg *config.Config, m c
}
}
func NewAsteriscRegisterTask(gameType faultTypes.GameType, cfg *config.Config, m caching.Metrics, serverExecutor vm.OracleServerExecutor) *RegisterTask {
func NewAsteriscRegisterTask(gameType faultTypes.GameType, cfg *config.Config, m caching.Metrics, serverExecutor vm.OracleServerExecutor, l2Client utils.L2HeaderSource, rollupClient outputs.OutputRollupClient) *RegisterTask {
stateConverter := asterisc.NewStateConverter(cfg.Asterisc)
return &RegisterTask{
gameType: gameType,
getPrestateProvider: cachePrestates(
getTopPrestateProvider: func(ctx context.Context, prestateBlock uint64) (faultTypes.PrestateProvider, error) {
return outputs.NewPrestateProvider(rollupClient, prestateBlock), nil
},
getBottomPrestateProvider: cachePrestates(
gameType,
stateConverter,
m,
......@@ -101,10 +104,8 @@ func NewAsteriscRegisterTask(gameType faultTypes.GameType, cfg *config.Config, m
newTraceAccessor: func(
logger log.Logger,
m metrics.Metricer,
l2Client utils.L2HeaderSource,
prestateProvider faultTypes.PrestateProvider,
vmPrestateProvider faultTypes.PrestateProvider,
rollupClient outputs.OutputRollupClient,
dir string,
l1Head eth.BlockID,
splitDepth faultTypes.Depth,
......@@ -116,11 +117,14 @@ func NewAsteriscRegisterTask(gameType faultTypes.GameType, cfg *config.Config, m
}
}
func NewAsteriscKonaRegisterTask(gameType faultTypes.GameType, cfg *config.Config, m caching.Metrics, serverExecutor vm.OracleServerExecutor) *RegisterTask {
func NewAsteriscKonaRegisterTask(gameType faultTypes.GameType, cfg *config.Config, m caching.Metrics, serverExecutor vm.OracleServerExecutor, l2Client utils.L2HeaderSource, rollupClient outputs.OutputRollupClient) *RegisterTask {
stateConverter := asterisc.NewStateConverter(cfg.Asterisc)
return &RegisterTask{
gameType: gameType,
getPrestateProvider: cachePrestates(
getTopPrestateProvider: func(ctx context.Context, prestateBlock uint64) (faultTypes.PrestateProvider, error) {
return outputs.NewPrestateProvider(rollupClient, prestateBlock), nil
},
getBottomPrestateProvider: cachePrestates(
gameType,
stateConverter,
m,
......@@ -133,10 +137,8 @@ func NewAsteriscKonaRegisterTask(gameType faultTypes.GameType, cfg *config.Confi
newTraceAccessor: func(
logger log.Logger,
m metrics.Metricer,
l2Client utils.L2HeaderSource,
prestateProvider faultTypes.PrestateProvider,
vmPrestateProvider faultTypes.PrestateProvider,
rollupClient outputs.OutputRollupClient,
dir string,
l1Head eth.BlockID,
splitDepth faultTypes.Depth,
......@@ -148,19 +150,20 @@ func NewAsteriscKonaRegisterTask(gameType faultTypes.GameType, cfg *config.Confi
}
}
func NewAlphabetRegisterTask(gameType faultTypes.GameType) *RegisterTask {
func NewAlphabetRegisterTask(gameType faultTypes.GameType, l2Client utils.L2HeaderSource, rollupClient outputs.OutputRollupClient) *RegisterTask {
return &RegisterTask{
gameType: gameType,
getPrestateProvider: func(_ context.Context, _ common.Hash) (faultTypes.PrestateProvider, error) {
getTopPrestateProvider: func(ctx context.Context, prestateBlock uint64) (faultTypes.PrestateProvider, error) {
return outputs.NewPrestateProvider(rollupClient, prestateBlock), nil
},
getBottomPrestateProvider: func(_ context.Context, _ common.Hash) (faultTypes.PrestateProvider, error) {
return alphabet.PrestateProvider, nil
},
newTraceAccessor: func(
logger log.Logger,
m metrics.Metricer,
l2Client utils.L2HeaderSource,
prestateProvider faultTypes.PrestateProvider,
vmPrestateProvider faultTypes.PrestateProvider,
rollupClient outputs.OutputRollupClient,
dir string,
l1Head eth.BlockID,
splitDepth faultTypes.Depth,
......@@ -181,7 +184,8 @@ func cachePrestates(
newPrestateProvider func(ctx context.Context, path string) faultTypes.PrestateProvider,
) func(ctx context.Context, prestateHash common.Hash) (faultTypes.PrestateProvider, error) {
prestateSource := prestates.NewPrestateSource(prestateBaseURL, preStatePath, prestateDir, stateConverter)
prestateProviderCache := prestates.NewPrestateProviderCache(m, fmt.Sprintf("prestates-%v", gameType), func(ctx context.Context, prestateHash common.Hash) (faultTypes.PrestateProvider, error) {
prestateProviderCache := prestates.NewPrestateProviderCache(m, fmt.Sprintf("prestates-%v", gameType),
func(ctx context.Context, prestateHash common.Hash) (faultTypes.PrestateProvider, error) {
prestatePath, err := prestateSource.PrestatePath(ctx, prestateHash)
if err != nil {
return nil, fmt.Errorf("required prestate %v not available: %w", prestateHash, err)
......@@ -200,11 +204,9 @@ func (e *RegisterTask) Register(
logger log.Logger,
m metrics.Metricer,
syncValidator SyncValidator,
rollupClient outputs.OutputRollupClient,
txSender TxSender,
gameFactory *contracts.DisputeGameFactoryContract,
caller *batching.MultiCaller,
l2Client utils.L2HeaderSource,
l1HeaderSource L1HeaderSource,
selective bool,
claimants []common.Address) error {
......@@ -219,7 +221,7 @@ func (e *RegisterTask) Register(
return nil, fmt.Errorf("failed to load prestate hash for game %v: %w", game.Proxy, err)
}
vmPrestateProvider, err := e.getPrestateProvider(ctx, requiredPrestatehash)
vmPrestateProvider, err := e.getBottomPrestateProvider(ctx, requiredPrestatehash)
if err != nil {
return nil, fmt.Errorf("required prestate %v not available for game %v: %w", requiredPrestatehash, game.Proxy, err)
}
......@@ -241,9 +243,12 @@ func (e *RegisterTask) Register(
if err != nil {
return nil, err
}
prestateProvider := outputs.NewPrestateProvider(rollupClient, prestateBlock)
prestateProvider, err := e.getTopPrestateProvider(ctx, prestateBlock)
if err != nil {
return nil, fmt.Errorf("failed to create top prestate provider: %w", err)
}
creator := func(ctx context.Context, logger log.Logger, gameDepth faultTypes.Depth, dir string) (faultTypes.TraceAccessor, error) {
accessor, err := e.newTraceAccessor(logger, m, l2Client, prestateProvider, vmPrestateProvider, rollupClient, dir, l1HeadID, splitDepth, prestateBlock, poststateBlock)
accessor, err := e.newTraceAccessor(logger, m, prestateProvider, vmPrestateProvider, dir, l1HeadID, splitDepth, prestateBlock, poststateBlock)
if err != nil {
return nil, err
}
......
op-challenger/game/service.go
View file @ 5d52bea9
......@@ -10,7 +10,6 @@ import (
"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"
"github.com/ethereum-optimism/optimism/op-service/sources"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/ethclient"
"github.com/ethereum/go-ethereum/log"
......@@ -55,7 +54,6 @@ type Service struct {
factoryContract *contracts.DisputeGameFactoryContract
registry *registry.GameTypeRegistry
oracles *registry.OracleRegistry
rollupClient *sources.RollupClient
l1Client *ethclient.Client
pollClient client.RPC
......@@ -93,9 +91,6 @@ func (s *Service) initFromConfig(ctx context.Context, cfg *config.Config) error
if err := s.initL1Client(ctx, cfg); err != nil {
return fmt.Errorf("failed to init l1 client: %w", err)
}
if err := s.initRollupClient(ctx, cfg); err != nil {
return fmt.Errorf("failed to init rollup client: %w", err)
}
if err := s.initPollClient(ctx, cfg); err != nil {
return fmt.Errorf("failed to init poll client: %w", err)
}
......@@ -210,27 +205,15 @@ func (s *Service) initBondClaims() error {
return nil
}
func (s *Service) initRollupClient(ctx context.Context, cfg *config.Config) error {
if cfg.RollupRpc == "" {
return nil
}
rollupClient, err := dial.DialRollupClientWithTimeout(ctx, dial.DefaultDialTimeout, s.logger, cfg.RollupRpc)
if err != nil {
return err
}
s.rollupClient = rollupClient
return nil
}
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.rollupClient, s.txSender, s.factoryContract, caller, s.l1Client, cfg.SelectiveClaimResolution, s.claimants)
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
if err != nil {
return err
}
s.faultGamesCloser = closer
s.registry = gameTypeRegistry
s.oracles = oracles
return nil
......@@ -304,9 +287,6 @@ func (s *Service) Stop(ctx context.Context) error {
s.txMgr.Close()
}
if s.rollupClient != nil {
s.rollupClient.Close()
}
if s.pollClient != nil {
s.pollClient.Close()
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment