Use exhaustive match in is_expected() and extract warn_if_unexpected()

Make NodeError::is_expected() use a match without catch-all so the
compiler forces a decision when new variants are added. Extract the
duplicated WARN logging into ValidatorUpdater::warn_if_unexpected().

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

Author: afck

linera-core/src/node.rs

@@ -348,17 +348,44 @@ impl NodeError {
     /// Unexpected errors indicate genuine network issues, validator misbehavior, or
     /// internal problems.
     pub fn is_expected(&self) -> bool {
-        matches!(
-            self,
+        match self {
+            // Expected: validators return these during normal operation and the client
+            // handles them automatically by supplying missing data and retrying.
             NodeError::BlobsNotFound(_)
-                | NodeError::EventsNotFound(_)
-                | NodeError::MissingCrossChainUpdate { .. }
-                | NodeError::WrongRound(_)
-                | NodeError::UnexpectedBlockHeight { .. }
-                | NodeError::InactiveChain(_)
-                | NodeError::InvalidTimestamp { .. }
-                | NodeError::MissingCertificateValue
-        )
+            | NodeError::EventsNotFound(_)
+            | NodeError::MissingCrossChainUpdate { .. }
+            | NodeError::WrongRound(_)
+            | NodeError::UnexpectedBlockHeight { .. }
+            | NodeError::InactiveChain(_)
+            | NodeError::InvalidTimestamp { .. }
+            | NodeError::MissingCertificateValue => true,
+
+            // Unexpected: network issues, validator misbehavior, or internal problems.
+            NodeError::CryptoError { .. }
+            | NodeError::ArithmeticError { .. }
+            | NodeError::ViewError { .. }
+            | NodeError::ChainError { .. }
+            | NodeError::WorkerError { .. }
+            | NodeError::MissingCertificates(_)
+            | NodeError::MissingVoteInValidatorResponse(_)
+            | NodeError::InvalidChainInfoResponse
+            | NodeError::UnexpectedCertificateValue
+            | NodeError::InvalidDecoding
+            | NodeError::UnexpectedMessage
+            | NodeError::GrpcError { .. }
+            | NodeError::ClientIoError { .. }
+            | NodeError::CannotResolveValidatorAddress { .. }
+            | NodeError::SubscriptionError { .. }
+            | NodeError::SubscriptionFailed { .. }
+            | NodeError::InvalidCertificateForBlob(_)
+            | NodeError::DuplicatesInBlobsNotFound
+            | NodeError::UnexpectedEntriesInBlobsNotFound
+            | NodeError::UnexpectedCertificates { .. }
+            | NodeError::EmptyBlobsNotFound
+            | NodeError::ResponseHandlingError { .. }
+            | NodeError::MissingCertificatesByHeights { .. }
+            | NodeError::TooManyCertificatesReturned { .. } => false,
+        }
     }
 }
 

linera-core/src/updater.rs

@@ -236,6 +236,17 @@ impl<Env> ValidatorUpdater<Env>
 where
     Env: Environment + 'static,
 {
+    /// Logs a warning if the error is not an expected part of the protocol flow.
+    fn warn_if_unexpected(&self, err: &NodeError) {
+        if !err.is_expected() {
+            tracing::warn!(
+                remote_node = self.remote_node.address(),
+                %err,
+                "unexpected error from validator",
+            );
+        }
+    }
+
     #[instrument(
         level = "trace", skip_all, err(level = Level::DEBUG),
         fields(chain_id = %certificate.block().header.chain_id)
@@ -282,13 +293,7 @@ where
                 }
                 result => {
                     if let Err(err) = &result {
-                        if !err.is_expected() {
-                            tracing::warn!(
-                                remote_node = self.remote_node.address(),
-                                %err,
-                                "unexpected error from validator",
-                            );
-                        }
+                        self.warn_if_unexpected(err);
                     }
                     return Ok(result?);
                 }
@@ -341,13 +346,7 @@ where
             .handle_validated_certificate(certificate)
             .await;
         if let Err(err) = &result {
-            if !err.is_expected() {
-                tracing::warn!(
-                    remote_node = self.remote_node.address(),
-                    %err,
-                    "unexpected error from validator",
-                );
-            }
+            self.warn_if_unexpected(err);
         }
         Ok(result?)
     }
@@ -369,14 +368,7 @@ 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",
-                );
-            }
+            self.warn_if_unexpected(err);
         }
         Ok(result?)
     }
@@ -636,14 +628,7 @@ where
                 }
                 // Fail immediately on other errors.
                 Err(err) => {
-                    if !err.is_expected() {
-                        tracing::warn!(
-                            remote_node = self.remote_node.address(),
-                            %chain_id,
-                            %err,
-                            "unexpected error from validator",
-                        );
-                    }
+                    self.warn_if_unexpected(&err);
                     return Err(err.into());
                 }
             }