Merge branch 'develop' of https://github.com/stacks-network/stacks-core into chore/add-vm-error-to-transaction-event-payload

Author: jferrant

CHANGELOG.md

@@ -9,7 +9,11 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 
 ### Added
 
-- Added field `vm_error` to EventObserver transaction output
+- Added field `vm_error` to EventObserver transaction outputs
+
+### Changed
+
+- Reduce the default `block_rejection_timeout_steps` configuration so that miners will retry faster when blocks fail to reach 70% approved or 30% rejected.
 
 ## [3.1.0.0.8]
 

libsigner/src/tests/mod.rs

@@ -142,13 +142,6 @@ fn test_simple_signer() {
         chunks.push(chunk_event);
     }
 
-    chunks.sort_by(|ev1, ev2| {
-        ev1.modified_slots[0]
-            .slot_id
-            .partial_cmp(&ev2.modified_slots[0].slot_id)
-            .unwrap()
-    });
-
     let thread_chunks = chunks.clone();
 
     // simulate a node that's trying to push data
@@ -186,41 +179,45 @@ fn test_simple_signer() {
 
     let sent_events: Vec<SignerEvent<SignerMessage>> = chunks
         .iter()
-        .map(|chunk| {
-            let msg = chunk.modified_slots[0].data.clone();
-            let pubkey = chunk.modified_slots[0]
-                .recover_pk()
-                .expect("Faield to recover public key of slot");
-            let signer_message = read_next::<SignerMessage, _>(&mut &msg[..]).unwrap();
+        .map(|event| {
+            let messages: Vec<(StacksPublicKey, SignerMessage)> = event
+                .modified_slots
+                .iter()
+                .filter_map(|chunk| {
+                    Some((
+                        chunk.recover_pk().ok()?,
+                        read_next::<SignerMessage, _>(&mut &chunk.data[..]).ok()?,
+                    ))
+                })
+                .collect();
             SignerEvent::SignerMessages {
                 signer_set: 0,
-                messages: vec![(pubkey, signer_message)],
+                messages,
                 received_time: SystemTime::now(),
             }
         })
         .collect();
 
-    for (sent_event, accepted_event) in sent_events.iter().zip(accepted_events.iter()) {
+    for event in sent_events {
         let SignerEvent::SignerMessages {
-            signer_set,
-            messages,
-            received_time,
-        } = sent_event
+            signer_set: sent_signer_set,
+            messages: sent_messages,
+            ..
+        } = event
         else {
-            panic!("BUG: should not have sent anything but a signer message");
+            panic!("We expect ONLY signer messages");
         };
-        let SignerEvent::SignerMessages {
-            signer_set: accepted_signer_set,
-            messages: accepted_messages,
-            received_time: accepted_time,
-        } = accepted_event
-        else {
-            panic!("BUG: should not have accepted anything but a signer message");
-        };
-
-        assert_eq!(signer_set, accepted_signer_set);
-        assert_eq!(messages, accepted_messages);
-        assert_ne!(received_time, accepted_time);
+        assert!(accepted_events.iter().any(|e| {
+            let SignerEvent::SignerMessages {
+                signer_set: accepted_signer_set,
+                messages: accepted_messages,
+                ..
+            } = e
+            else {
+                panic!("We expect ONLY signer messages");
+            };
+            *accepted_signer_set == sent_signer_set && *accepted_messages == sent_messages
+        }))
     }
     mock_stacks_node.join().unwrap();
 }

stacks-signer/src/runloop.rs

@@ -466,9 +466,15 @@ impl<Signer: SignerTrait<T>, T: StacksMessageCodec + Clone + Send + Debug> RunLo
                 // We are either the current or a future reward cycle, so we are not stale.
                 continue;
             }
-            if let ConfiguredSigner::RegisteredSigner(signer) = signer {
-                if !signer.has_unprocessed_blocks() {
-                    debug!("{signer}: Signer's tenure has completed.");
+            match signer {
+                ConfiguredSigner::RegisteredSigner(signer) => {
+                    if !signer.has_unprocessed_blocks() {
+                        debug!("{signer}: Signer's tenure has completed.");
+                        to_delete.push(*idx);
+                    }
+                }
+                ConfiguredSigner::NotRegistered { .. } => {
+                    debug!("{signer}: Unregistered signer's tenure has completed.");
                     to_delete.push(*idx);
                 }
             }

stackslib/src/config/mod.rs

@@ -2244,9 +2244,9 @@ impl Default for MinerConfig {
 
             block_rejection_timeout_steps: {
                 let mut rejections_timeouts_default_map = HashMap::<u32, Duration>::new();
-                rejections_timeouts_default_map.insert(0, Duration::from_secs(600));
-                rejections_timeouts_default_map.insert(10, Duration::from_secs(300));
-                rejections_timeouts_default_map.insert(20, Duration::from_secs(150));
+                rejections_timeouts_default_map.insert(0, Duration::from_secs(180));
+                rejections_timeouts_default_map.insert(10, Duration::from_secs(90));
+                rejections_timeouts_default_map.insert(20, Duration::from_secs(45));
                 rejections_timeouts_default_map.insert(30, Duration::from_secs(0));
                 rejections_timeouts_default_map
             },
@@ -2835,6 +2835,7 @@ impl MinerConfigFile {
         })
     }
 }
+
 #[derive(Clone, Deserialize, Default, Debug)]
 #[serde(deny_unknown_fields)]
 pub struct AtlasConfigFile {

testnet/stacks-node/src/nakamoto_node/miner.rs

@@ -704,7 +704,16 @@ impl BlockMinerThread {
                     )?
                     .ok_or_else(|| NakamotoNodeError::UnexpectedChainState)?;
 
-                if processed {
+                // Once the block has been processed and the miner is no longer
+                // blocked, we can continue mining.
+                if processed
+                    && !(*self
+                        .globals
+                        .get_miner_status()
+                        .lock()
+                        .expect("FATAL: mutex poisoned"))
+                    .is_blocked()
+                {
                     break;
                 }
 

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

@@ -12115,8 +12115,20 @@ fn repeated_rejection() {
     let send_amt = 100;
     let send_fee = 180;
     let recipient = PrincipalData::from(StacksAddress::burn_address(false));
-    let mut signer_test: SignerTest<SpawnedSigner> =
-        SignerTest::new(num_signers, vec![(sender_addr, (send_amt + send_fee) * 3)]);
+    let mut signer_test: SignerTest<SpawnedSigner> = SignerTest::new_with_config_modifications(
+        num_signers,
+        vec![(sender_addr, (send_amt + send_fee) * 3)],
+        |_| {},
+        |config| {
+            config.miner.block_rejection_timeout_steps.clear();
+            config
+                .miner
+                .block_rejection_timeout_steps
+                .insert(0, Duration::from_secs(120));
+        },
+        None,
+        None,
+    );
     let http_origin = format!("http://{}", &signer_test.running_nodes.conf.node.rpc_bind);
     signer_test.boot_to_epoch_3();