Merge branch 'development' of github.com:tari-project/sha-p2pool into…

… development
tari-project · Oct 26, 2024 · 8b6e590 · 8b6e590
2 parents a4e0af2 + c4ffb3b
commit 8b6e590
Show file tree

Hide file tree

Showing 8 changed files with 488 additions and 227 deletions.
diff --git a/src/server/grpc/p2pool.rs b/src/server/grpc/p2pool.rs
@@ -259,9 +259,15 @@ where S: ShareChain
             new_tip_block.fix_hash();
 
             if let Some(miner_data) = response.miner_data.as_mut() {
-                let _ = self
-                    .stats_broadcast
-                    .send_network_difficulty(pow_algo, Difficulty::from_u64(miner_data.target_difficulty).unwrap());
+                match Difficulty::from_u64(miner_data.target_difficulty) {
+                    Ok(diff) => {
+                        let _ = self.stats_broadcast.send_network_difficulty(pow_algo, diff);
+                    },
+                    Err(e) => {
+                        error!(target: LOG_TARGET, "Invalid target difficulty: {e:?}");
+                    },
+                }
+
                 // what happens p2pool difficulty > base chain diff
                 if target_difficulty.as_u64() < miner_data.target_difficulty {
                     miner_data.target_difficulty = target_difficulty.as_u64();

diff --git a/src/server/mod.rs b/src/server/mod.rs
@@ -12,4 +12,4 @@ pub mod grpc;
 pub mod http;
 pub mod p2p;
 
-pub const PROTOCOL_VERSION: u64 = 9;
+pub const PROTOCOL_VERSION: u64 = 10;
diff --git a/src/server/p2p/messages.rs b/src/server/p2p/messages.rs
@@ -78,7 +78,10 @@ impl PeerInfo {
     }
 
     pub fn public_addresses(&self) -> Vec<Multiaddr> {
-        self.public_addresses.iter().map(|addr| addr.parse().unwrap()).collect()
+        self.public_addresses
+            .iter()
+            .filter_map(|addr| addr.parse().ok())
+            .collect()
     }
 }
 
@@ -97,14 +100,83 @@ impl ShareChainSyncRequest {
     }
 
     pub fn algo(&self) -> PowAlgorithm {
-        PowAlgorithm::try_from(self.algo).unwrap()
+        PowAlgorithm::try_from(self.algo).unwrap_or(PowAlgorithm::RandomX)
     }
 
     pub fn missing_blocks(&self) -> &[(u64, FixedHash)] {
         &self.missing_blocks
     }
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct CatchUpSyncRequest {
+    algo: u64,
+    i_have: Vec<(u64, FixedHash)>,
+}
+
+impl CatchUpSyncRequest {
+    pub fn new(algo: PowAlgorithm, i_have: Vec<(u64, FixedHash)>) -> Self {
+        Self {
+            algo: algo.as_u64(),
+            i_have,
+        }
+    }
+
+    pub fn algo(&self) -> PowAlgorithm {
+        PowAlgorithm::try_from(self.algo).unwrap_or(PowAlgorithm::RandomX)
+    }
+
+    pub fn i_have(&self) -> &[(u64, FixedHash)] {
+        &self.i_have
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct CatchUpSyncResponse {
+    version: u64,
+    peer_id: PeerId,
+    algo: u64,
+    blocks: Vec<P2Block>,
+    // the tip is used to work out if we should continuing syncing from them
+    tip: (u64, FixedHash),
+}
+
+impl CatchUpSyncResponse {
+    pub fn new(algo: PowAlgorithm, peer_id: PeerId, blocks: &[Arc<P2Block>], tip: (u64, FixedHash)) -> Self {
+        Self {
+            version: PROTOCOL_VERSION,
+            algo: algo.as_u64(),
+            peer_id,
+            blocks: blocks.iter().map(|block| (**block).clone()).collect(),
+            tip,
+        }
+    }
+
+    pub fn peer_id(&self) -> &PeerId {
+        &self.peer_id
+    }
+
+    pub fn algo(&self) -> PowAlgorithm {
+        PowAlgorithm::try_from(self.algo).unwrap_or(PowAlgorithm::RandomX)
+    }
+
+    pub fn tip_hash(&self) -> &FixedHash {
+        &self.tip.1
+    }
+
+    pub fn tip_height(&self) -> u64 {
+        self.tip.0
+    }
+
+    pub fn into_blocks(self) -> Vec<P2Block> {
+        let mut blocks = self.blocks;
+        for block in &mut blocks {
+            block.verified = false;
+        }
+        blocks
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct DirectPeerInfoRequest {
     pub peer_id: String,
@@ -135,7 +207,7 @@ impl NotifyNewTipBlock {
     }
 
     pub fn algo(&self) -> PowAlgorithm {
-        PowAlgorithm::try_from(self.algo).unwrap()
+        PowAlgorithm::try_from(self.algo).unwrap_or(PowAlgorithm::RandomX)
     }
 }
 
@@ -162,7 +234,7 @@ impl ShareChainSyncResponse {
     }
 
     pub fn algo(&self) -> PowAlgorithm {
-        PowAlgorithm::try_from(self.algo).unwrap()
+        PowAlgorithm::try_from(self.algo).unwrap_or(PowAlgorithm::RandomX)
     }
 
     pub fn into_blocks(self) -> Vec<P2Block> {