fix(test): replace time.Sleep synchronization with deterministic polling

- ScheduleRetransmissions: register onTick handler synchronously instead
  of in a goroutine; onTick is a fast mutex+map-insert and has no reason
  to be async, and the goroutine created a registration race when tests
  sent ticks before the handler was installed
- retransmission_test: drop pre-tick yield sleeps (no longer needed) and
  replace 50ms post-tick sleeps with polling loops bounded by 2s deadline
- node_test: add waitForDispatcherIdle helper that polls until the wallet
  dispatcher is idle; replace all time.Sleep(200ms/50ms) wait-for-goroutine
  patterns with the helper
- signing_done: replace IIFE Lock/defer-Unlock pattern in write path with
  explicit Lock/Unlock -- single-statement body has no early return, so
  the closure adds indirection without benefit

Author: piotr-roslaniec

pkg/net/retransmission/retransmission.go

@@ -29,15 +29,13 @@ func ScheduleRetransmissions(
 	retransmit RetransmitFn,
 	strategy Strategy,
 ) {
-	go func() {
-		ticker.onTick(ctx, func() {
-			go func() {
-				if err := strategy.Tick(retransmit); err != nil {
-					logger.Errorf("could not retransmit message: [%v]", err)
-				}
-			}()
-		})
-	}()
+	ticker.onTick(ctx, func() {
+		go func() {
+			if err := strategy.Tick(retransmit); err != nil {
+				logger.Errorf("could not retransmit message: [%v]", err)
+			}
+		}()
+	})
 }
 
 // WithRetransmissionSupport takes the standard network message handler and

pkg/net/retransmission/retransmission_test.go

@@ -129,15 +129,15 @@ func TestScheduleRetransmissions_WithBackoffStrategy(t *testing.T) {
 		WithBackoffStrategy(),
 	)
 
-	// ScheduleRetransmissions registers its onTick handler in a goroutine;
-	// yield briefly so that goroutine runs before we start sending ticks.
-	time.Sleep(10 * time.Millisecond)
-
 	// BackoffStrategy fires at ticks 1, 3, 6, 11, 20 -- 5 fires in 20 ticks.
 	for i := uint64(1); i <= 20; i++ {
 		ticks <- i
 	}
-	time.Sleep(50 * time.Millisecond)
+
+	deadline := time.Now().Add(2 * time.Second)
+	for atomic.LoadUint64(&retransmissions) < 5 && time.Now().Before(deadline) {
+		time.Sleep(time.Millisecond)
+	}
 
 	got := atomic.LoadUint64(&retransmissions)
 	if got != 5 {
@@ -167,12 +167,18 @@ func TestScheduleRetransmissions_LogsRetransmitError(t *testing.T) {
 		WithStandardStrategy(),
 	)
 
-	// Allow the registration goroutine inside ScheduleRetransmissions to call
-	// onTick before we send the first tick.
-	time.Sleep(10 * time.Millisecond)
-
 	ticks <- 1
-	time.Sleep(50 * time.Millisecond)
+
+	deadline := time.Now().Add(2 * time.Second)
+	for time.Now().Before(deadline) {
+		logger.mu.Lock()
+		n := len(logger.errors)
+		logger.mu.Unlock()
+		if n > 0 {
+			break
+		}
+		time.Sleep(time.Millisecond)
+	}
 
 	logger.mu.Lock()
 	errs := logger.errors

pkg/tbtc/node_test.go

@@ -520,8 +520,7 @@ func TestNode_HandleHeartbeatProposal_DispatchesAction(t *testing.T) {
 
 	n.handleHeartbeatProposal(signer.wallet, &HeartbeatProposal{Message: [16]byte{0x03}}, 10, 100)
 
-	// Allow the dispatched goroutine to run and clean up.
-	time.Sleep(200 * time.Millisecond)
+	waitForDispatcherIdle(t, n)
 
 	if count := dispatchedActionsCount(n); count != 0 {
 		t.Errorf(
@@ -587,8 +586,7 @@ func TestNode_HandleDepositSweepProposal_DispatchesAction(t *testing.T) {
 		100,
 	)
 
-	// Allow the dispatched goroutine to run and clean up.
-	time.Sleep(200 * time.Millisecond)
+	waitForDispatcherIdle(t, n)
 
 	if count := dispatchedActionsCount(n); count != 0 {
 		t.Errorf(
@@ -654,8 +652,7 @@ func TestNode_HandleRedemptionProposal_DispatchesAction(t *testing.T) {
 		100,
 	)
 
-	// Allow the dispatched goroutine to run and clean up.
-	time.Sleep(200 * time.Millisecond)
+	waitForDispatcherIdle(t, n)
 
 	if count := dispatchedActionsCount(n); count != 0 {
 		t.Errorf(
@@ -716,8 +713,7 @@ func TestNode_HandleMovingFundsProposal_DispatchesAction(t *testing.T) {
 
 	n.handleMovingFundsProposal(signer.wallet, &MovingFundsProposal{}, 10, 100)
 
-	// Allow the dispatched goroutine to run and clean up.
-	time.Sleep(200 * time.Millisecond)
+	waitForDispatcherIdle(t, n)
 
 	if count := dispatchedActionsCount(n); count != 0 {
 		t.Errorf(
@@ -783,8 +779,7 @@ func TestNode_HandleMovedFundsSweepProposal_DispatchesAction(t *testing.T) {
 		100,
 	)
 
-	// Allow the dispatched goroutine to run and clean up.
-	time.Sleep(200 * time.Millisecond)
+	waitForDispatcherIdle(t, n)
 
 	if count := dispatchedActionsCount(n); count != 0 {
 		t.Errorf(
@@ -831,8 +826,7 @@ func TestProcessCoordinationResult_HeartbeatRoutesToHandler(t *testing.T) {
 
 	processCoordinationResult(n, result)
 
-	// Allow dispatched goroutine to complete.
-	time.Sleep(50 * time.Millisecond)
+	waitForDispatcherIdle(t, n)
 
 	// Dispatcher should be idle; a panicking handler would have made this fail.
 	if count := dispatchedActionsCount(n); count != 0 {
@@ -1242,6 +1236,19 @@ func dispatchedActionsCount(n *node) int {
 	return len(n.walletDispatcher.actions)
 }
 
+// waitForDispatcherIdle polls until walletDispatcher has no active actions or
+// the 2-second deadline is exceeded.
+func waitForDispatcherIdle(t *testing.T, n *node) {
+	t.Helper()
+	deadline := time.Now().Add(2 * time.Second)
+	for dispatchedActionsCount(n) > 0 {
+		if time.Now().After(deadline) {
+			t.Fatal("timed out waiting for walletDispatcher to become idle")
+		}
+		time.Sleep(time.Millisecond)
+	}
+}
+
 // createMockSigner creates a mock signer instance that can be used for
 // test cases that needs a placeholder signer. The produced signer cannot
 // be used to test actual signing scenarios.

pkg/tbtc/signing_done.go

@@ -117,11 +117,9 @@ func (sdc *signingDoneCheck) listen(
 					continue
 				}
 
-				func() {
-					sdc.doneSignersMutex.Lock()
-					defer sdc.doneSignersMutex.Unlock()
-					sdc.doneSigners[doneMessage.senderID] = doneMessage
-				}()
+				sdc.doneSignersMutex.Lock()
+				sdc.doneSigners[doneMessage.senderID] = doneMessage
+				sdc.doneSignersMutex.Unlock()
 
 			case <-sdc.receiveCtx.Done():
 				return