fix: send syncing start/stop messages to miner

The mining loop is no longer async as it is wrapped by
spawn_blocking().

Thus it can no longer await async futures.  So we cannot check
the GlobalState syncing flag, which requires an async lock
acquisition.

Instead, the main task sends StartSyncing and StopSyncing
messages to the mining task which cancels the mining thread
when it receives StartSyncing.

src/main_loop.rs

@@ -406,6 +406,7 @@ impl MainLoopHandler {
                         if !stay_in_sync_mode {
                             info!("Exiting sync mode");
                             global_state_mut.net.syncing = false;
+                            self.main_to_miner_tx.send(MainToMiner::StopSyncing)?;
                         }
                     }
 
@@ -459,6 +460,7 @@ impl MainLoopHandler {
                     socket_addr, claimed_max_height, claimed_max_pow_family
                 );
                     global_state_mut.net.syncing = true;
+                    self.main_to_miner_tx.send(MainToMiner::StartSyncing)?;
                 }
             }
             PeerThreadToMain::RemovePeerMaxBlockHeight(socket_addr) => {

src/mine_loop.rs

@@ -381,6 +381,8 @@ pub async fn mine(
                 }
 
                 let main_message: MainToMiner = from_main.borrow_and_update().clone();
+                debug!("Miner received message {:?}", main_message);
+
                 match main_message {
                     MainToMiner::Shutdown => {
                         debug!("Miner shutting down.");
@@ -399,23 +401,32 @@ pub async fn mine(
                         info!("Miner thread received {} block height {}", global_state_lock.lock(|s| s.cli().network).await, latest_block.kernel.header.height);
                     }
                     MainToMiner::Empty => (),
-                    MainToMiner::ReadyToMineNextBlock => {
-                        debug!("Got {:?} from `main_loop`", MainToMiner::ReadyToMineNextBlock);
-                    }
+                    MainToMiner::ReadyToMineNextBlock => {}
                     MainToMiner::StopMining => {
-                        debug!("Miner shutting down.");
-
                         pause_mine = true;
 
                         if let Some(mt) = miner_thread {
                             mt.abort();
                         }
                     }
                     MainToMiner::StartMining => {
-                        debug!("Starting miner");
-
                         pause_mine = false;
                     }
+                    MainToMiner::StopSyncing => {
+                        // no need to do anything here.  Mining will
+                        // resume or not at top of loop depending on
+                        // pause_mine and syncing variables.
+                    }
+                    MainToMiner::StartSyncing => {
+                        // when syncing begins, we must halt the mining
+                        // thread.  But we don't change the pause_mine
+                        // variable, because it reflects the logical on/off
+                        // of mining, which syncing can temporarily override
+                        // but not alter the setting.
+                        if let Some(mt) = miner_thread {
+                            mt.abort();
+                        }
+                    }
                 }
             }
             new_block_res = worker_thread_rx => {

src/models/channel.rs

@@ -24,6 +24,9 @@ pub enum MainToMiner {
 
     StopMining,
     StartMining,
+
+    StartSyncing,
+    StopSyncing,
     // SetCoinbasePubkey,
 }