event_graph: remove check_version_match() and compare peers version with a const in taud and darkirc

Cargo.lock

@@ -7106,6 +7106,7 @@ dependencies = [
  "log",
  "rand 0.8.5",
  "ring 0.17.8",
+ "semver 1.0.23",
  "serde",
  "signal-hook",
  "signal-hook-async-std",

bin/darkirc/src/irc/client.rs

@@ -47,6 +47,8 @@ use super::{
 
 const PENALTY_LIMIT: usize = 5;
 
+const PROTOCOL_VERSION_SECS_TIMESTAMPS: semver::Version = semver::Version::new(0, 5, 0);
+
 /// Reply types, we can either send server replies, or client replies.
 pub enum ReplyType {
     /// Server reply, we have to use numerics
@@ -190,28 +192,27 @@ impl Client {
                                     }
 
                                     // Otherwise, broadcast it
-                                    let self_version = self.server.darkirc.p2p.settings().read().await.app_version.clone();
                                     let connected_peers = self.server.darkirc.p2p.hosts().peers();
-                                    let mut peers_with_matched_version = vec![];
+                                    let mut peers_millis = vec![];
-                                    let mut peers_with_different_version = vec![];
+                                    let mut peers_seconds = vec![];
                                     for peer in connected_peers {
                                         let peer_version = peer.version.lock().await.clone();
                                         if let Some(ref peer_version) = peer_version {
-                                            if self_version == peer_version.version {
+                                            if peer_version.version > PROTOCOL_VERSION_SECS_TIMESTAMPS{
-                                                peers_with_matched_version.push(peer)
+                                                peers_millis.push(peer)
                                             } else {
-                                                peers_with_different_version.push(peer)
+                                                peers_seconds.push(peer)
                                             }
                                         }
                                     }
 
-                                    if !peers_with_matched_version.is_empty() {
+                                    if !peers_millis.is_empty() {
-                                        self.server.darkirc.p2p.broadcast_to(&EventPut(event.clone()), &peers_with_matched_version).await;
+                                        self.server.darkirc.p2p.broadcast_to(&EventPut(event.clone()), &peers_millis).await;
                                     }
-                                    if !peers_with_different_version.is_empty() {
+                                    if !peers_seconds.is_empty() {
                                         let mut event = event;
                                         event.timestamp /= 1000;
-                                        self.server.darkirc.p2p.broadcast_to(&EventPut(event), &peers_with_different_version).await;
+                                        self.server.darkirc.p2p.broadcast_to(&EventPut(event), &peers_seconds).await;
                                     }
                                     // self.server.darkirc.p2p.broadcast(&EventPut(event)).await;
                                 }

bin/tau/taud/Cargo.toml

@@ -37,6 +37,7 @@ ring = "0.17.8"
 # Encoding and parsing
 bs58 = "0.5.1"
 toml = "0.8.19"
+semver = "1.0.23"
 
 # Misc
 async-trait = "0.1.81"

bin/tau/taud/src/main.rs

@@ -76,6 +76,8 @@ use crate::{
     settings::{Args, CONFIG_FILE, CONFIG_FILE_CONTENTS},
 };
 
+const PROTOCOL_VERSION_SECS_TIMESTAMPS: semver::Version = semver::Version::new(0, 5, 0);
+
 struct Workspace {
     read_key: ChaChaBox,
     write_key: Option<Ed25519KeyPair>,
@@ -318,28 +320,27 @@ async fn start_sync_loop(
                         error!(target: "taud", "Failed inserting new event to DAG: {}", e);
                     } else {
                         // Otherwise, broadcast it
-                        let self_version = p2p.settings().read().await.app_version.clone();
                         let connected_peers = p2p.hosts().peers();
-                        let mut peers_with_matched_version = vec![];
+                        let mut peers_millis = vec![];
-                        let mut peers_with_different_version = vec![];
+                        let mut peers_seconds = vec![];
                         for peer in connected_peers {
                             let peer_version = peer.version.lock().await.clone();
                             if let Some(ref peer_version) = peer_version {
-                                if self_version == peer_version.version {
+                                if peer_version.version > PROTOCOL_VERSION_SECS_TIMESTAMPS {
-                                    peers_with_matched_version.push(peer)
+                                    peers_millis.push(peer)
                                 } else {
-                                    peers_with_different_version.push(peer)
+                                    peers_seconds.push(peer)
                                 }
                             }
                         }
 
-                        if !peers_with_matched_version.is_empty() {
+                        if !peers_millis.is_empty() {
-                            p2p.broadcast_to(&EventPut(event.clone()), &peers_with_matched_version).await;
+                            p2p.broadcast_to(&EventPut(event.clone()), &peers_millis).await;
                         }
-                        if !peers_with_different_version.is_empty() {
+                        if !peers_seconds.is_empty() {
                             let mut event = event;
                             event.timestamp /= 1000;
-                            p2p.broadcast_to(&EventPut(event), &peers_with_different_version).await;
+                            p2p.broadcast_to(&EventPut(event), &peers_seconds).await;
                         }
                         // p2p.broadcast(&EventPut(event)).await;
                     }

src/event_graph/event.rs

@@ -176,28 +176,21 @@ impl Event {
     /// assuming some possibility for a time drift.
     /// Note: This validation does *NOT* check for recursive references(circles),
     /// and should be used as a first quick check.
-    pub fn validate_new(&self, is_ver_match: bool) -> bool {
+    pub fn validate_new(&self) -> bool {
         // Let's not bother with empty events
         if self.content.is_empty() {
             return false
         }
 
-        if is_ver_match {
+        let timestamp =
-            // Check if the event is too old or too new
+            if self.timestamp > 1e10 as u64 { self.timestamp / 1000 } else { self.timestamp };
-            let now = UNIX_EPOCH.elapsed().unwrap().as_millis() as u64;
+
-            let too_old = self.timestamp < now - EVENT_TIME_DRIFT;
+        // Check if the event is too old or too new
-            let too_new = self.timestamp > now + EVENT_TIME_DRIFT;
+        let now = UNIX_EPOCH.elapsed().unwrap().as_secs();
-            if too_old || too_new {
+        let too_old = timestamp < (now - (EVENT_TIME_DRIFT / 1000));
-                return false
+        let too_new = timestamp > (now + (EVENT_TIME_DRIFT / 1000));
-            }
+        if too_old || too_new {
-        } else {
+            return false
-            // Check if the event is too old or too new
-            let now = UNIX_EPOCH.elapsed().unwrap().as_secs();
-            let too_old = self.timestamp < (now - (EVENT_TIME_DRIFT / 1000));
-            let too_new = self.timestamp > (now + (EVENT_TIME_DRIFT / 1000));
-            if too_old || too_new {
-                return false
-            }
         }
 
         // Validate the parents. We have to check that at least one parent

src/event_graph/mod.rs

@@ -35,7 +35,7 @@ use tinyjson::JsonValue::{self};
 
 use crate::{
     event_graph::util::{replayer_log, seconds_until_next_rotation},
-    net::{channel::Channel, P2pPtr},
+    net::P2pPtr,
     rpc::{
         jsonrpc::{JsonResponse, JsonResult},
         util::json_map,
@@ -880,18 +880,4 @@ impl EventGraph {
 
         Ok(result)
     }
-
-    /// Check if the our version matches the connected peer's
-    /// return true if they are, false otherwise
-    async fn check_version_match(&self, channel: &Arc<Channel>) -> bool {
-        let self_version = self.p2p.settings().read().await.app_version.clone();
-        let peer_version = channel.version.lock().await.clone();
-        if let Some(ref peer_version) = peer_version {
-            if self_version == peer_version.version {
-                return true
-            }
-        }
-
-        false
-    }
 }

src/event_graph/proto.rs

@@ -203,8 +203,7 @@ impl ProtocolEventGraph {
             // Validate the new event first. If we do not consider it valid, we
             // will just drop it and stay quiet. If the malicious threshold
             // is reached, we will stop the connection.
-            let is_ver_match = self.event_graph.check_version_match(&self.channel).await;
+            if !event.validate_new() {
-            if !event.validate_new(is_ver_match) {
                 self.clone().increase_malicious_count().await?;
                 continue
             }