🚨 Fix 'cyclop'.

Signed-off-by: Oliver Tale-Yazdi <[email protected]>

backend/ethereum/channel/conclude.go

@@ -62,17 +62,11 @@ func (a *Adjudicator) ensureConcluded(ctx context.Context, req channel.Adjudicat
 		subErr <- sub.Read(ctx, events)
 	}()
 
-	// In final Register calls, as the non-initiator, we optimistically wait for
-	// the other party to send the transaction first for
-	// `secondaryWaitBlocks + TxFinalityDepth` many blocks.
-	if req.Tx.IsFinal && req.Secondary {
-		waitBlocks := secondaryWaitBlocks + int(a.txFinalityDepth)
-		isConcluded, err := waitConcludedForNBlocks(waitCtx, a, events, waitBlocks)
-		if err != nil {
-			return err
-		} else if isConcluded {
-			return nil
-		}
+	concluded, err := a.waitConcludedSecondary(waitCtx, req, events)
+	if err != nil {
+		return errors.WithMessage(err, "waiting for secondary conclude")
+	} else if concluded {
+		return nil
 	}
 
 	// No conclude event found in the past, send transaction.
@@ -100,6 +94,17 @@ func (a *Adjudicator) ensureConcluded(ctx context.Context, req channel.Adjudicat
 	}
 }
 
+func (a *Adjudicator) waitConcludedSecondary(ctx context.Context, req channel.AdjudicatorReq, events chan *subscription.Event) (concluded bool, err error) {
+	// In final Register calls, as the non-initiator, we optimistically wait for
+	// the other party to send the transaction first for
+	// `secondaryWaitBlocks + TxFinalityDepth` many blocks.
+	if req.Tx.IsFinal && req.Secondary {
+		waitBlocks := secondaryWaitBlocks + int(a.txFinalityDepth)
+		return waitConcludedForNBlocks(ctx, a, events, waitBlocks)
+	}
+	return false, nil
+}
+
 func (a *Adjudicator) conclude(ctx context.Context, req channel.AdjudicatorReq, subStates channel.StateMap) error {
 	// If the on-chain state resulted from forced execution, we do not have a fully-signed state and cannot call concludeFinal.
 	forceExecuted, err := a.isForceExecuted(ctx, req.Params.ID())

backend/ethereum/subscription/eventsub.go

@@ -174,19 +174,9 @@ read2:
 	}
 
 	for _, log := range logs {
-		event := s.eFact()
-		if err := s.contract.UnpackLog(event.Data, event.Name, log); err != nil {
+		if err := s.processLog(ctx, log, sink); err != nil {
 			return err
 		}
-		event.Log = log
-
-		select {
-		case <-ctx.Done():
-			return ctx.Err()
-		case sink <- event:
-		case <-s.closer.Closed():
-			return nil
-		}
 	}
 	return nil
 }
@@ -195,19 +185,9 @@ func (s *EventSub) readFuture(ctx context.Context, sink chan<- *Event) error {
 	for {
 		select {
 		case log := <-s.watchLogs:
-			event := s.eFact()
-			if err := s.contract.UnpackLog(event.Data, event.Name, log); err != nil {
+			if err := s.processLog(ctx, log, sink); err != nil {
 				return err
 			}
-			event.Log = log
-
-			select {
-			case <-ctx.Done():
-				return ctx.Err()
-			case sink <- event:
-			case <-s.closer.Closed():
-				return nil
-			}
 		case err := <-s.watchSub.Err():
 			err = cherrors.CheckIsChainNotReachableError(err)
 			return err
@@ -219,6 +199,23 @@ func (s *EventSub) readFuture(ctx context.Context, sink chan<- *Event) error {
 	}
 }
 
+func (s *EventSub) processLog(ctx context.Context, log types.Log, sink chan<- *Event) error {
+	event := s.eFact()
+	if err := s.contract.UnpackLog(event.Data, event.Name, log); err != nil {
+		return err
+	}
+	event.Log = log
+
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case sink <- event:
+		return nil
+	case <-s.closer.Closed():
+		return nil
+	}
+}
+
 // Close closes the sub and frees associated resources.
 // Can be called more than once. Is thread safe.
 func (s *EventSub) Close() {