feat(chainsync): allow not fetching past active events

ezdac · ezdac · commit 3b0ca62603b2 · 2024-02-23T21:14:15.000+01:00
diff --git a/rolling-shutter/medley/chainsync/options.go b/rolling-shutter/medley/chainsync/options.go
@@ -28,6 +28,7 @@ type options struct {
 	logger                      log.Logger
 	runner                      service.Runner
 	syncStart                   *number.BlockNumber
+	fetchActivesAtSyncStart     bool
 	privKey                     *ecdsa.PrivateKey
 
 	handlerShutterState event.ShutterStateHandler
@@ -91,12 +92,13 @@ func (o *options) apply(ctx context.Context, c *Client) error {
 		return err
 	}
 	c.kssync = &syncer.KeyperSetSyncer{
-		Client:              client,
-		Contract:            c.KeyperSetManager,
-		Log:                 c.log,
-		StartBlock:          o.syncStart,
-		Handler:             o.handlerKeyperSet,
-		DisableEventWatcher: true,
+		Client:                  client,
+		Contract:                c.KeyperSetManager,
+		Log:                     c.log,
+		StartBlock:              o.syncStart,
+		Handler:                 o.handlerKeyperSet,
+		FetchActiveAtStartBlock: o.fetchActivesAtSyncStart,
+		DisableEventWatcher:     true,
 	}
 	if o.handlerKeyperSet != nil {
 		c.services = append(c.services, c.kssync)
@@ -108,26 +110,28 @@ func (o *options) apply(ctx context.Context, c *Client) error {
 		return err
 	}
 	c.epksync = &syncer.EonPubKeySyncer{
-		Client:              client,
-		Log:                 c.log,
-		KeyBroadcast:        c.KeyBroadcast,
-		KeyperSetManager:    c.KeyperSetManager,
-		Handler:             o.handlerEonPublicKey,
-		StartBlock:          o.syncStart,
-		DisableEventWatcher: true,
+		Client:                  client,
+		Log:                     c.log,
+		KeyBroadcast:            c.KeyBroadcast,
+		KeyperSetManager:        c.KeyperSetManager,
+		Handler:                 o.handlerEonPublicKey,
+		StartBlock:              o.syncStart,
+		FetchActiveAtStartBlock: o.fetchActivesAtSyncStart,
+		DisableEventWatcher:     true,
 	}
 	if o.handlerEonPublicKey != nil {
 		c.services = append(c.services, c.epksync)
 		syncedServices = append(syncedServices, c.epksync)
 	}
 
 	c.sssync = &syncer.ShutterStateSyncer{
-		Client:              client,
-		Contract:            c.KeyperSetManager,
-		Log:                 c.log,
-		Handler:             o.handlerShutterState,
-		StartBlock:          o.syncStart,
-		DisableEventWatcher: true,
+		Client:                  client,
+		Contract:                c.KeyperSetManager,
+		Log:                     c.log,
+		Handler:                 o.handlerShutterState,
+		StartBlock:              o.syncStart,
+		FetchActiveAtStartBlock: o.fetchActivesAtSyncStart,
+		DisableEventWatcher:     true,
 	}
 	if o.handlerShutterState != nil {
 		c.services = append(c.services, c.sssync)
@@ -169,11 +173,21 @@ func defaultOptions() *options {
 		ethClient:                   nil,
 		logger:                      noopLogger,
 		runner:                      nil,
+		fetchActivesAtSyncStart:     true,
 		syncStart:                   number.NewBlockNumber(nil),
 	}
 }
 
-func WithSyncStartBlock(blockNumber *number.BlockNumber) Option {
+func WithNoFetchActivesBeforeStart() Option {
+	return func(o *options) error {
+		o.fetchActivesAtSyncStart = false
+		return nil
+	}
+}
+
+func WithSyncStartBlock(
+	blockNumber *number.BlockNumber,
+) Option {
 	if blockNumber == nil {
 		blockNumber = number.NewBlockNumber(nil)
 	}
diff --git a/rolling-shutter/medley/chainsync/syncer/eonpubkey.go b/rolling-shutter/medley/chainsync/syncer/eonpubkey.go
@@ -18,13 +18,14 @@ import (
 var _ ManualFilterHandler = &EonPubKeySyncer{}
 
 type EonPubKeySyncer struct {
-	Client              client.EthereumClient
-	Log                 log.Logger
-	KeyBroadcast        *bindings.KeyBroadcastContract
-	KeyperSetManager    *bindings.KeyperSetManager
-	StartBlock          *number.BlockNumber
-	Handler             event.EonPublicKeyHandler
-	DisableEventWatcher bool
+	Client                  client.EthereumClient
+	Log                     log.Logger
+	KeyBroadcast            *bindings.KeyBroadcastContract
+	KeyperSetManager        *bindings.KeyperSetManager
+	StartBlock              *number.BlockNumber
+	Handler                 event.EonPublicKeyHandler
+	FetchActiveAtStartBlock bool
+	DisableEventWatcher     bool
 
 	keyBroadcastCh chan *bindings.KeyBroadcastContractEonKeyBroadcast
 }
@@ -76,15 +77,18 @@ func (s *EonPubKeySyncer) Start(ctx context.Context, runner service.Runner) erro
 		}
 		s.StartBlock.SetUint64(latest)
 	}
-	pubKs, err := s.getInitialPubKeys(ctx)
-	if err != nil {
-		return err
-	}
-	for _, k := range pubKs {
-		err := s.Handler(ctx, k)
+
+	if s.FetchActiveAtStartBlock {
+		pubKs, err := s.getInitialPubKeys(ctx)
 		if err != nil {
 			return err
 		}
+		for _, k := range pubKs {
+			err := s.Handler(ctx, k)
+			if err != nil {
+				return err
+			}
+		}
 	}
 
 	watchOpts := &bind.WatchOpts{
diff --git a/rolling-shutter/medley/chainsync/syncer/keyperset.go b/rolling-shutter/medley/chainsync/syncer/keyperset.go
@@ -30,7 +30,8 @@ type KeyperSetSyncer struct {
 	StartBlock *number.BlockNumber
 	Handler    event.KeyperSetHandler
 	// disable this when the QueryAndHandle manual polling should be used:
-	DisableEventWatcher bool
+	FetchActiveAtStartBlock bool
+	DisableEventWatcher     bool
 
 	keyperAddedCh chan *bindings.KeyperSetManagerKeyperSetAdded
 }
@@ -87,18 +88,21 @@ func (s *KeyperSetSyncer) Start(ctx context.Context, runner service.Runner) erro
 		Start:   s.StartBlock.ToUInt64Ptr(),
 		Context: ctx,
 	}
-	initial, err := s.getInitialKeyperSets(ctx)
-	if err != nil {
-		return err
-	}
-	for _, ks := range initial {
-		err = s.Handler(ctx, ks)
+
+	if s.FetchActiveAtStartBlock {
+		initial, err := s.getInitialKeyperSets(ctx)
 		if err != nil {
-			s.Log.Error(
-				"handler for `NewKeyperSet` errored for initial sync",
-				"error",
-				err.Error(),
-			)
+			return err
+		}
+		for _, ks := range initial {
+			err = s.Handler(ctx, ks)
+			if err != nil {
+				s.Log.Error(
+					"handler for `NewKeyperSet` errored for initial sync",
+					"error",
+					err.Error(),
+				)
+			}
 		}
 	}
 	s.keyperAddedCh = make(chan *bindings.KeyperSetManagerKeyperSetAdded, channelSize)
diff --git a/rolling-shutter/medley/chainsync/syncer/shutterstate.go b/rolling-shutter/medley/chainsync/syncer/shutterstate.go
@@ -17,12 +17,13 @@ import (
 var _ ManualFilterHandler = &ShutterStateSyncer{}
 
 type ShutterStateSyncer struct {
-	Client              client.EthereumClient
-	Contract            *bindings.KeyperSetManager
-	StartBlock          *number.BlockNumber
-	Log                 log.Logger
-	Handler             event.ShutterStateHandler
-	DisableEventWatcher bool
+	Client                  client.EthereumClient
+	Contract                *bindings.KeyperSetManager
+	StartBlock              *number.BlockNumber
+	Log                     log.Logger
+	Handler                 event.ShutterStateHandler
+	FetchActiveAtStartBlock bool
+	DisableEventWatcher     bool
 
 	pausedCh   chan *bindings.KeyperSetManagerPaused
 	unpausedCh chan *bindings.KeyperSetManagerUnpaused
@@ -153,26 +154,20 @@ func (s *ShutterStateSyncer) watchPaused(ctx context.Context) error {
 		Context:     nil,
 	}
 
-	stateAtStartBlock, err := s.GetShutterState(ctx, opts)
-	if err != nil {
-		// XXX: this will fail everything, do we want that?
-		return err
+	if s.FetchActiveAtStartBlock {
+		stateAtStartBlock, err := s.GetShutterState(ctx, opts)
+		if err != nil {
+			// XXX: this will fail everything, do we want that?
+			return err
+		}
+		s.handle(ctx, stateAtStartBlock)
 	}
-	s.handle(ctx, stateAtStartBlock)
-	lastState := stateAtStartBlock
 	for {
 		select {
 		case unpaused, ok := <-s.unpausedCh:
 			if !ok {
 				return nil
 			}
-			if lastState.Active {
-				s.Log.Warn(
-					"state/event mismatch, but continue handler",
-					"new-event", "Unpaused",
-					"last-state", "active",
-				)
-			}
 			block := unpaused.Raw.BlockNumber
 			ev := &event.ShutterState{
 				Active:        true,
@@ -183,13 +178,6 @@ func (s *ShutterStateSyncer) watchPaused(ctx context.Context) error {
 			if !ok {
 				return nil
 			}
-			if !lastState.Active {
-				s.Log.Warn(
-					"state/event mismatch, but continue handler",
-					"new-event", "Paused",
-					"last-state", "inactive",
-				)
-			}
 			block := paused.Raw.BlockNumber
 			ev := &event.ShutterState{
 				Active:        false,
