fix: contract event handler for ShutterState

Author: ezdac

rolling-shutter/medley/chainsync/syncer/shutterstate.go

@@ -88,29 +88,38 @@ func (s *ShutterStateSyncer) Start(ctx context.Context, runner service.Runner) e
 	if s.Handler == nil {
 		return errors.New("no handler registered")
 	}
-	watchOpts := &bind.WatchOpts{
-		Start:   s.StartBlock.ToUInt64Ptr(), // nil means latest
+	// the latest block still has to be fixed.
+	// otherwise we could skip some block events
+	// between the initial poll and the subscription.
+	if s.StartBlock.IsLatest() {
+		latest, err := s.Client.BlockNumber(ctx)
+		if err != nil {
+			return err
+		}
+		s.StartBlock.SetUint64(latest)
+	}
+
+	opts := &bind.WatchOpts{
+		Start:   s.StartBlock.ToUInt64Ptr(),
 		Context: ctx,
 	}
 	s.pausedCh = make(chan *bindings.KeyperSetManagerPaused)
 	runner.Defer(func() {
 		close(s.pausedCh)
 	})
 	s.unpausedCh = make(chan *bindings.KeyperSetManagerUnpaused)
-	if !s.DisableEventWatcher {
-	}
 	runner.Defer(func() {
 		close(s.unpausedCh)
 	})
 
 	if !s.DisableEventWatcher {
-		subs, err := s.Contract.WatchPaused(watchOpts, s.pausedCh)
+		subs, err := s.Contract.WatchPaused(opts, s.pausedCh)
 		// FIXME: what to do on subs.Error()
 		if err != nil {
 			return err
 		}
 		runner.Defer(subs.Unsubscribe)
-		subs, err = s.Contract.WatchUnpaused(watchOpts, s.unpausedCh)
+		subs, err = s.Contract.WatchUnpaused(opts, s.unpausedCh)
 		// FIXME: what to do on subs.Error()
 		if err != nil {
 			return err
@@ -124,14 +133,6 @@ func (s *ShutterStateSyncer) Start(ctx context.Context, runner service.Runner) e
 	return nil
 }
 
-func (s *ShutterStateSyncer) pollIsActive(ctx context.Context) (bool, error) {
-	callOpts := bind.CallOpts{
-		Context: ctx,
-	}
-	paused, err := s.Contract.Paused(&callOpts)
-	return !paused, err
-}
-
 func (s *ShutterStateSyncer) handle(ctx context.Context, ev *event.ShutterState) {
 	err := s.Handler(ctx, ev)
 	if err != nil {
@@ -144,40 +145,56 @@ func (s *ShutterStateSyncer) handle(ctx context.Context, ev *event.ShutterState)
 }
 
 func (s *ShutterStateSyncer) watchPaused(ctx context.Context) error {
-	isActive, err := s.pollIsActive(ctx)
+	// query the initial state
+	// and construct a "virtual"
+	// event
+	opts := &bind.CallOpts{
+		BlockNumber: s.StartBlock.Int,
+		Context:     nil,
+	}
+
+	stateAtStartBlock, err := s.GetShutterState(ctx, opts)
 	if err != nil {
 		// XXX: this will fail everything, do we want that?
 		return err
 	}
-	ev := &event.ShutterState{
-		Active: isActive,
-	}
-	s.handle(ctx, ev)
+	s.handle(ctx, stateAtStartBlock)
+	lastState := stateAtStartBlock
 	for {
 		select {
-		case _, ok := <-s.unpausedCh:
+		case unpaused, ok := <-s.unpausedCh:
 			if !ok {
 				return nil
 			}
-			if isActive {
-				s.Log.Error("state mismatch", "got", "actice", "have", "inactive")
+			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,
+				Active:        true,
+				AtBlockNumber: number.NewBlockNumber(&block),
 			}
-			isActive = ev.Active
 			s.handle(ctx, ev)
-		case _, ok := <-s.pausedCh:
+		case paused, ok := <-s.pausedCh:
 			if !ok {
 				return nil
 			}
-			if isActive {
-				s.Log.Error("state mismatch", "got", "inactive", "have", "active")
+			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,
+				Active:        false,
+				AtBlockNumber: number.NewBlockNumber(&block),
 			}
-			isActive = ev.Active
 			s.handle(ctx, ev)
 		case <-ctx.Done():
 			return ctx.Err()