fix(node): update stale block time after resetting connections

If a block is considered stale, the `advance_state` function will reset
connections with all peers. To reset the "staleness" of a block, the
`LastBlockMonitor::update` function must be called. Currently that is done
upon receiving new block headers, but no headers will ever be sent, as
`advance_state` disconnects the peers before they can send them once
a block is considered stale. Here we patch this to reset the "staleness"
of a block after disconnecting from all peers.

Author: rustaceanrob

src/core/mod.rs

@@ -48,7 +48,7 @@ impl LastBlockMonitor {
         Self { last_block: None }
     }
 
-    pub(crate) fn update(&mut self) {
+    pub(crate) fn reset(&mut self) {
         self.last_block = Some(Instant::now())
     }
 

src/core/node.rs

@@ -188,7 +188,7 @@ impl<H: HeaderStore, P: PeerStore> Node<H, P> {
         let mut client_recv = self.client_recv.lock().await;
         loop {
             // Try to advance the state of the node
-            self.advance_state(&last_block).await;
+            self.advance_state(&mut last_block).await;
             // Connect to more peers if we need them and remove old connections
             self.dispatch().await?;
             // If there are blocks we need in the queue, we should request them of a random peer
@@ -216,7 +216,7 @@ impl<H: HeaderStore, P: PeerStore> Node<H, P> {
                                 }
                                 PeerMessage::Addr(addresses) => self.handle_new_addrs(addresses).await,
                                 PeerMessage::Headers(headers) => {
-                                    last_block.update();
+                                    last_block.reset();
                                     self.dialog.send_dialog(format!("[Peer {}]: headers", peer_thread.nonce))
                                         .await;
                                     match self.handle_headers(peer_thread.nonce, headers).await {
@@ -424,7 +424,7 @@ impl<H: HeaderStore, P: PeerStore> Node<H, P> {
     }
 
     // Try to continue with the syncing process
-    async fn advance_state(&self, last_block: &LastBlockMonitor) {
+    async fn advance_state(&self, last_block: &mut LastBlockMonitor) {
         let mut state = self.state.write().await;
         match *state {
             NodeState::Behind => {
@@ -476,6 +476,7 @@ impl<H: HeaderStore, P: PeerStore> Node<H, P> {
                         .send_dialog("Disconnecting from remote nodes to find new connections")
                         .await;
                     self.broadcast(MainThreadMessage::Disconnect).await;
+                    last_block.reset();
                 }
             }
         }