fix(consensus,sharding,libp2p): address PR #48 review feedback

- nodesCoordinator: guard EpochStartPrepare display block against a nil
  nodesConfig[newEpoch] when SetNodes returns an error, and acquire
  mutNodesMaps.RLock() for consistency with other readers.
- slotConsensus: rewrite the SetConsensusGroup doc comment so it matches
  the body — the two writes are intentionally non-atomic to keep the
  JobDone hot path off the ConsensusGroup lock; the brief inconsistency
  self-heals on the next poll.
- consensusState: add SetWaitingAllSignaturesTimeOutIfSlot to perform
  the slot-equality check and the flag write under a single mutSlotState
  write lock.
- subslotSignature: use the new helper in waitAllSignatures so a stale
  goroutine cannot set WaitingAllSignaturesTimeOut after BeginNewSlot
  has cleared state.
- libp2p netMessenger: replace per-iteration time.After with a reusable
  time.Ticker so the connection-monitor sweep loop no longer allocates
  a fresh timer on every iteration.

Author: fbsobreira

core/consensus/slot/bls/subslotSignature.go

@@ -327,21 +327,14 @@ func (sr *subslotSignature) waitAllSignatures(spawnSlot int64) {
 		// All signatures collected (100%), exit immediately
 		return
 	case <-timeout.C:
-		sr.RLockSlotState()
-		currentSlot := sr.SlotIndex
-		sr.RUnlockSlotState()
-		if currentSlot != spawnSlot {
-			// Slot has advanced — this goroutine belongs to a stale slot. Do
-			// not touch shared state; the current slot has its own goroutine.
-			return
-		}
-
 		// Timeout reached, check if subslot is already finished by threshold signatures
 		if sr.IsSubslotFinished(sr.Current()) {
 			return
 		}
 
-		sr.SetWaitingAllSignaturesTimeOut(true)
+		if !sr.SetWaitingAllSignaturesTimeOutIfSlot(spawnSlot, true) {
+			return
+		}
 		select {
 		case sr.ConsensusChannel() <- true:
 		default:

core/consensus/slot/consensusState.go

@@ -75,6 +75,20 @@ func (cns *ConsensusState) SetWaitingAllSignaturesTimeOut(timedOut bool) {
 	cns.mutSlotState.Unlock()
 }
 
+// SetWaitingAllSignaturesTimeOutIfSlot atomically sets WaitingAllSignaturesTimeOut
+// only when SlotIndex still equals spawnSlot. Returns true when the write was
+// applied. Used by waitAllSignatures to ensure a stale goroutine cannot set the
+// flag after BeginNewSlot has already advanced the slot and cleared state.
+func (cns *ConsensusState) SetWaitingAllSignaturesTimeOutIfSlot(spawnSlot int64, timedOut bool) bool {
+	cns.mutSlotState.Lock()
+	defer cns.mutSlotState.Unlock()
+	if cns.SlotIndex != spawnSlot {
+		return false
+	}
+	cns.WaitingAllSignaturesTimeOut = timedOut
+	return true
+}
+
 // NewConsensusState creates a new ConsensusState object
 func NewConsensusState(
 	slotConsensus *slotConsensus,

core/consensus/slot/slotConsensus.go

@@ -13,8 +13,12 @@ import (
 //   - mutConsensusGroup protects consensusGroup
 //   - mut           protects validatorSlotStates
 //
-// SetConsensusGroup acquires mutConsensusGroup and mut in that order to swap
-// both atomically with respect to combined readers; never the reverse order.
+// SetConsensusGroup installs consensusGroup and validatorSlotStates in two
+// separate critical sections (mutConsensusGroup, then mut); the writes are
+// intentionally not atomic against combined readers, and a concurrent
+// ComputeSize can undercount for one poll cycle before self-healing on the
+// next poll. Lock order is fixed: mutConsensusGroup before mut, never the
+// reverse, so readers holding mut.RLock can safely call ConsensusGroup().
 type slotConsensus struct {
 	electedNodes        map[string]struct{}
 	mutElected          sync.RWMutex

network/p2p/libp2p/netMessenger.go

@@ -439,12 +439,14 @@ func (netMes *networkMessenger) createConnectionMonitor(p2pConfig config.P2PConf
 		// goroutine had no termination signal and leaked on Close(), which
 		// accumulated under test rigs that spin clusters up and down in the
 		// same process (-count=N integration tests).
+		ticker := time.NewTicker(durationCheckConnections)
+		defer ticker.Stop()
 		for {
 			cmw.CheckConnectionsBlocking()
 			select {
 			case <-netMes.ctx.Done():
 				return
-			case <-time.After(durationCheckConnections):
+			case <-ticker.C:
 			}
 		}
 	}()

sharding/nodesCoordinator.go

@@ -786,18 +786,18 @@ func (ihgs *indexHashedNodesCoordinator) EpochStartPrepare(metaHdr data.HeaderHa
 
 	ihgs.mutNodesConfig.RLock()
 	displayCfg := ihgs.nodesConfig[newEpoch]
-	displayElected := displayCfg.electedList
-	displayEligible := displayCfg.eligibleList
-	displayWaiting := displayCfg.waitingList
-	displayLeaving := displayCfg.leavingList
 	ihgs.mutNodesConfig.RUnlock()
 
-	displayNodesConfiguration(
-		displayElected,
-		displayEligible,
-		displayWaiting,
-		displayLeaving,
-	)
+	if displayCfg != nil {
+		displayCfg.mutNodesMaps.RLock()
+		elected := displayCfg.electedList
+		eligible := displayCfg.eligibleList
+		waiting := displayCfg.waitingList
+		leaving := displayCfg.leavingList
+		displayCfg.mutNodesMaps.RUnlock()
+
+		displayNodesConfiguration(elected, eligible, waiting, leaving)
+	}
 
 	ihgs.mutSavedStateKey.Lock()
 	ihgs.savedStateKey = randomness