fix(consensus): classify wrapped state commit duplicate errors as duplicate requests (#10916)

* fix(consensus): classify wrapped state commit duplicate errors as duplicate requests

* Apply suggestions from code review

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* Update CHANGELOG.md

Co-authored-by: Janito Vaqueiro Ferreira Filho <janito.vff@gmail.com>

* address comments

---------

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
Co-authored-by: Janito Vaqueiro Ferreira Filho <janito.vff@gmail.com>

Author: 3 people

CHANGELOG.md

@@ -12,6 +12,7 @@ and this project adheres to [Semantic Versioning](https://semver.org).
 - Don't disconnect from peers that return empty `FindBlocks` or `FindHeaders`
   responses when the local node is at or near the chain tip
   ([#10732](https://github.com/ZcashFoundation/zebra/pull/10732))
+- Fix syncer restarts due to incorrect error downcasting.
 
 ## [Zebra 6.0.0-rc.0](https://github.com/ZcashFoundation/zebra/releases/tag/v6.0.0-rc.0) - 2026-07-02
 

zebra-consensus/src/block.rs

@@ -119,6 +119,25 @@ impl VerifyBlockError {
     }
 }
 
+/// Converts an error from a `CommitSemanticallyVerifiedBlock` state request
+/// into a [`VerifyBlockError`].
+///
+/// The state boxes commit errors as [`zs::CommitSemanticallyVerifiedError`], a
+/// newtype around [`zs::CommitBlockError`], so the wrapper must be unwrapped
+/// here for `is_duplicate_request()` and `misbehavior_score()` to classify
+/// duplicate blocks as benign.
+fn map_commit_error(source: BoxError, hash: block::Hash) -> VerifyBlockError {
+    if let Some(commit_err) = source
+        .downcast_ref::<zs::CommitSemanticallyVerifiedError>()
+        .map(zs::CommitSemanticallyVerifiedError::inner)
+        .or_else(|| source.downcast_ref::<zs::CommitBlockError>())
+    {
+        return VerifyBlockError::Commit(commit_err.clone());
+    }
+
+    VerifyBlockError::StateService { source, hash }
+}
+
 /// The maximum number of transparent signature operations allowed in a block.
 ///
 /// # Consensus
@@ -380,13 +399,7 @@ where
                     Ok(hash)
                 }
 
-                Err(source) => {
-                    if let Some(commit_err) = source.downcast_ref::<zs::CommitBlockError>() {
-                        return Err(VerifyBlockError::Commit(commit_err.clone()));
-                    }
-
-                    Err(VerifyBlockError::StateService { source, hash })
-                }
+                Err(source) => Err(map_commit_error(source, hash)),
 
                 _ => unreachable!("wrong response for CommitSemanticallyVerifiedBlock"),
             }

zebra-consensus/src/block/tests.rs

@@ -844,3 +844,28 @@ fn verify_block_error_misbehavior_scores() {
     };
     assert_eq!(VerifyBlockError::Commit(dup_err).misbehavior_score(), 0);
 }
+
+/// Duplicate block errors must stay classified as duplicate requests after the
+/// state wraps them, so they don't restart the syncer or turn `submitblock`
+/// duplicates into rejections.
+#[test]
+fn state_commit_duplicate_errors_are_duplicate_requests() {
+    let duplicate = zs::CommitBlockError::Duplicate {
+        hash_or_height: None,
+        location: zs::KnownBlock::BestChain,
+    };
+
+    // Box the error the same way the state's `CommitSemanticallyVerifiedBlock`
+    // handler does. This mirrors the wrapping manually, so it won't fail
+    // automatically if the state changes its error type — keep it in sync by hand.
+    let source: BoxError = Box::new(zs::CommitSemanticallyVerifiedError::from(duplicate));
+
+    let err = map_commit_error(source, block::Hash([0; 32]));
+
+    assert!(
+        matches!(err, VerifyBlockError::Commit(_)),
+        "state commit errors must be unwrapped into VerifyBlockError::Commit, got: {err:?}"
+    );
+    assert!(err.is_duplicate_request());
+    assert_eq!(err.misbehavior_score(), 0);
+}

zebra-consensus/src/checkpoint.rs

@@ -1025,6 +1025,12 @@ impl VerifyCheckpointError {
             // TODO: make this duplicate-incomplete
             VerifyCheckpointError::NewerRequest { .. } => true,
             VerifyCheckpointError::VerifyBlock(block_error) => block_error.is_duplicate_request(),
+            // The state boxes commit errors as `zs::CommitCheckpointVerifiedError`,
+            // a newtype around `zs::CommitBlockError`, so the wrapper must be
+            // unwrapped to classify duplicate blocks as benign.
+            VerifyCheckpointError::CommitCheckpointVerified(source) => source
+                .downcast_ref::<zs::CommitCheckpointVerifiedError>()
+                .is_some_and(|commit_err| commit_err.inner().is_duplicate_request()),
             _ => false,
         }
     }

zebra-consensus/src/checkpoint/tests.rs

@@ -814,3 +814,23 @@ async fn hard_coded_mainnet() -> Result<(), Report> {
 
     Ok(())
 }
+
+/// Duplicate block errors must stay classified as duplicate requests after the
+/// state wraps them, so they don't restart the syncer during checkpoint sync.
+#[test]
+fn state_commit_duplicate_errors_are_duplicate_requests() {
+    let duplicate = zs::CommitBlockError::Duplicate {
+        hash_or_height: None,
+        location: zs::KnownBlock::Finalized,
+    };
+
+    // Box the error the same way the state's `CommitCheckpointVerifiedBlock`
+    // handler does. This mirrors the wrapping manually, so it won't fail
+    // automatically if the state changes its error type — keep it in sync by hand.
+    let source: BoxError = Box::new(zs::CommitCheckpointVerifiedError::from(duplicate));
+
+    let err = VerifyCheckpointError::CommitCheckpointVerified(source);
+
+    assert!(err.is_duplicate_request());
+    assert_eq!(err.misbehavior_score(), 0);
+}

zebra-state/src/error.rs

@@ -136,6 +136,13 @@ impl CommitBlockError {
 #[error("could not commit semantically-verified block")]
 pub struct CommitSemanticallyVerifiedError(#[from] CommitBlockError);
 
+impl CommitSemanticallyVerifiedError {
+    /// Returns the [`CommitBlockError`] describing why the commit failed.
+    pub fn inner(&self) -> &CommitBlockError {
+        &self.0
+    }
+}
+
 impl From<ValidateContextError> for CommitSemanticallyVerifiedError {
     fn from(value: ValidateContextError) -> Self {
         Self(CommitBlockError::ValidateContextError(Box::new(value)))
@@ -164,6 +171,13 @@ impl<E: std::error::Error + 'static> From<BoxError> for LayeredStateError<E> {
 #[error("could not commit checkpoint-verified block")]
 pub struct CommitCheckpointVerifiedError(#[from] CommitBlockError);
 
+impl CommitCheckpointVerifiedError {
+    /// Returns the [`CommitBlockError`] describing why the commit failed.
+    pub fn inner(&self) -> &CommitBlockError {
+        &self.0
+    }
+}
+
 impl From<ValidateContextError> for CommitCheckpointVerifiedError {
     fn from(value: ValidateContextError) -> Self {
         Self(CommitBlockError::ValidateContextError(Box::new(value)))

zebra-state/src/lib.rs

@@ -43,8 +43,8 @@ pub use constants::{
     state_database_format_version_in_code, MAX_BLOCK_REORG_HEIGHT, MAX_NON_FINALIZED_CHAIN_FORKS,
 };
 pub use error::{
-    BoxError, CloneError, CommitBlockError, CommitSemanticallyVerifiedError,
-    DuplicateNullifierError, StateInitError, ValidateContextError,
+    BoxError, CloneError, CommitBlockError, CommitCheckpointVerifiedError,
+    CommitSemanticallyVerifiedError, DuplicateNullifierError, StateInitError, ValidateContextError,
 };
 pub use request::{
     CheckpointVerifiedBlock, CommitSemanticallyVerifiedBlockRequest, HashOrHeight, MappedRequest,