Signers should not infinitely loop when posting a block to the node

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

Author: jferrant

stacks-signer/src/client/stacks_client.rs

@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use std::collections::{HashMap, VecDeque};
-use std::fmt::Display;
-use std::time::{Duration, Instant};
 
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use blockstack_lib::chainstate::stacks::boot::{NakamotoSignerEntry, SIGNERS_NAME};
@@ -602,36 +600,6 @@ impl StacksClient {
         Ok(account_entry)
     }
 
-    /// Post a block to the stacks-node, retry forever on errors.
-    ///
-    /// In tests, this panics if the retry takes longer than 30 seconds.
-    pub fn post_block_until_ok<F: Display>(&self, log_fmt: &F, block: &NakamotoBlock) -> bool {
-        debug!("StacksClient: Posting block to stacks node";
-            "signer_signature_hash" => %block.header.signer_signature_hash(),
-            "block_id" => %block.header.block_id(),
-            "block_height" => %block.header.chain_length,
-        );
-        let start_time = Instant::now();
-        loop {
-            match self.post_block(block) {
-                Ok(block_push_result) => {
-                    debug!("{log_fmt}: Block pushed to stacks node: {block_push_result:?}");
-                    return block_push_result;
-                }
-                Err(e) => {
-                    if cfg!(any(test, feature = "testing"))
-                        && start_time.elapsed() > Duration::from_secs(30)
-                    {
-                        panic!(
-                            "{log_fmt}: Timed out in test while pushing block to stacks node: {e}"
-                        );
-                    }
-                    warn!("{log_fmt}: Failed to push block to stacks node: {e}. Retrying...");
-                }
-            };
-        }
-    }
-
     /// Try to post a completed nakamoto block to our connected stacks-node
     /// Returns `true` if the block was accepted or `false` if the block
     ///   was rejected.

stacks-signer/src/v0/signer.rs

@@ -455,7 +455,7 @@ impl Signer {
                             if self.test_skip_block_broadcast(b) {
                                 return;
                             }
-                            stacks_client.post_block_until_ok(self, b);
+                            self.handle_post_block(stacks_client, b);
                         }
                         SignerMessage::MockProposal(mock_proposal) => {
                             let epoch = match stacks_client.get_node_epoch() {
@@ -1528,12 +1528,11 @@ impl Signer {
     }
 
     fn broadcast_signed_block(
-        &self,
+        &mut self,
         stacks_client: &StacksClient,
         mut block: NakamotoBlock,
         addrs_to_sigs: &HashMap<StacksAddress, MessageSignature>,
     ) {
-        let block_hash = block.header.signer_signature_hash();
         // collect signatures for the block
         let signatures: Vec<_> = self
             .signer_addresses
@@ -1548,17 +1547,25 @@ impl Signer {
         if self.test_skip_block_broadcast(&block) {
             return;
         }
-        debug!(
-            "{self}: Broadcasting Stacks block {} to node",
-            &block.block_id()
-        );
-        stacks_client.post_block_until_ok(self, &block);
+        self.handle_post_block(stacks_client, &block);
+    }
 
-        if let Err(e) = self
-            .signer_db
-            .set_block_broadcasted(&block_hash, get_epoch_time_secs())
-        {
-            warn!("{self}: Failed to set block broadcasted for {block_hash}: {e:?}");
+    /// Attempt to post a block to the stacks-node and handle the result
+    pub fn handle_post_block(&mut self, stacks_client: &StacksClient, block: &NakamotoBlock) {
+        let block_hash = block.header.signer_signature_hash();
+        match stacks_client.post_block(block) {
+            Ok(accepted) => {
+                debug!("{self}: Block {block_hash} accepted by stacks node: {accepted}");
+                if let Err(e) = self
+                    .signer_db
+                    .set_block_broadcasted(&block_hash, get_epoch_time_secs())
+                {
+                    warn!("{self}: Failed to set block broadcasted for {block_hash}: {e:?}");
+                }
+            }
+            Err(e) => {
+                warn!("{self}: Failed to broadcast block {block_hash} to the node: {e}")
+            }
         }
     }