feat/modify rotate key to ask for all signatures

signer/src/stacks/contracts.rs

@@ -203,6 +203,14 @@ pub enum StacksTx {
     SmartContract(SmartContract),
 }
 
+impl StacksTx {
+    /// Returns true if the transaction is a rotate keys transaction, regardless
+    /// of the version.
+    pub fn is_rotate_keys(&self) -> bool {
+        matches!(self, StacksTx::ContractCall(ContractCall::RotateKeysV1(_)))
+    }
+}
+
 impl AsTxPayload for StacksTx {
     fn tx_payload(&self) -> TransactionPayload {
         match self {

signer/src/stacks/wallet.rs

@@ -345,6 +345,11 @@ impl MultisigTx {
         &self.tx
     }
 
+    /// Return the message digest associated with the transaction
+    pub fn digest(&self) -> &Message {
+        &self.digest
+    }
+
     /// Return the total number of signatures that have been received so
     /// far for this transaction.
     pub fn num_signatures(&self) -> u16 {

signer/src/transaction_coordinator.rs

@@ -43,6 +43,7 @@ use crate::metrics::Metrics;
 use crate::metrics::BITCOIN_BLOCKCHAIN;
 use crate::metrics::STACKS_BLOCKCHAIN;
 use crate::network;
+use crate::signature::RecoverableEcdsaSignature as _;
 use crate::signature::TaprootSignature;
 use crate::stacks::api::FeePriority;
 use crate::stacks::api::GetNakamotoStartHeight;
@@ -900,6 +901,22 @@ where
     ) -> Result<StacksTransaction, Error> {
         let txid = req.txid;
 
+        // Determine the number of signatures required for the transaction. If
+        // the transaction is a rotate keys transaction, then we require all
+        // signers to sign the transaction to ensure that all signers have
+        // successfully finished DKG. Otherwise, we only need the number of
+        // signatures required by the wallet.
+        //
+        // Note: this check is naive and assumes that signers are correctly
+        // validating the new aggregate key. A malicious/faulty signer can
+        // still sign the transaction as the signer simply signs the transaction
+        // using their configured private key.
+        let signatures_required = if req.contract_tx.is_rotate_keys() {
+            wallet.num_signers()
+        } else {
+            wallet.signatures_required()
+        } as usize;
+
         // We ask for the signers to sign our transaction (including
         // ourselves, via our tx signer event loop)
         self.send_message(req, chain_tip).await?;
@@ -913,7 +930,15 @@ where
         tokio::pin!(signal_stream);
 
         let future = async {
-            while multi_tx.num_signatures() < wallet.signatures_required() {
+            let mut pending_signers = wallet.public_keys().clone();
+
+            // This serves as a "super-condition" relative to `multi_tx.num_signatures() < wallet.signatures_required()`:
+            // - We start with a full set of expected signers `pending_signers`.
+            // - Each valid signature is verified using `recover_ecdsa(multi_tx.digest())`, ensuring that only the
+            //   actual signers of the expected transaction digest can remove themselves from `pending_signers`.
+            // - We stop collecting signatures once we have enough, but keep tracking responses from remaining signers
+            //   for key rotation transactions.
+            while wallet.public_keys().len() - pending_signers.len() < signatures_required {
                 // If signal_stream.next() returns None then one of the
                 // underlying streams has closed. That means either the
                 // network stream, the internal message stream, or the
@@ -938,6 +963,19 @@ where
                     _ => continue,
                 };
 
+                let enough_signatures = multi_tx.num_signatures() >= wallet.signatures_required();
+                let recovered_key = sig.signature.recover_ecdsa(multi_tx.digest());
+
+                if let Ok(key) = recovered_key {
+                    pending_signers.remove(&key);
+                }
+
+                // Stop collecting signatures once we have enough, but keep tracking responses
+                // from remaining signers for key rotation transactions
+                if enough_signatures {
+                    continue;
+                }
+
                 if let Err(error) = multi_tx.add_signature(sig.signature) {
                     tracing::warn!(
                         %txid,