src/event_graph: use Timestamp struct as events timestamp

bin/darkirc/src/irc/client.rs

@@ -558,7 +558,7 @@ impl<C: AsyncRead + AsyncWrite + Send + Unpin + 'static> IrcClient<C> {
         }
         // Process missed messages if any (sorted by event's timestamp)
         let mut hash_vec = self.missed_events.lock().await.clone();
-        hash_vec.sort_by(|a, b| a.timestamp.cmp(&b.timestamp));
+        hash_vec.sort_by(|a, b| a.timestamp.0.cmp(&b.timestamp.0));
 
         for event in hash_vec {
             let mut action = event.action.clone();

bin/darkirc/src/irc/server.rs

@@ -28,14 +28,13 @@ use log::{error, info};
 
 use darkfi::{
     event_graph::{
-        get_current_time,
         model::{Event, EventId, ModelPtr},
         protocol_event::{Seen, SeenPtr, UnreadEventsPtr},
         view::ViewPtr,
     },
     net::P2pPtr,
     system::SubscriberPtr,
-    util::path::expand_path,
+    util::{path::expand_path, time::Timestamp},
     Error, Result,
 };
 
@@ -169,7 +168,7 @@ impl IrcServer {
                     let event = Event {
                         previous_event_hash: model.lock().await.get_head_hash(),
                         action: msg.clone(),
-                        timestamp: get_current_time(),
+                        timestamp: Timestamp::current_time(),
                         read_confirms: 0,
                     };
 

bin/genev/genevd/src/rpc.rs

@@ -23,7 +23,6 @@ use serde_json::{json, Value};
 
 use darkfi::{
     event_graph::{
-        get_current_time,
         model::{Event, EventId, ModelPtr},
         protocol_event::{SeenPtr, UnreadEvents},
     },
@@ -32,6 +31,7 @@ use darkfi::{
         jsonrpc::{ErrorCode, JsonError, JsonRequest, JsonResponse, JsonResult},
         server::RequestHandler,
     },
+    util::time::Timestamp,
 };
 
 use crate::genevent::GenEvent;
@@ -105,7 +105,7 @@ impl JsonRpcInterface {
         let event = Event {
             previous_event_hash: self.model.lock().await.get_head_hash(),
             action: genevent,
-            timestamp: get_current_time(),
+            timestamp: Timestamp::current_time(),
             read_confirms: 0,
         };
 

bin/tau/taud/src/main.rs

@@ -41,7 +41,6 @@ use darkfi::{
     async_daemonize,
     event_graph::{
         events_queue::EventsQueue,
-        get_current_time,
         model::{Event, EventId, Model, ModelPtr},
         protocol_event::{ProtocolEvent, Seen, SeenPtr, UnreadEvents},
         view::{View, ViewPtr},
@@ -49,7 +48,7 @@ use darkfi::{
     },
     net::{self, P2pPtr},
     rpc::server::listen_and_serve,
-    util::path::expand_path,
+    util::{path::expand_path, time::Timestamp},
     Error, Result,
 };
 
@@ -164,7 +163,7 @@ async fn start_sync_loop(
                     let event = Event {
                         previous_event_hash: model.lock().await.get_head_hash(),
                         action: encrypted_task,
-                        timestamp: get_current_time(),
+                        timestamp: Timestamp::current_time(),
                         read_confirms: 0,
                     };
 

src/event_graph/mod.rs

@@ -30,13 +30,3 @@ pub trait EventMsg {
 pub fn gen_id(len: usize) -> String {
     thread_rng().sample_iter(&Alphanumeric).take(len).map(char::from).collect()
 }
-
-pub fn get_current_time() -> u64 {
-    let start = std::time::SystemTime::now();
-    start
-        .duration_since(std::time::UNIX_EPOCH)
-        .expect("Time went backwards")
-        .as_millis()
-        .try_into()
-        .unwrap()
-}

src/event_graph/model.rs

@@ -23,7 +23,7 @@ use darkfi_serial::{Decodable, Encodable, SerialDecodable, SerialEncodable};
 use log::error;
 use ripemd::{Digest, Ripemd256};
 
-use crate::event_graph::events_queue::EventsQueuePtr;
+use crate::{event_graph::events_queue::EventsQueuePtr, util::time::Timestamp};
 
 use super::EventMsg;
 
@@ -36,7 +36,7 @@ const MAX_HEIGHT: u32 = 300;
 pub struct Event<T: Send + Sync> {
     pub previous_event_hash: EventId,
     pub action: T,
-    pub timestamp: u64,
+    pub timestamp: Timestamp,
     pub read_confirms: u8,
 }
 
@@ -87,7 +87,7 @@ where
             event: Event {
                 previous_event_hash: [0u8; 32],
                 action: T::new(),
-                timestamp: 1674512021323,
+                timestamp: Timestamp(1674512021323),
                 read_confirms: 0,
             },
             children: Vec::new(),
@@ -400,7 +400,7 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::event_graph::{events_queue::EventsQueue, get_current_time};
+    use crate::event_graph::events_queue::EventsQueue;
 
     #[derive(SerialEncodable, SerialDecodable, Clone, Debug)]
     pub struct PrivMsgEvent {
@@ -426,7 +426,12 @@ mod tests {
     }
 
     fn create_message(previous_event_hash: EventId, timestamp: u64) -> Event<PrivMsgEvent> {
-        Event { previous_event_hash, action: PrivMsgEvent::new(), timestamp, read_confirms: 4 }
+        Event {
+            previous_event_hash,
+            action: PrivMsgEvent::new(),
+            timestamp: Timestamp(timestamp),
+            read_confirms: 4,
+        }
     }
 
     /* THIS IS FAILING
@@ -615,7 +620,7 @@ mod tests {
         let model = Model::new(events_queue);
         let root_id = model.current_root;
 
-        let timestamp = get_current_time() + 1;
+        let timestamp = Timestamp::current_time().0 + 1;
         let event = create_message(root_id, timestamp);
         let mut event2 = event.clone();
 

src/event_graph/protocol_event.rs

@@ -27,11 +27,11 @@ use darkfi_serial::{Decodable, Encodable, SerialDecodable, SerialEncodable};
 use log::debug;
 use rand::{rngs::OsRng, RngCore};
 
-use super::{get_current_time, EventMsg};
+use super::EventMsg;
 use crate::{
     event_graph::model::{Event, EventId, ModelPtr},
     net,
-    util::async_util::sleep,
+    util::{async_util::sleep, time::Timestamp},
     Result,
 };
 
@@ -152,7 +152,7 @@ where
         // prune expired events
         let mut prune_ids = vec![];
         for (id, e) in self.events.iter() {
-            if e.timestamp + (UNREAD_EVENT_EXPIRE_TIME * 1000) < get_current_time() {
+            if e.timestamp.0 + (UNREAD_EVENT_EXPIRE_TIME * 1000) < Timestamp::current_time().0 {
                 prune_ids.push(*id);
             }
         }