Add NodeError::is_expected() and WARN logging for unexpected validator errors

Add an `is_expected()` method to `NodeError` that classifies errors as
normal protocol flow (BlobsNotFound, EventsNotFound, WrongRound, etc.)
vs unexpected issues (network errors, validator misbehavior). This
mirrors the `is_local()` pattern used on the server side.

Use this in the updater's error escape paths (send_confirmed_certificate,
send_validated_certificate, send_block_proposal, request_timeout) to
log unexpected errors at WARN while keeping expected ones at DEBUG.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: afck

linera-core/src/node.rs

@@ -340,6 +340,28 @@ pub enum NodeError {
     },
 }
 
+impl NodeError {
+    /// Returns whether this error is an expected part of the protocol flow.
+    ///
+    /// Expected errors are those that validators return during normal operation and that
+    /// the client handles automatically (e.g. by supplying missing data and retrying).
+    /// Unexpected errors indicate genuine network issues, validator misbehavior, or
+    /// internal problems.
+    pub fn is_expected(&self) -> bool {
+        matches!(
+            self,
+            NodeError::BlobsNotFound(_)
+                | NodeError::EventsNotFound(_)
+                | NodeError::MissingCrossChainUpdate { .. }
+                | NodeError::WrongRound(_)
+                | NodeError::UnexpectedBlockHeight { .. }
+                | NodeError::InactiveChain(_)
+                | NodeError::InvalidTimestamp { .. }
+                | NodeError::MissingCertificateValue
+        )
+    }
+}
+
 impl From<tonic::Status> for NodeError {
     fn from(status: tonic::Status) -> Self {
         Self::GrpcError {

linera-core/src/updater.rs

@@ -280,7 +280,18 @@ where
                     self.remote_node.node.upload_blobs(blobs).await?;
                     sent_blobs = true;
                 }
-                result => return Ok(result?),
+                result => {
+                    if let Err(err) = &result {
+                        if !err.is_expected() {
+                            tracing::warn!(
+                                remote_node = self.remote_node.address(),
+                                %err,
+                                "unexpected error from validator",
+                            );
+                        }
+                    }
+                    return Ok(result?);
+                }
             }
             result = self
                 .remote_node
@@ -325,10 +336,20 @@ where
             }
             _ => return Ok(result?),
         }
-        Ok(self
+        let result = self
             .remote_node
             .handle_validated_certificate(certificate)
-            .await?)
+            .await;
+        if let Err(err) = &result {
+            if !err.is_expected() {
+                tracing::warn!(
+                    remote_node = self.remote_node.address(),
+                    %err,
+                    "unexpected error from validator",
+                );
+            }
+        }
+        Ok(result?)
     }
 
     /// Requests a vote for a timeout certificate for the given round from the remote node.
@@ -348,6 +369,14 @@ where
             .await;
         if let Err(err) = &result {
             self.sync_if_needed(chain_id, round, height, err).await?;
+            if !err.is_expected() {
+                tracing::warn!(
+                    remote_node = self.remote_node.address(),
+                    %chain_id,
+                    %err,
+                    "unexpected error from validator",
+                );
+            }
         }
         Ok(result?)
     }
@@ -606,7 +635,17 @@ where
                         .await;
                 }
                 // Fail immediately on other errors.
-                Err(err) => return Err(err.into()),
+                Err(err) => {
+                    if !err.is_expected() {
+                        tracing::warn!(
+                            remote_node = self.remote_node.address(),
+                            %chain_id,
+                            %err,
+                            "unexpected error from validator",
+                        );
+                    }
+                    return Err(err.into());
+                }
             }
         }
     }