feat: add delay to start of mining (#131)

Description
---
adds a 10 min delay to pool mining where it will solo mine till

Author: SWvheerden

src/server/grpc/p2pool.rs

@@ -4,7 +4,10 @@
 use std::{
     collections::{HashMap, VecDeque},
     str::FromStr,
-    sync::Arc,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
     time::Instant,
 };
 
@@ -76,6 +79,7 @@ where S: ShareChain
     list_of_templates_sha3x: RwLock<VecDeque<FixedHash>>,
     template_store_rx: RwLock<HashMap<FixedHash, P2Block>>,
     list_of_templates_rx: RwLock<VecDeque<FixedHash>>,
+    are_we_synced_with_p2pool: Arc<AtomicBool>,
 }
 
 impl<S> ShaP2PoolGrpc<S>
@@ -93,6 +97,7 @@ where S: ShareChain
         genesis_block_hash: FixedHash,
         stats_broadcast: StatsBroadcastClient,
         squad: Squad,
+        are_we_synced_with_p2pool: Arc<AtomicBool>,
     ) -> Result<Self, Error> {
         Ok(Self {
             local_peer_id,
@@ -116,11 +121,16 @@ where S: ShareChain
             list_of_templates_sha3x: RwLock::new(VecDeque::with_capacity(MAX_STORED_TEMPLATES_SHA3X + 1)),
             template_store_rx: RwLock::new(HashMap::new()),
             list_of_templates_rx: RwLock::new(VecDeque::with_capacity(MAX_STORED_TEMPLATES_RX + 1)),
+            are_we_synced_with_p2pool,
         })
     }
 
     /// Submits a new block to share chain and broadcasts to the p2p network.
     pub async fn submit_share_chain_block(&self, block: Arc<P2Block>) -> Result<(), Status> {
+        if !self.are_we_synced_with_p2pool.load(Ordering::Relaxed) {
+            info!(target: LOG_TARGET, "We are not synced yet, not submitting blok atm");
+            return Ok(());
+        }
         let pow_algo = block.original_block.header.pow.pow_algo;
         let share_chain = match pow_algo {
             PowAlgorithm::RandomX => self.share_chain_random_x.clone(),
@@ -274,7 +284,9 @@ where S: ShareChain
                 }
 
                 // what happens p2pool difficulty > base chain diff
-                if target_difficulty.as_u64() < miner_data.target_difficulty {
+                if target_difficulty.as_u64() < miner_data.target_difficulty &&
+                    self.are_we_synced_with_p2pool.load(Ordering::Relaxed)
+                {
                     miner_data.target_difficulty = target_difficulty.as_u64();
                 }
             }

src/server/server.rs

@@ -4,7 +4,7 @@
 use std::{
     net::{AddrParseError, SocketAddr},
     str::FromStr,
-    sync::Arc,
+    sync::{atomic::AtomicBool, Arc},
 };
 
 use log::{error, info};
@@ -53,6 +53,7 @@ where S: ShareChain
     stats_collector: Option<StatsCollector>,
     shutdown_signal: ShutdownSignal,
     stats_broadcast_client: StatsBroadcastClient,
+    are_we_synced_with_p2pool: Arc<AtomicBool>,
 }
 
 impl<S> Server<S>
@@ -69,7 +70,7 @@ where S: ShareChain
         let share_chain_sha3x = Arc::new(share_chain_sha3x);
         let share_chain_random_x = Arc::new(share_chain_random_x);
         let network_peer_store = PeerStore::new(&config.peer_store, stats_broadcast_client.clone());
-
+        let are_we_synced_with_p2pool = Arc::new(AtomicBool::new(false));
         let stats_client = stats_collector.create_client();
 
         let mut p2p_service: p2p::Service<S> = p2p::Service::new(
@@ -107,6 +108,7 @@ where S: ShareChain
                 genesis_block_hash,
                 stats_broadcast_client.clone(),
                 config.p2p_service.squad.clone(),
+                are_we_synced_with_p2pool.clone(),
             )
             .await
             .map_err(Error::Grpc)?;
@@ -135,6 +137,7 @@ where S: ShareChain
             stats_collector: Some(stats_collector),
             shutdown_signal,
             stats_broadcast_client,
+            are_we_synced_with_p2pool,
         })
     }
 
@@ -167,6 +170,15 @@ where S: ShareChain
     pub async fn start(&mut self) -> Result<(), Error> {
         info!(target: LOG_TARGET, "⛏ Starting Tari SHA-3 mining P2Pool...");
 
+        // this is stupid way of checking sync, but should atleast give as something to mine solo for a while and giving
+        // p2pool 4 mins to sync
+        let sync_start = self.are_we_synced_with_p2pool.clone();
+        tokio::spawn(async move {
+            tokio::time::sleep(tokio::time::Duration::from_secs(240)).await;
+            info!(target: LOG_TARGET, "Setting as synced");
+            sync_start.store(true, std::sync::atomic::Ordering::Relaxed);
+        });
+
         if self.config.mining_enabled {
             // local base node and p2pool node grpc services
             let base_node_grpc_service = self.base_node_grpc_service.clone().unwrap();