Merge branch 'develop' into feat/propagate-vm-error

Author: obycode

CHANGELOG.md

@@ -11,6 +11,10 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 
 - Include a reason string in the transaction receipt when a transaction is rolled back due to a post-condition. This should help users in understanding what went wrong.
 
+### 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]
 
 ### Added

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/client/stacks_client.rs

@@ -20,11 +20,7 @@ use std::time::{Duration, Instant};
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use blockstack_lib::chainstate::stacks::boot::{NakamotoSignerEntry, SIGNERS_NAME};
 use blockstack_lib::chainstate::stacks::db::StacksBlockHeaderTypes;
-use blockstack_lib::chainstate::stacks::{
-    StacksTransaction, StacksTransactionSigner, TransactionAnchorMode, TransactionAuth,
-    TransactionContractCall, TransactionPayload, TransactionPostConditionMode,
-    TransactionSpendingCondition, TransactionVersion,
-};
+use blockstack_lib::chainstate::stacks::TransactionVersion;
 use blockstack_lib::net::api::callreadonly::CallReadOnlyResponse;
 use blockstack_lib::net::api::get_tenures_fork_info::{
     TenureForkingInfo, RPC_TENURE_FORKING_INFO_PATH,
@@ -61,8 +57,6 @@ use crate::runloop::RewardCycleInfo;
 pub struct StacksClient {
     /// The stacks address of the signer
     stacks_address: StacksAddress,
-    /// The private key used in all stacks node communications
-    stacks_private_key: StacksPrivateKey,
     /// The stacks node HTTP base endpoint
     http_origin: String,
     /// The types of transactions
@@ -94,7 +88,6 @@ pub struct CurrentAndLastSortition {
 impl From<&GlobalConfig> for StacksClient {
     fn from(config: &GlobalConfig) -> Self {
         Self {
-            stacks_private_key: config.stacks_private_key,
             stacks_address: config.stacks_address,
             http_origin: format!("http://{}", config.node_host),
             tx_version: config.network.to_transaction_version(),
@@ -123,7 +116,6 @@ impl StacksClient {
         };
         let stacks_address = StacksAddress::p2pkh(mainnet, &pubkey);
         Self {
-            stacks_private_key,
             stacks_address,
             http_origin: format!("http://{}", node_host),
             tx_version,
@@ -756,60 +748,6 @@ impl StacksClient {
     fn tenure_tip_path(&self, consensus_hash: &ConsensusHash) -> String {
         format!("{}/v3/tenures/tip/{}", self.http_origin, consensus_hash)
     }
-
-    /// Helper function to create a stacks transaction for a modifying contract call
-    #[allow(clippy::too_many_arguments)]
-    pub fn build_unsigned_contract_call_transaction(
-        contract_addr: &StacksAddress,
-        contract_name: ContractName,
-        function_name: ClarityName,
-        function_args: &[ClarityValue],
-        stacks_private_key: &StacksPrivateKey,
-        tx_version: TransactionVersion,
-        chain_id: u32,
-        nonce: u64,
-    ) -> Result<StacksTransaction, ClientError> {
-        let tx_payload = TransactionPayload::ContractCall(TransactionContractCall {
-            address: *contract_addr,
-            contract_name,
-            function_name,
-            function_args: function_args.to_vec(),
-        });
-        let public_key = StacksPublicKey::from_private(stacks_private_key);
-        let tx_auth = TransactionAuth::Standard(
-            TransactionSpendingCondition::new_singlesig_p2pkh(public_key).ok_or(
-                ClientError::TransactionGenerationFailure(format!(
-                    "Failed to create spending condition from public key: {}",
-                    public_key.to_hex()
-                )),
-            )?,
-        );
-
-        let mut unsigned_tx = StacksTransaction::new(tx_version, tx_auth, tx_payload);
-        unsigned_tx.set_origin_nonce(nonce);
-
-        unsigned_tx.anchor_mode = TransactionAnchorMode::Any;
-        unsigned_tx.post_condition_mode = TransactionPostConditionMode::Allow;
-        unsigned_tx.chain_id = chain_id;
-        Ok(unsigned_tx)
-    }
-
-    /// Sign an unsigned transaction
-    pub fn sign_transaction(
-        &self,
-        unsigned_tx: StacksTransaction,
-    ) -> Result<StacksTransaction, ClientError> {
-        let mut tx_signer = StacksTransactionSigner::new(&unsigned_tx);
-        tx_signer
-            .sign_origin(&self.stacks_private_key)
-            .map_err(|e| ClientError::TransactionGenerationFailure(e.to_string()))?;
-
-        tx_signer
-            .get_tx()
-            .ok_or(ClientError::TransactionGenerationFailure(
-                "Failed to generate transaction from a transaction signer".to_string(),
-            ))
-    }
 }
 
 #[cfg(test)]

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();