Skip to content

N
nebula
Commit 56ad5b77 authored by Adrian Sutton's avatar Adrian Sutton Committed by GitHub
Browse files
Options

challenger: Simplify register code (#8384)

parent 72956dae
Show whitespace changes
Inline Side-by-side
Showing with 63 additions and 152 deletions
op-challenger/game/fault/player.go
View file @ 56ad5b77
...@@ -36,12 +36,7 @@ type GameContract interface { ...@@ -36,12 +36,7 @@ type GameContract interface {
GetMaxGameDepth(ctx context.Context) (uint64, error) GetMaxGameDepth(ctx context.Context) (uint64, error)
} }
type gameTypeResources interface { type resourceCreator func(ctx context.Context, logger log.Logger, gameDepth uint64, dir string) (types.TraceAccessor, error)
Contract() GameContract
CreateAccessor(ctx context.Context, logger log.Logger, gameDepth uint64, dir string) (types.TraceAccessor, error)
}
type resourceCreator func(addr common.Address) (gameTypeResources, error)
func NewGamePlayer( func NewGamePlayer(
ctx context.Context, ctx context.Context,
...@@ -50,17 +45,11 @@ func NewGamePlayer( ...@@ -50,17 +45,11 @@ func NewGamePlayer(
dir string, dir string,
addr common.Address, addr common.Address,
txMgr txmgr.TxManager, txMgr txmgr.TxManager,
loader GameContract,
creator resourceCreator, creator resourceCreator,
) (*GamePlayer, error) { ) (*GamePlayer, error) {
logger = logger.New("game", addr) logger = logger.New("game", addr)
resources, err := creator(addr)
if err != nil {
return nil, fmt.Errorf("failed to create game resources: %w", err)
}
loader := resources.Contract()
status, err := loader.GetStatus(ctx) status, err := loader.GetStatus(ctx)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to fetch game status: %w", err) return nil, fmt.Errorf("failed to fetch game status: %w", err)
...@@ -84,7 +73,7 @@ func NewGamePlayer( ...@@ -84,7 +73,7 @@ func NewGamePlayer(
return nil, fmt.Errorf("failed to fetch the game depth: %w", err) return nil, fmt.Errorf("failed to fetch the game depth: %w", err)
} }
accessor, err := resources.CreateAccessor(ctx, logger, gameDepth, dir) accessor, err := creator(ctx, logger, gameDepth, dir)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to create trace accessor: %w", err) return nil, fmt.Errorf("failed to create trace accessor: %w", err)
} }
......
op-challenger/game/fault/register.go
View file @ 56ad5b77
...@@ -16,7 +16,6 @@ import ( ...@@ -16,7 +16,6 @@ import (
"github.com/ethereum-optimism/optimism/op-challenger/metrics" "github.com/ethereum-optimism/optimism/op-challenger/metrics"
"github.com/ethereum-optimism/optimism/op-service/sources/batching" "github.com/ethereum-optimism/optimism/op-service/sources/batching"
"github.com/ethereum-optimism/optimism/op-service/txmgr" "github.com/ethereum-optimism/optimism/op-service/txmgr"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/ethclient" "github.com/ethereum/go-ethereum/ethclient"
"github.com/ethereum/go-ethereum/log" "github.com/ethereum/go-ethereum/log"
) )
...@@ -57,7 +56,7 @@ func RegisterGameTypes( ...@@ -57,7 +56,7 @@ func RegisterGameTypes(
registerOutputCannon(registry, ctx, logger, m, cfg, txMgr, caller, l2Client) registerOutputCannon(registry, ctx, logger, m, cfg, txMgr, caller, l2Client)
} }
if cfg.TraceTypeEnabled(config.TraceTypeOutputAlphabet) { if cfg.TraceTypeEnabled(config.TraceTypeOutputAlphabet) {
registerOutputAlphabet(registry, ctx, logger, m, cfg, txMgr, caller, l2Client) registerOutputAlphabet(registry, ctx, logger, m, cfg, txMgr, caller)
} }
if cfg.TraceTypeEnabled(config.TraceTypeCannon) { if cfg.TraceTypeEnabled(config.TraceTypeCannon) {
registerCannon(registry, ctx, logger, m, cfg, txMgr, caller, l2Client) registerCannon(registry, ctx, logger, m, cfg, txMgr, caller, l2Client)
...@@ -75,52 +74,31 @@ func registerOutputAlphabet( ...@@ -75,52 +74,31 @@ func registerOutputAlphabet(
m metrics.Metricer, m metrics.Metricer,
cfg *config.Config, cfg *config.Config,
txMgr txmgr.TxManager, txMgr txmgr.TxManager,
caller *batching.MultiCaller, caller *batching.MultiCaller) {
l2Client cannon.L2HeaderSource) { playerCreator := func(game types.GameMetadata, dir string) (scheduler.GamePlayer, error) {
resourceCreator := func(addr common.Address) (gameTypeResources, error) { contract, err := contracts.NewOutputBisectionGameContract(game.Proxy, caller)
contract, err := contracts.NewOutputBisectionGameContract(addr, caller)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return &outputAlphabetResources{ creator := func(ctx context.Context, logger log.Logger, gameDepth uint64, dir string) (faultTypes.TraceAccessor, error) {
m: m,
cfg: cfg,
l2Client: l2Client,
contract: contract,
}, nil
}
playerCreator := func(game types.GameMetadata, dir string) (scheduler.GamePlayer, error) {
return NewGamePlayer(ctx, logger, m, dir, game.Proxy, txMgr, resourceCreator)
}
registry.RegisterGameType(outputAlphabetGameType, playerCreator)
}
type outputAlphabetResources struct {
m metrics.Metricer
cfg *config.Config
l2Client cannon.L2HeaderSource
contract *contracts.OutputBisectionGameContract
}
func (r *outputAlphabetResources) Contract() GameContract {
return r.contract
}
func (r *outputAlphabetResources) CreateAccessor(ctx context.Context, logger log.Logger, gameDepth uint64, dir string) (faultTypes.TraceAccessor, error) {
// TODO(client-pod#44): Validate absolute pre-state for split games // TODO(client-pod#44): Validate absolute pre-state for split games
prestateBlock, poststateBlock, err := r.contract.GetBlockRange(ctx) prestateBlock, poststateBlock, err := contract.GetBlockRange(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
splitDepth, err := r.contract.GetSplitDepth(ctx) splitDepth, err := contract.GetSplitDepth(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
accessor, err := outputs.NewOutputAlphabetTraceAccessor(ctx, logger, r.m, r.cfg, gameDepth, splitDepth, prestateBlock, poststateBlock) accessor, err := outputs.NewOutputAlphabetTraceAccessor(ctx, logger, m, cfg, gameDepth, splitDepth, prestateBlock, poststateBlock)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return accessor, nil return accessor, nil
}
return NewGamePlayer(ctx, logger, m, dir, game.Proxy, txMgr, contract, creator)
}
registry.RegisterGameType(outputAlphabetGameType, playerCreator)
} }
func registerOutputCannon( func registerOutputCannon(
...@@ -132,46 +110,26 @@ func registerOutputCannon( ...@@ -132,46 +110,26 @@ func registerOutputCannon(
txMgr txmgr.TxManager, txMgr txmgr.TxManager,
caller *batching.MultiCaller, caller *batching.MultiCaller,
l2Client cannon.L2HeaderSource) { l2Client cannon.L2HeaderSource) {
resourceCreator := func(addr common.Address) (gameTypeResources, error) { playerCreator := func(game types.GameMetadata, dir string) (scheduler.GamePlayer, error) {
contract, err := contracts.NewOutputBisectionGameContract(addr, caller) contract, err := contracts.NewOutputBisectionGameContract(game.Proxy, caller)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return &outputCannonResources{ creator := func(ctx context.Context, logger log.Logger, gameDepth uint64, dir string) (faultTypes.TraceAccessor, error) {
m: m,
cfg: cfg,
l2Client: l2Client,
contract: contract,
}, nil
}
playerCreator := func(game types.GameMetadata, dir string) (scheduler.GamePlayer, error) {
return NewGamePlayer(ctx, logger, m, dir, game.Proxy, txMgr, resourceCreator)
}
registry.RegisterGameType(outputCannonGameType, playerCreator)
}
type outputCannonResources struct {
m metrics.Metricer
cfg *config.Config
l2Client cannon.L2HeaderSource
contract *contracts.OutputBisectionGameContract
}
func (r *outputCannonResources) Contract() GameContract {
return r.contract
}
func (r *outputCannonResources) CreateAccessor(ctx context.Context, logger log.Logger, gameDepth uint64, dir string) (faultTypes.TraceAccessor, error) {
// TODO(client-pod#44): Validate absolute pre-state for split games // TODO(client-pod#44): Validate absolute pre-state for split games
agreed, disputed, err := r.contract.GetBlockRange(ctx) agreed, disputed, err := contract.GetBlockRange(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
accessor, err := outputs.NewOutputCannonTraceAccessor(ctx, logger, r.m, r.cfg, r.l2Client, r.contract, dir, gameDepth, agreed, disputed) accessor, err := outputs.NewOutputCannonTraceAccessor(ctx, logger, m, cfg, l2Client, contract, dir, gameDepth, agreed, disputed)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return accessor, nil return accessor, nil
}
return NewGamePlayer(ctx, logger, m, dir, game.Proxy, txMgr, contract, creator)
}
registry.RegisterGameType(outputCannonGameType, playerCreator)
} }
func registerCannon( func registerCannon(
...@@ -183,45 +141,25 @@ func registerCannon( ...@@ -183,45 +141,25 @@ func registerCannon(
txMgr txmgr.TxManager, txMgr txmgr.TxManager,
caller *batching.MultiCaller, caller *batching.MultiCaller,
l2Client cannon.L2HeaderSource) { l2Client cannon.L2HeaderSource) {
resourceCreator := func(addr common.Address) (gameTypeResources, error) { playerCreator := func(game types.GameMetadata, dir string) (scheduler.GamePlayer, error) {
contract, err := contracts.NewFaultDisputeGameContract(addr, caller) contract, err := contracts.NewFaultDisputeGameContract(game.Proxy, caller)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return &cannonResources{ creator := func(ctx context.Context, logger log.Logger, gameDepth uint64, dir string) (faultTypes.TraceAccessor, error) {
m: m, localInputs, err := cannon.FetchLocalInputs(ctx, contract, l2Client)
cfg: cfg,
l2Client: l2Client,
contract: contract,
}, nil
}
playerCreator := func(game types.GameMetadata, dir string) (scheduler.GamePlayer, error) {
return NewGamePlayer(ctx, logger, m, dir, game.Proxy, txMgr, resourceCreator)
}
registry.RegisterGameType(cannonGameType, playerCreator)
}
type cannonResources struct {
m metrics.Metricer
cfg *config.Config
l2Client cannon.L2HeaderSource
contract *contracts.FaultDisputeGameContract
}
func (r *cannonResources) Contract() GameContract {
return r.contract
}
func (r *cannonResources) CreateAccessor(ctx context.Context, logger log.Logger, gameDepth uint64, dir string) (faultTypes.TraceAccessor, error) {
localInputs, err := cannon.FetchLocalInputs(ctx, r.contract, r.l2Client)
if err != nil { if err != nil {
return nil, fmt.Errorf("failed to fetch cannon local inputs: %w", err) return nil, fmt.Errorf("failed to fetch cannon local inputs: %w", err)
} }
provider := cannon.NewTraceProvider(logger, r.m, r.cfg, faultTypes.NoLocalContext, localInputs, dir, gameDepth) provider := cannon.NewTraceProvider(logger, m, cfg, faultTypes.NoLocalContext, localInputs, dir, gameDepth)
if err := ValidateAbsolutePrestate(ctx, provider, r.contract); err != nil { if err := ValidateAbsolutePrestate(ctx, provider, contract); err != nil {
return nil, err return nil, err
} }
return trace.NewSimpleTraceAccessor(provider), nil return trace.NewSimpleTraceAccessor(provider), nil
}
return NewGamePlayer(ctx, logger, m, dir, game.Proxy, txMgr, contract, creator)
}
registry.RegisterGameType(cannonGameType, playerCreator)
} }
func registerAlphabet( func registerAlphabet(
...@@ -232,35 +170,19 @@ func registerAlphabet( ...@@ -232,35 +170,19 @@ func registerAlphabet(
cfg *config.Config, cfg *config.Config,
txMgr txmgr.TxManager, txMgr txmgr.TxManager,
caller *batching.MultiCaller) { caller *batching.MultiCaller) {
resourceCreator := func(addr common.Address) (gameTypeResources, error) { playerCreator := func(game types.GameMetadata, dir string) (scheduler.GamePlayer, error) {
contract, err := contracts.NewFaultDisputeGameContract(addr, caller) contract, err := contracts.NewFaultDisputeGameContract(game.Proxy, caller)
if err != nil { if err != nil {
return nil, err return nil, err
} }
return &alphabetResources{ creator := func(ctx context.Context, logger log.Logger, gameDepth uint64, dir string) (faultTypes.TraceAccessor, error) {
cfg: cfg, provider := alphabet.NewTraceProvider(cfg.AlphabetTrace, gameDepth)
contract: contract, if err := ValidateAbsolutePrestate(ctx, provider, contract); err != nil {
}, nil
}
playerCreator := func(game types.GameMetadata, dir string) (scheduler.GamePlayer, error) {
return NewGamePlayer(ctx, logger, m, dir, game.Proxy, txMgr, resourceCreator)
}
registry.RegisterGameType(alphabetGameType, playerCreator)
}
type alphabetResources struct {
cfg *config.Config
contract *contracts.FaultDisputeGameContract
}
func (r *alphabetResources) Contract() GameContract {
return r.contract
}
func (r *alphabetResources) CreateAccessor(ctx context.Context, _ log.Logger, gameDepth uint64, _ string) (faultTypes.TraceAccessor, error) {
provider := alphabet.NewTraceProvider(r.cfg.AlphabetTrace, gameDepth)
if err := ValidateAbsolutePrestate(ctx, provider, r.contract); err != nil {
return nil, err return nil, err
} }
return trace.NewSimpleTraceAccessor(provider), nil return trace.NewSimpleTraceAccessor(provider), nil
}
return NewGamePlayer(ctx, logger, m, dir, game.Proxy, txMgr, contract, creator)
}
registry.RegisterGameType(alphabetGameType, playerCreator)
} }
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