feat: allow forced block broadcast

Author: jcnelson

stackslib/src/net/relay.rs

@@ -790,11 +790,44 @@ impl Relayer {
         }
         Ok(res)
     }
+    
+    /// Wrapper around inner_process_new_nakamoto_block
+    pub fn process_new_nakamoto_block(
+        burnchain: &Burnchain,
+        sortdb: &SortitionDB,
+        sort_handle: &mut SortitionHandleConn,
+        chainstate: &mut StacksChainState,
+        stacks_tip: &StacksBlockId,
+        block: &NakamotoBlock,
+        coord_comms: Option<&CoordinatorChannels>,
+        obtained_method: NakamotoBlockObtainMethod,
+    ) -> Result<bool, chainstate_error> {
+        Self::process_new_nakamoto_block_ext(
+            burnchain,
+            sortdb,
+            sort_handle,
+            chainstate,
+            stacks_tip,
+            block,
+            coord_comms,
+            obtained_method,
+            false
+        )
+    }
 
     /// Insert a staging Nakamoto block that got relayed to us somehow -- e.g. uploaded via http,
     /// downloaded by us, or pushed via p2p.
-    /// Return Ok(true) if we stored it, Ok(false) if we didn't
-    pub fn process_new_nakamoto_block(
+    /// Return Ok(true) if we should broadcast the block.  If force_broadcast is true, then this
+    /// function will return Ok(true) even if we already have the block.
+    /// Return Ok(false) if we should not broadcast it (e.g. we already have it, it was invalid,
+    /// etc.)
+    /// Return Err(..) in the following cases, beyond DB errors:
+    /// * If the block is from a tenure we don't recognize
+    /// * If we're not in the Nakamoto epoch
+    /// * If the reward cycle info could not be determined
+    /// * If there was an unrecognized signer
+    /// * If the coordinator is closed, and `coord_comms` is Some(..)
+    pub fn process_new_nakamoto_block_ext(
         burnchain: &Burnchain,
         sortdb: &SortitionDB,
         sort_handle: &mut SortitionHandleConn,
@@ -803,6 +836,7 @@ impl Relayer {
         block: &NakamotoBlock,
         coord_comms: Option<&CoordinatorChannels>,
         obtained_method: NakamotoBlockObtainMethod,
+        force_broadcast: bool
     ) -> Result<bool, chainstate_error> {
         debug!(
             "Handle incoming Nakamoto block {}/{} obtained via {}",
@@ -825,8 +859,16 @@ impl Relayer {
                 e
             })?
         {
-            debug!("Already have Nakamoto block {}", &block.header.block_id());
-            return Ok(false);
+            if force_broadcast {
+                // it's possible that the signer sent this block to us, in which case, we should
+                // broadcast it
+                debug!("Already have Nakamoto block {}, but broadcasting anyway", &block.header.block_id());
+                return Ok(true);
+            }
+            else {
+                debug!("Already have Nakamoto block {}", &block.header.block_id());
+                return Ok(false);
+            }
         }
 
         let block_sn =
@@ -2541,6 +2583,7 @@ impl Relayer {
         accepted_blocks: Vec<AcceptedNakamotoBlocks>,
         force_send: bool,
     ) {
+        // TODO: we don't relay HTTP-uploaded blocks :(
         debug!(
             "{:?}: relay {} sets of Nakamoto blocks",
             _local_peer,