feat: add DKG verification window

docker/sbtc/signer/signer-config.toml

@@ -225,6 +225,14 @@ bootstrap_signatures_required = 2
 # Environment: SIGNER_SIGNER__DKG_TARGET_ROUNDS
 # dkg_target_rounds = 1
 
+# The number of bitcoin blocks after a DKG start where we attempt to verify the
+# shares. After this many blocks, we mark the shares as failed. Please only use
+# this parameter when instructed to by the sBTC team.
+#
+# Required: false
+# Environment: SIGNER_SIGNER__DKG_VERIFICATION_WINDOW
+# dkg_verification_window = 10
+
 # !! ==============================================================================
 # !! Stacks Event Observer Configuration
 # !!

signer/src/block_observer.rs

@@ -38,6 +38,7 @@ use crate::stacks::api::StacksInteract;
 use crate::stacks::api::TenureBlocks;
 use crate::storage;
 use crate::storage::model;
+use crate::storage::model::EncryptedDkgShares;
 use crate::storage::DbRead;
 use crate::storage::DbWrite;
 use bitcoin::hashes::Hash as _;
@@ -159,6 +160,11 @@ where
                         tracing::warn!(%error, "could not process stacks blocks");
                     }
 
+                    if let Err(error) = self.check_pending_dkg_shares(block_hash).await {
+                        tracing::warn!(%error, "could not check pending dkg shares");
+                        continue;
+                    }
+
                     tracing::debug!("updating the signer state");
                     if let Err(error) = self.update_signer_state(block_hash).await {
                         tracing::warn!(%error, "could not update the signer state");
@@ -628,6 +634,38 @@ impl<C: Context, B> BlockObserver<C, B> {
         tracing::info!("updating the signer state with the current signer set");
         self.set_signer_set_and_aggregate_key(chain_tip).await
     }
+
+    /// Checks if the latest dkg share is pending and is no longer valid
+    async fn check_pending_dkg_shares(&self, chain_tip: BlockHash) -> Result<(), Error> {
+        let db = self.context.get_storage_mut();
+
+        let last_dkg = db.get_latest_encrypted_dkg_shares().await?;
+        let Some(
+            last_dkg @ EncryptedDkgShares {
+                dkg_shares_status: model::DkgSharesStatus::Unverified,
+                ..
+            },
+        ) = last_dkg
+        else {
+            return Ok(());
+        };
+
+        let chain_tip = db
+            .get_bitcoin_block(&chain_tip.into())
+            .await?
+            .ok_or(Error::NoChainTip)?;
+        let verification_window = self.context.config().signer.dkg_verification_window;
+
+        let max_verification_height = last_dkg
+            .started_at_bitcoin_block_height
+            .saturating_add(verification_window as u64);
+
+        if max_verification_height < chain_tip.block_height {
+            db.revoke_dkg_shares(last_dkg.aggregate_key).await?;
+        }
+
+        Ok(())
+    }
 }
 
 /// Return the signing set that can make sBTC related contract calls along

signer/src/config/default.toml

@@ -231,6 +231,14 @@ sbtc_bitcoin_start_height = 101
 # Environment: SIGNER_SIGNER__DKG_TARGET_ROUNDS
 # dkg_target_rounds = 1
 
+# The number of bitcoin blocks after a DKG start where we attempt to verify the
+# shares. After this many blocks, we mark the shares as failed. Please only use
+# this parameter when instructed to by the sBTC team.
+#
+# Required: false
+# Environment: SIGNER_SIGNER__DKG_VERIFICATION_WINDOW
+# dkg_verification_window = 10
+
 # !! ==============================================================================
 # !! Stacks Event Observer Configuration
 # !!

signer/src/config/mod.rs

@@ -343,6 +343,9 @@ pub struct SignerConfig {
     /// assuming the conditions for `dkg_min_bitcoin_block_height` are also met.
     /// If DKG has never been run, this configuration has no effect.
     pub dkg_target_rounds: NonZeroU32,
+    /// The number of bitcoin blocks after a DKG start where we attempt to
+    /// verify the shares. After this many blocks, we mark the shares as failed.
+    pub dkg_verification_window: u16,
 }
 
 impl Validatable for SignerConfig {
@@ -494,6 +497,7 @@ impl Settings {
             DEFAULT_MAX_DEPOSITS_PER_BITCOIN_TX,
         )?;
         cfg_builder = cfg_builder.set_default("signer.dkg_target_rounds", 1)?;
+        cfg_builder = cfg_builder.set_default("signer.dkg_verification_window", 10)?;
 
         if let Some(path) = config_path {
             cfg_builder = cfg_builder.add_source(File::from(path.as_ref()));
@@ -631,6 +635,7 @@ mod tests {
             settings.signer.dkg_target_rounds,
             NonZeroU32::new(1).unwrap()
         );
+        assert_eq!(settings.signer.dkg_verification_window, 10);
         assert_eq!(settings.signer.dkg_min_bitcoin_block_height, None);
     }
 
@@ -790,6 +795,18 @@ mod tests {
         );
     }
 
+    #[test]
+    fn default_config_toml_loads_dkg_verification_window() {
+        clear_env();
+
+        let settings = Settings::new_from_default_config().unwrap();
+        assert_eq!(settings.signer.dkg_verification_window, 10);
+
+        std::env::set_var("SIGNER_SIGNER__DKG_VERIFICATION_WINDOW", "42");
+        let settings = Settings::new_from_default_config().unwrap();
+        assert_eq!(settings.signer.dkg_verification_window, 42);
+    }
+
     #[test]
     fn default_config_toml_loads_signer_network_with_environment() {
         clear_env();

signer/src/storage/in_memory.rs

@@ -615,7 +615,13 @@ impl super::DbRead for SharedStore {
     }
 
     async fn get_encrypted_dkg_shares_count(&self) -> Result<u32, Error> {
-        Ok(self.lock().await.encrypted_dkg_shares.len() as u32)
+        Ok(self
+            .lock()
+            .await
+            .encrypted_dkg_shares
+            .values()
+            .filter(|(_, shares)| shares.dkg_shares_status != DkgSharesStatus::Failed)
+            .count() as u32)
     }
 
     async fn get_last_key_rotation(

signer/src/storage/mod.rs

@@ -232,7 +232,7 @@ pub trait DbRead {
         &self,
     ) -> impl Future<Output = Result<Option<model::EncryptedDkgShares>, Error>> + Send;
 
-    /// Returns the number of DKG shares entries in the database.
+    /// Returns the number of non-failed DKG shares entries in the database.
     fn get_encrypted_dkg_shares_count(&self) -> impl Future<Output = Result<u32, Error>> + Send;
 
     /// Return the latest rotate-keys transaction confirmed by the given `chain-tip`.

signer/src/storage/postgres.rs

@@ -1529,12 +1529,14 @@ impl super::DbRead for PgStore {
         .map_err(Error::SqlxQuery)
     }
 
-    /// Returns the number of rows in the `dkg_shares` table.
+    /// Returns the number of non-failed rows in the `dkg_shares` table.
     async fn get_encrypted_dkg_shares_count(&self) -> Result<u32, Error> {
-        let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM sbtc_signer.dkg_shares;")
-            .fetch_one(&self.0)
-            .await
-            .map_err(Error::SqlxQuery)?;
+        let count: i64 = sqlx::query_scalar(
+            "SELECT COUNT(*) FROM sbtc_signer.dkg_shares WHERE dkg_shares_status != 'failed';",
+        )
+        .fetch_one(&self.0)
+        .await
+        .map_err(Error::SqlxQuery)?;
 
         u32::try_from(count).map_err(Error::ConversionDatabaseInt)
     }

signer/src/testing/transaction_coordinator.rs

@@ -1020,7 +1020,12 @@ where
 
         let dkg_txid = testing::dummy::txid(&fake::Faker, rng);
         let (aggregate_key, all_dkg_shares) = signer_set
-            .run_dkg(bitcoin_chain_tip, dkg_txid.into(), rng)
+            .run_dkg(
+                bitcoin_chain_tip,
+                dkg_txid.into(),
+                rng,
+                model::DkgSharesStatus::Verified,
+            )
             .await;
 
         let encrypted_dkg_shares = all_dkg_shares.first().unwrap();

signer/src/testing/transaction_signer.rs

@@ -264,7 +264,12 @@ async fn run_dkg_and_store_results_for_signers<'s: 'r, 'r, S, Rng>(
     let dkg_txid = testing::dummy::txid(&fake::Faker, rng);
     let bitcoin_chain_tip = *chain_tip;
     let (_, all_dkg_shares) = testing_signer_set
-        .run_dkg(bitcoin_chain_tip, dkg_txid.into(), rng)
+        .run_dkg(
+            bitcoin_chain_tip,
+            dkg_txid.into(),
+            rng,
+            model::DkgSharesStatus::Verified,
+        )
         .await;
 
     for (storage, encrypted_dkg_shares) in stores.into_iter().zip(all_dkg_shares) {

signer/src/testing/wsts.rs

@@ -406,6 +406,7 @@ impl SignerSet {
         bitcoin_chain_tip: model::BitcoinBlockHash,
         id: WstsMessageId,
         rng: &mut Rng,
+        dkg_shares_status: model::DkgSharesStatus,
     ) -> (PublicKey, Vec<model::EncryptedDkgShares>) {
         let mut signer_handles = Vec::new();
         for signer in self.signers.drain(..) {
@@ -430,10 +431,12 @@ impl SignerSet {
             self.signers
                 .iter()
                 .map(|signer| {
-                    signer
+                    let mut shares = signer
                         .wsts_signer
                         .get_encrypted_dkg_shares(rng, &started_at)
-                        .expect("failed to get encrypted shares")
+                        .expect("failed to get encrypted shares");
+                    shares.dkg_shares_status = dkg_shares_status;
+                    shares
                 })
                 .collect(),
         )
@@ -559,7 +562,12 @@ mod tests {
         let mut signer_set = SignerSet::new(&signer_info, threshold, || network.connect());
 
         let (_, dkg_shares) = signer_set
-            .run_dkg(bitcoin_chain_tip, txid.into(), &mut rng)
+            .run_dkg(
+                bitcoin_chain_tip,
+                txid.into(),
+                &mut rng,
+                model::DkgSharesStatus::Unverified,
+            )
             .await;
 
         assert_eq!(dkg_shares.len(), num_signers as usize);

signer/src/transaction_coordinator.rs

@@ -2000,10 +2000,10 @@ mod tests {
         // Write `dkg_shares` entries for the `current` number of rounds, simulating
         // the signer having participated in that many successful DKG rounds.
         for _ in 0..dkg_rounds_current {
-            storage
-                .write_encrypted_dkg_shares(&Faker.fake())
-                .await
-                .unwrap();
+            let mut shares: model::EncryptedDkgShares = Faker.fake();
+            shares.dkg_shares_status = model::DkgSharesStatus::Verified;
+
+            storage.write_encrypted_dkg_shares(&shares).await.unwrap();
         }
 
         // Dummy chain tip hash which will be used to fetch the block height

signer/src/transaction_signer.rs

@@ -1263,7 +1263,7 @@ where
 
 /// Asserts whether a `DkgBegin` WSTS message should be allowed to proceed
 /// based on the current state of the signer and the DKG configuration.
-async fn assert_allow_dkg_begin(
+pub async fn assert_allow_dkg_begin(
     context: &impl Context,
     bitcoin_chain_tip: &model::BitcoinBlockRef,
 ) -> Result<(), Error> {
@@ -1451,10 +1451,10 @@ mod tests {
         // Write `dkg_shares` entries for the `current` number of rounds, simulating
         // the signer having participated in that many successful DKG rounds.
         for _ in 0..dkg_rounds_current {
-            storage
-                .write_encrypted_dkg_shares(&Faker.fake())
-                .await
-                .unwrap();
+            let mut shares: model::EncryptedDkgShares = Faker.fake();
+            shares.dkg_shares_status = model::DkgSharesStatus::Verified;
+
+            storage.write_encrypted_dkg_shares(&shares).await.unwrap();
         }
 
         // Dummy chain tip hash which will be used to fetch the block height
@@ -1495,10 +1495,10 @@ mod tests {
 
         // Write 1 DKG shares entry to the database, simulating that DKG has
         // successfully run once.
-        storage
-            .write_encrypted_dkg_shares(&Faker.fake())
-            .await
-            .unwrap();
+        let mut shares: model::EncryptedDkgShares = Faker.fake();
+        shares.dkg_shares_status = model::DkgSharesStatus::Verified;
+
+        storage.write_encrypted_dkg_shares(&shares).await.unwrap();
 
         // Dummy chain tip hash which will be used to fetch the block height.
         let bitcoin_chain_tip = model::BitcoinBlockRef {
@@ -1566,10 +1566,10 @@ mod tests {
 
         // Write 1 DKG shares entry to the database, simulating that DKG has
         // successfully run once.
-        storage
-            .write_encrypted_dkg_shares(&Faker.fake())
-            .await
-            .unwrap();
+        let mut shares: model::EncryptedDkgShares = Faker.fake();
+        shares.dkg_shares_status = model::DkgSharesStatus::Verified;
+
+        storage.write_encrypted_dkg_shares(&shares).await.unwrap();
 
         // Dummy chain tip hash which will be used to fetch the block height.
         let bitcoin_chain_tip: model::BitcoinBlockHash = Faker.fake();