Add logging

packages/ciphernode/aggregator/Cargo.toml

@@ -10,3 +10,4 @@ bincode = { workspace = true }
 enclave-core = { path = "../core" }
 fhe = { path = "../fhe" }
 sortition = { path = "../sortition" }
+tracing = { workspace = true }

packages/ciphernode/aggregator/src/plaintext_aggregator.rs

@@ -7,6 +7,7 @@ use enclave_core::{
 use fhe::{Fhe, GetAggregatePlaintext};
 use sortition::{GetHasNode, Sortition};
 use std::sync::Arc;
+use tracing::error;
 
 #[derive(Debug, Clone)]
 pub enum PlaintextAggregatorState {
@@ -124,7 +125,7 @@ impl Handler<DecryptionshareCreated> for PlaintextAggregator {
             threshold_m, seed, ..
         } = self.state
         else {
-            println!("Aggregator has been closed for collecting.");
+            error!(state=?self.state, "Aggregator has been closed for collecting.");
             return Box::pin(fut::ready(Ok(())));
         };
 
@@ -144,12 +145,12 @@ impl Handler<DecryptionshareCreated> for PlaintextAggregator {
                 .map(move |res, act, ctx| {
                     let has_node = res?;
                     if !has_node {
-                        println!("Node not found in committee"); // TODO: log properly
+                        error!("Node not found in committee");
                         return Ok(());
                     }
 
                     if e3_id != act.e3_id {
-                        println!("Wrong e3_id sent to aggregator. This should not happen.");
+                        error!("Wrong e3_id sent to aggregator. This should not happen.");
                         return Ok(());
                     }
 

packages/ciphernode/aggregator/src/publickey_aggregator.rs

@@ -6,6 +6,7 @@ use enclave_core::{
 use fhe::{Fhe, GetAggregatePublicKey};
 use sortition::{GetHasNode, GetNodes, Sortition};
 use std::sync::Arc;
+use tracing::error;
 
 #[derive(Debug, Clone)]
 pub enum PublicKeyAggregatorState {
@@ -132,8 +133,7 @@ impl Handler<KeyshareCreated> for PublicKeyAggregator {
             threshold_m, seed, ..
         } = self.state.clone()
         else {
-            println!("Aggregator has been closed for collecting keyshares."); // TODO: log properly
-
+            error!(state=?self.state, "Aggregator has been closed for collecting keyshares.");
             return Box::pin(fut::ready(Ok(())));
         };
 
@@ -155,12 +155,12 @@ impl Handler<KeyshareCreated> for PublicKeyAggregator {
                     // we will not be doing a send
                     let has_node = res?;
                     if !has_node {
-                        println!("Node not found in committee"); // TODO: log properly
+                        error!("Node not found in committee");
                         return Ok(());
                     }
 
                     if e3_id != act.e3_id {
-                        println!("Wrong e3_id sent to aggregator. This should not happen.");
+                        error!("Wrong e3_id sent to aggregator. This should not happen.");
                         return Ok(());
                     }
 

packages/ciphernode/core/src/events.rs

@@ -1,4 +1,4 @@
-use actix::{Actor, Addr, Message};
+use actix::Message;
 use alloy::{
     hex,
     primitives::{Uint, U256},
@@ -69,7 +69,7 @@ impl EventId {
 impl fmt::Display for EventId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let base58_string = bs58::encode(&self.0).into_string();
-        write!(f, "eid_{}", base58_string)
+        write!(f, "evt:{}", &base58_string[0..8])
     }
 }
 
@@ -183,6 +183,22 @@ impl EnclaveEvent {
             _ => None,
         }
     }
+    pub fn get_data(&self) -> String {
+        match self.clone() {
+            EnclaveEvent::KeyshareCreated { data, .. } => format!("{}", data),
+            EnclaveEvent::E3Requested { data, .. } => format!("{}", data),
+            EnclaveEvent::PublicKeyAggregated { data, .. } => format!("{}", data),
+            EnclaveEvent::CiphertextOutputPublished { data, .. } => format!("{}", data),
+            EnclaveEvent::DecryptionshareCreated { data, .. } => format!("{}", data),
+            EnclaveEvent::PlaintextAggregated { data, .. } => format!("{}", data),
+            EnclaveEvent::CiphernodeSelected { data, .. } => format!("{}", data),
+            EnclaveEvent::CiphernodeAdded { data, .. } => format!("{}", data),
+            EnclaveEvent::CiphernodeRemoved { data, .. } => format!("{}", data),
+            EnclaveEvent::E3RequestComplete { data, .. } => format!("{}", data),
+            EnclaveEvent::EnclaveError { data, .. } => format!("{:?}", data),
+            // _ => "<omitted>".to_string(),
+        }
+    }
 }
 
 pub trait FromError {
@@ -299,7 +315,7 @@ impl FromError for EnclaveEvent {
 
 impl fmt::Display for EnclaveEvent {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(&format!("{}({})", self.event_type(), self.get_id()))
+        f.write_str(&format!("{}({})", self.event_type(), self.get_data()))
     }
 }
 
@@ -311,6 +327,12 @@ pub struct KeyshareCreated {
     pub node: String,
 }
 
+impl Display for KeyshareCreated {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "e3_id: {}, node: {}", self.e3_id, self.node,)
+    }
+}
+
 #[derive(Message, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[rtype(result = "anyhow::Result<()>")]
 pub struct DecryptionshareCreated {
@@ -319,6 +341,12 @@ pub struct DecryptionshareCreated {
     pub node: String,
 }
 
+impl Display for DecryptionshareCreated {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "e3_id: {}, node: {}", self.e3_id, self.node,)
+    }
+}
+
 #[derive(Message, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[rtype(result = "()")]
 pub struct PublicKeyAggregated {
@@ -328,18 +356,34 @@ pub struct PublicKeyAggregated {
     pub src_chain_id: u64,
 }
 
+impl Display for PublicKeyAggregated {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "e3_id: {}, src_chain_id: {}, nodes: <omitted>, pubkey: <omitted>",
+            self.e3_id, self.src_chain_id,
+        )
+    }
+}
+
 #[derive(Message, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[rtype(result = "()")]
 pub struct E3Requested {
     pub e3_id: E3id,
     pub threshold_m: usize,
     pub seed: Seed,
     pub params: Vec<u8>,
-    pub src_chain_id: u64, // threshold: usize, // TODO:
-                           // computation_type: ??, // TODO:
-                           // execution_model_type: ??, // TODO:
-                           // input_deadline: ??, // TODO:
-                           // availability_duration: ??, // TODO:
+    pub src_chain_id: u64,
+}
+
+impl Display for E3Requested {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "e3_id: {}, threshold_m: {}, src_chain_id: {}, seed: {}, params: <omitted>",
+            self.e3_id, self.threshold_m, self.src_chain_id, self.seed
+        )
+    }
 }
 
 #[derive(Message, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
@@ -349,13 +393,29 @@ pub struct CiphernodeSelected {
     pub threshold_m: usize,
 }
 
+impl Display for CiphernodeSelected {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "e3_id: {}, threshold_m: {}",
+            self.e3_id, self.threshold_m,
+        )
+    }
+}
+
 #[derive(Message, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[rtype(result = "()")]
 pub struct CiphertextOutputPublished {
     pub e3_id: E3id,
     pub ciphertext_output: Vec<u8>,
 }
 
+impl Display for CiphertextOutputPublished {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "e3_id: {}", self.e3_id,)
+    }
+}
+
 #[derive(Message, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[rtype(result = "()")]
 pub struct PlaintextAggregated {
@@ -364,13 +424,29 @@ pub struct PlaintextAggregated {
     pub src_chain_id: u64,
 }
 
+impl Display for PlaintextAggregated {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "e3_id: {}, src_chain_id: {}",
+            self.e3_id, self.src_chain_id
+        )
+    }
+}
+
 /// E3RequestComplete event is a local only event
 #[derive(Message, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[rtype(result = "()")]
 pub struct E3RequestComplete {
     pub e3_id: E3id,
 }
 
+impl Display for E3RequestComplete {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "e3_id: {}", self.e3_id)
+    }
+}
+
 #[derive(Message, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[rtype(result = "()")]
 pub struct CiphernodeAdded {
@@ -379,6 +455,16 @@ pub struct CiphernodeAdded {
     pub num_nodes: usize,
 }
 
+impl Display for CiphernodeAdded {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "address: {}, index: {}, num_nodes: {}",
+            self.address, self.index, self.num_nodes
+        )
+    }
+}
+
 #[derive(Message, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[rtype(result = "()")]
 pub struct CiphernodeRemoved {
@@ -387,16 +473,37 @@ pub struct CiphernodeRemoved {
     pub num_nodes: usize,
 }
 
+impl Display for CiphernodeRemoved {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "address: {}, index: {}, num_nodes: {}",
+            self.address, self.index, self.num_nodes
+        )
+    }
+}
+
 #[derive(Message, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[rtype(result = "()")]
 pub struct EnclaveError {
     pub err_type: EnclaveErrorType,
     pub message: String,
 }
 
+impl Display for EnclaveError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
 #[derive(Message, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 #[rtype(result = "()")]
 pub struct Die;
+impl Display for Die {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Die",)
+    }
+}
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub struct Seed(pub [u8; 32]);
@@ -432,6 +539,7 @@ pub enum EnclaveErrorType {
     IO,
     PlaintextAggregation,
     Decryption,
+    Sortition,
 }
 
 impl EnclaveError {

packages/ciphernode/enclave/Cargo.toml

@@ -14,3 +14,5 @@ clap = { workspace = true }
 actix-rt = { workspace = true }
 tokio = { workspace = true }
 config = "0.14.0"
+tracing-subscriber = { workspace = true } 
+tracing = { workspace = true }

packages/ciphernode/enclave/src/bin/aggregator.rs

@@ -1,6 +1,7 @@
 use clap::Parser;
 use enclave::load_config;
 use enclave_node::MainAggregator;
+use tracing::info;
 
 #[derive(Parser, Debug)]
 #[command(author, version, about, long_about = None)]
@@ -18,8 +19,9 @@ struct Args {
 
 #[actix_rt::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    tracing_subscriber::fmt::init();
     let args = Args::parse();
-    println!("LAUNCHING AGGREGATOR");
+    info!("LAUNCHING AGGREGATOR");
     let config = load_config(&args.config)?;
     let (_, handle) = MainAggregator::attach(
         config,