1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
package driver
import (
"context"
"errors"
"github.com/ethereum/go-ethereum/log"
altda "github.com/ethereum-optimism/optimism/op-alt-da"
"github.com/ethereum-optimism/optimism/op-node/metrics"
"github.com/ethereum-optimism/optimism/op-node/rollup"
"github.com/ethereum-optimism/optimism/op-node/rollup/derive"
"github.com/ethereum-optimism/optimism/op-node/rollup/engine"
"github.com/ethereum-optimism/optimism/op-node/rollup/event"
"github.com/ethereum-optimism/optimism/op-node/rollup/sync"
)
type EndCondition interface {
Closing() bool
Result() error
}
type Driver struct {
logger log.Logger
events []event.Event
end EndCondition
deriver event.Deriver
}
func NewDriver(logger log.Logger, cfg *rollup.Config, l1Source derive.L1Fetcher,
l1BlobsSource derive.L1BlobsFetcher, l2Source engine.Engine, targetBlockNum uint64) *Driver {
d := &Driver{
logger: logger,
}
pipeline := derive.NewDerivationPipeline(logger, cfg, l1Source, l1BlobsSource, altda.Disabled, l2Source, metrics.NoopMetrics)
pipelineDeriver := derive.NewPipelineDeriver(context.Background(), pipeline)
pipelineDeriver.AttachEmitter(d)
ec := engine.NewEngineController(l2Source, logger, metrics.NoopMetrics, cfg, &sync.Config{SyncMode: sync.CLSync}, d)
engineDeriv := engine.NewEngDeriver(logger, context.Background(), cfg, metrics.NoopMetrics, ec)
engineDeriv.AttachEmitter(d)
syncCfg := &sync.Config{SyncMode: sync.CLSync}
engResetDeriv := engine.NewEngineResetDeriver(context.Background(), logger, cfg, l1Source, l2Source, syncCfg)
engResetDeriv.AttachEmitter(d)
prog := &ProgramDeriver{
logger: logger,
Emitter: d,
closing: false,
result: nil,
targetBlockNum: targetBlockNum,
}
d.deriver = &event.DeriverMux{
prog,
engineDeriv,
pipelineDeriver,
engResetDeriv,
}
d.end = prog
return d
}
func (d *Driver) Emit(ev event.Event) {
if d.end.Closing() {
return
}
d.events = append(d.events, ev)
}
var ExhaustErr = errors.New("exhausted events before completing program")
func (d *Driver) RunComplete() error {
// Initial reset
d.Emit(engine.ResetEngineRequestEvent{})
for !d.end.Closing() {
if len(d.events) == 0 {
return ExhaustErr
}
if len(d.events) > 10000 { // sanity check, in case of bugs. Better than going OOM.
return errors.New("way too many events queued up, something is wrong")
}
ev := d.events[0]
d.events = d.events[1:]
d.deriver.OnEvent(ev)
}
return d.end.Result()
}