Fix test

Signed-off-by: Jacinta Ferrant <[email protected]>

Author: jferrant

stacks-signer/src/runloop.rs

@@ -415,6 +415,16 @@ impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
                     signer.commands.push_back(command.command);
                 }
             }
+            // Check if we missed any DKG messages due to a restart or being late to the party
+            // Note: We currently only check for DKG specific messages as we cannot rejoin a sign
+            // round due to a miner overwriting its own message slots (impossible to recover without every message)
+            if let Err(e) = signer.read_dkg_stackerdb_messages(
+                &self.stacks_client,
+                res.clone(),
+                current_reward_cycle,
+            ) {
+                error!("{signer}: failed to read stackerdb messages: {e}");
+            }
             // After processing event, run the next command for each signer
             signer.process_next_command(&self.stacks_client, current_reward_cycle);
         }

stacks-signer/src/signer.rs

@@ -1418,11 +1418,15 @@ impl Signer {
             // TODO: this will never work as is. We need to have stored our party shares on the side etc for this particular aggregate key.
             // Need to update state to store the necessary info, check against it to see if we have participated in the winning round and
             // then overwrite our value accordingly. Otherwise, we will be locked out of the round and should not participate.
+            let internal_dkg = self.coordinator.aggregate_public_key;
+            if internal_dkg != self.approved_aggregate_public_key {
+                warn!("{self}: we do not support changing the internal DKG key yet. Expected {internal_dkg:?} got {:?}", self.approved_aggregate_public_key);
+            }
             self.coordinator
                 .set_aggregate_public_key(self.approved_aggregate_public_key);
             if old_dkg != self.approved_aggregate_public_key {
                 warn!(
-                    "{self}: updated DKG value to {:?}.",
+                    "{self}: updated DKG value from {old_dkg:?} to {:?}.",
                     self.approved_aggregate_public_key
                 );
             }
@@ -1432,6 +1436,9 @@ impl Signer {
                     self.coordinator.current_dkg_id
                 );
                 self.finish_operation();
+            } else if self.state == State::Uninitialized {
+                // If we successfully load the DKG value, we are fully initialized
+                self.state = State::Idle;
             }
         } else if should_queue {
             if self.commands.front() != Some(&Command::Dkg) {

testnet/stacks-node/src/tests/signer.rs

@@ -59,7 +59,7 @@ use crate::tests::bitcoin_regtest::BitcoinCoreController;
 use crate::tests::nakamoto_integrations::{
     boot_to_epoch_3_reward_set, boot_to_epoch_3_reward_set_calculation_boundary,
     naka_neon_integration_conf, next_block_and, next_block_and_mine_commit,
-    POX_4_DEFAULT_STACKER_BALANCE,
+    next_block_and_process_new_stacks_block, POX_4_DEFAULT_STACKER_BALANCE,
 };
 use crate::tests::neon_integrations::{
     next_block_and_wait, run_until_burnchain_height, test_observer, wait_for_runloop,
@@ -1162,44 +1162,33 @@ fn stackerdb_delayed_dkg() {
     );
 
     info!("------------------------- Start DKG -------------------------");
-    let height = signer_test
-        .running_nodes
-        .btc_regtest_controller
-        .get_headers_height();
+    info!("Waiting for DKG to start...");
     // Advance one more to trigger DKG
-    run_until_burnchain_height(
+    next_block_and(
         &mut signer_test.running_nodes.btc_regtest_controller,
-        &signer_test.running_nodes.blocks_processed,
-        height.wrapping_add(1),
-        &signer_test.running_nodes.conf,
-    );
+        timeout.as_secs(),
+        || Ok(true),
+    )
+    .expect("Failed to mine bitcoin block");
     // Wait a bit so DKG is actually triggered and signers are not available to respond
     std::thread::sleep(Duration::from_secs(5));
 
-    // Make sure DKG did not get set
-    assert!(signer_test
-        .stacks_client
-        .get_approved_aggregate_key(reward_cycle)
-        .expect("Failed to get approved aggregate key")
-        .is_none());
-
     info!("------------------------- Restart Stopped Signer -------------------------");
 
     signer_test.restart_signer(signer_idx, signer_key);
 
     info!("------------------------- Wait for DKG -------------------------");
     let key = signer_test.wait_for_dkg(timeout);
-    let height = signer_test
-        .running_nodes
-        .btc_regtest_controller
-        .get_headers_height();
-    // Advance one more to mine dkg transactions
-    run_until_burnchain_height(
+    // Sleep a bit to make sure the transactions are broadcast.
+    std::thread::sleep(Duration::from_secs(1));
+    // Mine a block and make sure the votes were mined
+    next_block_and_process_new_stacks_block(
         &mut signer_test.running_nodes.btc_regtest_controller,
-        &signer_test.running_nodes.blocks_processed,
-        height.wrapping_add(1),
-        &signer_test.running_nodes.conf,
-    );
+        timeout.as_secs(),
+        &signer_test.running_nodes.coord_channel,
+    )
+    .unwrap();
+
     // Make sure DKG did get set
     assert_eq!(
         key,