fix(dash): key rotation ChainLock signatures per quorum work block

dash-spv/src/sync/events.rs

@@ -241,12 +241,13 @@ impl fmt::Display for SyncEvent {
             } => match qr_info_result {
                 Some(s) => write!(
                     f,
-                    "MasternodeStateUpdated(height={}, qr_info={{stored_cycle_height={:?}, verified={}/{}, newly_qualified={}}})",
+                    "MasternodeStateUpdated(height={}, qr_info={{stored_cycle_height={:?}, verified={}/{}, newly_qualified={}, previous_cycle_invalid={}}})",
                     height,
                     s.stored_cycle_height,
                     s.fully_verified_count,
                     s.rotated_quorum_count,
                     s.newly_qualified_count,
+                    s.previous_cycle_invalid_count,
                 ),
                 None => write!(f, "MasternodeStateUpdated(height={})", height),
             },

dash-spv/src/sync/masternodes/sync_manager.rs

@@ -296,11 +296,14 @@ impl<H: BlockHeaderStorage> SyncManager for MasternodesManager<H> {
 
                 if let Some(ref qr_info_result) = qr_info_result {
                     tracing::info!(
-                        "QRInfo processed: stored_cycle_height={:?}, rotated_quorum_count={}, fully_verified_count={}, newly_qualified_count={}",
+                        "QRInfo processed: stored_cycle_height={:?}, rotated_quorum_count={}/{}, fully_verified_count={}, newly_qualified_count={}, cycle_key_unresolved={}, previous_cycle_invalid_count={}",
                         qr_info_result.stored_cycle_height,
                         qr_info_result.rotated_quorum_count,
+                        qr_info_result.expected_rotated_quorum_count,
                         qr_info_result.fully_verified_count,
                         qr_info_result.newly_qualified_count,
+                        qr_info_result.cycle_key_unresolved,
+                        qr_info_result.previous_cycle_invalid_count,
                     );
                     // If every rotated quorum in this QRInfo ended up Verified,
                     // mark the cycle validated so `next_pipeline_mode` will

dash/Cargo.toml

@@ -33,6 +33,7 @@ eddsa = ["ed25519-dalek"]
 quorum_validation = ["bls"]
 message_verification = ["bls"]
 bincode = [ "dep:bincode", "dep:bincode_derive", "dashcore_hashes/bincode", "dash-network/bincode" ]
+qrinfo-capture = ["bincode"]
 test-utils = []
 
 [package.metadata.docs.rs]

dash/src/sml/llmq_entry_verification.rs

@@ -25,11 +25,11 @@ pub enum LLMQEntryVerificationSkipStatus {
     /// fetch.
     MissingChainLock(CoreBlockHeight, BlockHash),
     /// The quorum entry came through without an attached
-    /// `VerifyingChainLockSignaturesType::Rotating`. Typically happens when
-    /// a QRInfo's historical diff covers a block range in which no rotating
-    /// DKG successfully committed, so `apply_diff` extracts no
-    /// `rotation_sig` and `feed_qr_info` can't populate the 4-sig tuple for
-    /// the quorums in `lastCommitmentPerIndex`.
+    /// `VerifyingChainLockSignaturesType::Rotating`. Each of the four quarter
+    /// signatures is looked up by the work height of its quarter in the
+    /// `quorumsCLSigs` mapping the QRInfo's diffs carry, so a QRInfo that
+    /// covers none of a quorum's quarter work blocks, or whose quorum hash
+    /// heights are unknown, leaves the 4-sig tuple unpopulated.
     MissingRotationChainLockSigs(QuorumHash),
     /// A specific rotation chain-lock signature at offset `h - n` was not
     /// present for the masternode diff at the given block hash. The first
@@ -38,6 +38,12 @@ pub enum LLMQEntryVerificationSkipStatus {
     /// where the entire 4-sig tuple is absent.
     MissingRotationChainLockSig(u8, BlockHash),
     OtherContext(String),
+    /// At least one of the quarter chain-lock signatures used to reconstruct
+    /// this quorum was keyed by elimination rather than by a known quorum
+    /// height, so a verification failure says nothing about the quorum data
+    /// itself. Retry logic can resolve it by feeding the heights of the
+    /// rotated quorum hashes the QRInfo carries.
+    InferredRotationChainLockSigs(QuorumHash),
 }
 
 impl Display for LLMQEntryVerificationSkipStatus {
@@ -71,6 +77,9 @@ impl Display for LLMQEntryVerificationSkipStatus {
                 LLMQEntryVerificationSkipStatus::OtherContext(message) => {
                     format!("OtherContext({message})")
                 }
+                LLMQEntryVerificationSkipStatus::InferredRotationChainLockSigs(quorum_hash) => {
+                    format!("InferredRotationChainLockSigs({})", quorum_hash)
+                }
             }
             .as_str(),
         )
@@ -122,6 +131,13 @@ impl From<QuorumValidationError> for LLMQEntryVerificationStatus {
                     offset, block_hash,
                 ))
             }
+            // A cycle base sitting below the depth a rotation reconstruction
+            // reaches back to means the quarter lists cannot exist yet. That
+            // is missing history like its siblings above, so it degrades the
+            // one quorum instead of rejecting everything served with it.
+            QuorumValidationError::CycleBaseHeightTooLow(height) => {
+                Self::Skipped(LLMQEntryVerificationSkipStatus::MissedList(height))
+            }
             other => Self::Invalid(other),
         }
     }
@@ -208,6 +224,12 @@ mod tests {
                     LLMQEntryVerificationSkipStatus::MissingRotationChainLockSig(2, h4),
                 ),
             ),
+            (
+                QuorumValidationError::CycleBaseHeightTooLow(5),
+                LLMQEntryVerificationStatus::Skipped(LLMQEntryVerificationSkipStatus::MissedList(
+                    5,
+                )),
+            ),
             (
                 QuorumValidationError::InvalidQuorumPublicKey,
                 LLMQEntryVerificationStatus::Invalid(QuorumValidationError::InvalidQuorumPublicKey),
@@ -237,6 +259,10 @@ mod tests {
                 LLMQEntryVerificationSkipStatus::MissingRotationChainLockSig(2, h),
                 format!("MissingRotationChainLockSig(h - 2, {h})"),
             ),
+            (
+                LLMQEntryVerificationSkipStatus::InferredRotationChainLockSigs(h),
+                format!("InferredRotationChainLockSigs({h})"),
+            ),
         ];
 
         for (status, expected) in cases {