diff --git a/Cargo.lock b/Cargo.lock index 73a233b..b5d82de 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -11,8 +11,6 @@ dependencies = [ "base64 0.22.1", "dashmap", "dotenv", - "epsilon-core", - "epsilon-native", "futures", "hex", "hkdf", @@ -28,6 +26,8 @@ dependencies = [ "strum_macros", "thiserror 2.0.18", "tokio", + "ttp-core", + "ttp-native", "uuid", "x448", ] @@ -697,32 +697,6 @@ dependencies = [ "zeroize", ] -[[package]] -name = "epsilon-core" -version = "0.1.0" -source = "git+https://github.com/Tensamin/Epsilon.git#bafbf13f43a9f7092341ec102621e234438be163" -dependencies = [ - "base64 0.22.1", - "byteorder", - "rand 0.8.5", - "strum", - "strum_macros", -] - -[[package]] -name = "epsilon-native" -version = "0.1.0" -source = "git+https://github.com/Tensamin/Epsilon.git#bafbf13f43a9f7092341ec102621e234438be163" -dependencies = [ - "epsilon-core", - "quinn", - "rustls", - "rustls-native-certs", - "thiserror 2.0.18", - "tokio", - "wtransport", -] - [[package]] name = "equivalent" version = "1.0.2" @@ -2938,6 +2912,32 @@ version = "0.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b" +[[package]] +name = "ttp-core" +version = "0.1.0" +source = "git+https://github.com/t3kkm0tt/TTP.git#8a3cd5cea756d62e7f85824ebfa1e64c7594c7de" +dependencies = [ + "base64 0.22.1", + "byteorder", + "rand 0.8.5", + "strum", + "strum_macros", +] + +[[package]] +name = "ttp-native" +version = "0.1.0" +source = "git+https://github.com/t3kkm0tt/TTP.git#8a3cd5cea756d62e7f85824ebfa1e64c7594c7de" +dependencies = [ + "quinn", + "rustls", + "rustls-native-certs", + "thiserror 2.0.18", + "tokio", + "ttp-core", + "wtransport", +] + [[package]] name = "tungstenite" version = "0.20.1" diff --git a/Cargo.toml b/Cargo.toml index 666912d..be0c5a4 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,8 +4,8 @@ version = "0.1.0" edition = "2024" [dependencies] -epsilon-core = { git = "https://github.com/Tensamin/Epsilon.git", package = "epsilon-core" } -epsilon-native = { git = "https://github.com/Tensamin/Epsilon.git", package = "epsilon-native" } +ttp-core = { git = "https://github.com/t3kkm0tt/TTP.git", package = "ttp-core" } +ttp-native = { git = "https://github.com/t3kkm0tt/TTP.git", package = "ttp-native" } ansi_term = "*" uuid = { version = "*", features = ["v4"] } diff --git a/src/anonymous_clients/anonymous_client_connection.rs b/src/anonymous_clients/anonymous_client_connection.rs index 0e4ad80..ed0ef65 100644 --- a/src/anonymous_clients/anonymous_client_connection.rs +++ b/src/anonymous_clients/anonymous_client_connection.rs @@ -1,9 +1,9 @@ -use epsilon_core::{CommunicationType, CommunicationValue, DataTypes, DataValue}; -use epsilon_native::{Receiver, Sender}; use std::str::FromStr; use std::sync::Arc; use std::time::Duration; use tokio::sync::RwLock; +use ttp_core::{CommunicationType, CommunicationValue, DataTypes, DataValue}; +use ttp_native::{Receiver, Sender}; use uuid::Uuid; use crate::anonymous_clients::anonymous_manager::{self, generate_username}; @@ -457,7 +457,7 @@ impl AnonymousClientConnection { let error = CommunicationValue::new(error_type).with_id(*message_id); self.send_message(&error).await; } - + #[allow(dead_code)] /// Close the connection pub async fn close(&self) { let mut is_open_guard = self.is_open.write().await; @@ -469,16 +469,19 @@ impl AnonymousClientConnection { let _ = self.sender.close(); } + #[allow(dead_code)] /// Set interested users list pub async fn set_interested_users(self: Arc, interested_ids: Vec) { let mut interested_guard = self.interested_users.write().await; *interested_guard = interested_ids; } + #[allow(dead_code)] pub async fn get_interested_users(self: Arc) -> Vec { let interested_guard = self.interested_users.read().await; interested_guard.clone() } + #[allow(dead_code)] /// Check if interested in a user and send notification pub async fn are_you_interested(self: Arc, user_id: i64) { let interested_guard = self.clone().get_interested_users().await; @@ -491,6 +494,7 @@ impl AnonymousClientConnection { } } + #[allow(dead_code)] /// Handle connection close pub async fn handle_close(&self) { diff --git a/src/anonymous_clients/anonymous_manager.rs b/src/anonymous_clients/anonymous_manager.rs index 70d8068..edfefde 100644 --- a/src/anonymous_clients/anonymous_manager.rs +++ b/src/anonymous_clients/anonymous_manager.rs @@ -9,10 +9,12 @@ use crate::anonymous_clients::anonymous_client_connection::AnonymousClientConnec static ANONYMOUS_USERS: Lazy>> = Lazy::new(|| DashMap::new()); +#[allow(dead_code)] pub async fn add_anonymous_user(connection: Arc) { ANONYMOUS_USERS.insert(connection.get_user_id(), connection); } +#[allow(dead_code)] pub async fn remove_anonymous_user(user_id: u64) { ANONYMOUS_USERS.remove(&user_id); } diff --git a/src/calls/call_group.rs b/src/calls/call_group.rs index 2bc8c0b..91e85cf 100644 --- a/src/calls/call_group.rs +++ b/src/calls/call_group.rs @@ -1,4 +1,4 @@ -use epsilon_core::{CommunicationType, CommunicationValue, DataTypes, DataValue}; +use ttp_core::{CommunicationType, CommunicationValue, DataTypes, DataValue}; use std::{env, sync::Arc, time::Duration}; use tokio::sync::RwLock; diff --git a/src/calls/call_manager.rs b/src/calls/call_manager.rs index 051a262..a17f347 100644 --- a/src/calls/call_manager.rs +++ b/src/calls/call_manager.rs @@ -6,7 +6,7 @@ use uuid::Uuid; use crate::calls::{call_group::CallGroup, caller::Caller}; pub static CALL_GROUPS: Lazy>> = Lazy::new(|| DashMap::new()); - +#[allow(dead_code)] pub async fn get_call_invites(user_id: u64) -> Vec> { let mut callers = Vec::new(); for (_, cg) in CALL_GROUPS.clone().into_iter() { diff --git a/src/calls/call_util.rs b/src/calls/call_util.rs index 3d832c3..57df005 100644 --- a/src/calls/call_util.rs +++ b/src/calls/call_util.rs @@ -54,6 +54,7 @@ pub fn create_token(user_id: u64, call_id: Uuid, has_admin: bool) -> Result Result<(RoomClient, Room), ()> { if let Ok((hostname, api_key, api_secret)) = get_livekit() { let room_service = RoomClient::with_api_key(&hostname, &api_key, &api_secret); @@ -82,6 +83,7 @@ pub async fn remove_participant(call_id: Uuid, user_id: u64) -> Result<(), ()> { return Err(()); } +#[allow(dead_code)] pub async fn get_room_metadata(call_id: Uuid) -> Result { if let Ok((_, room)) = get_room(call_id).await { Ok(room.metadata) diff --git a/src/calls/caller.rs b/src/calls/caller.rs index d4ef493..74e0c3b 100644 --- a/src/calls/caller.rs +++ b/src/calls/caller.rs @@ -21,12 +21,14 @@ impl Caller { timeout: RwLock::new(0), } } + #[allow(dead_code)] pub fn set_admin(&mut self, has_admin: bool) { self.has_admin = has_admin; } pub fn has_admin(&self) -> bool { self.has_admin } + #[allow(dead_code)] pub async fn is_timeouted(&self) -> bool { *self.timeout.read().await > SystemTime::now() diff --git a/src/omega/omega_connection.rs b/src/omega/omega_connection.rs index b5c6bdf..e4cfa0f 100644 --- a/src/omega/omega_connection.rs +++ b/src/omega/omega_connection.rs @@ -9,8 +9,6 @@ use crate::{ }, }; use dashmap::DashMap; -use epsilon_core::{CommunicationType, CommunicationValue, DataTypes, DataValue, rand_u32}; -use epsilon_native::{Receiver, Sender}; use once_cell::sync::Lazy; use std::{collections::HashMap, env, sync::Arc, time::Duration}; use tokio::{ @@ -18,6 +16,8 @@ use tokio::{ task::JoinHandle, time::{Instant, sleep}, }; +use ttp_core::{CommunicationType, CommunicationValue, DataTypes, DataValue, rand_u32}; +use ttp_native::{Receiver, Sender}; use uuid::Uuid; // ============================================================================ @@ -64,6 +64,7 @@ pub enum ConnectionState { Connected { identified: bool }, } +#[allow(unused_variables)] impl ConnectionState { pub fn is_connected(&self) -> bool { match self { @@ -72,6 +73,7 @@ impl ConnectionState { } } + #[allow(dead_code)] pub fn is_identified(&self) -> bool { match self { ConnectionState::Connected { identified: true } => true, @@ -83,6 +85,7 @@ impl ConnectionState { // ============================================================================ // Omega Connection (Client-side with auto-reconnect) // ============================================================================ +#[allow(dead_code)] pub struct OmegaConnection { state: Arc>, sender: Arc>>>, @@ -153,6 +156,7 @@ impl OmegaConnection { *self.connection_loop_handle.lock().await = Some(handle); } + #[allow(dead_code)] pub async fn stop(&self) { // Disable reconnection *self.reconnect_on_close.write().await = false; @@ -239,7 +243,7 @@ impl OmegaConnection { let addr_str = format!("https://{}:{}", self.host, self.port); - let (sender, mut receiver) = epsilon_native::client::connect(&addr_str, None) + let (sender, mut receiver) = ttp_native::client::connect(&addr_str, None) .await .map_err(|e| format!("Connection failed: {}", e))?; @@ -444,7 +448,7 @@ impl OmegaConnection { async fn read_loop( self: Arc, receiver: &mut Receiver, - sender_handle: Arc, + sender_handle: Arc, ) { // Monitor both receiver and sender handle for close let mut close_rx = sender_handle.subscribe_close(); @@ -634,14 +638,16 @@ impl OmegaConnection { } } + #[allow(dead_code)] pub async fn is_connected(&self) -> bool { self.state.read().await.is_connected() } - + #[allow(dead_code)] pub async fn is_identified(&self) -> bool { self.state.read().await.is_identified() } + #[allow(dead_code)] pub async fn close_iota(iota_id: i64) { let cv = CommunicationValue::new(CommunicationType::iota_disconnected) .add_data(DataTypes::iota_id, DataValue::Number(iota_id)); diff --git a/src/omega/ping_pong_task.rs b/src/omega/ping_pong_task.rs index c528abf..c7fc0b9 100644 --- a/src/omega/ping_pong_task.rs +++ b/src/omega/ping_pong_task.rs @@ -1,6 +1,6 @@ -use epsilon_core::{CommunicationType, CommunicationValue, DataTypes, DataValue, rand_u32}; use std::time::Duration; use tokio::time::Instant; +use ttp_core::{CommunicationType, CommunicationValue, DataTypes, DataValue, rand_u32}; use crate::omega::omega_connection::OmegaConnection; diff --git a/src/rho/client_connection.rs b/src/rho/client_connection.rs index 143df9f..bb379bb 100644 --- a/src/rho/client_connection.rs +++ b/src/rho/client_connection.rs @@ -6,12 +6,12 @@ use crate::rho::{rho_connection::RhoConnection, rho_manager}; use crate::util::logger::PrintType; use crate::{data::user::UserStatus, omega::omega_connection::OmegaConnection}; use crate::{log_cv_in, log_cv_out, log_out}; -use epsilon_core::{CommunicationType, CommunicationValue, DataTypes, DataValue}; -use epsilon_native::{Receiver, Sender}; use std::str::FromStr; use std::sync::Arc; use std::time::{Duration, SystemTime, UNIX_EPOCH}; use tokio::sync::RwLock; +use ttp_core::{CommunicationType, CommunicationValue, DataTypes, DataValue}; +use ttp_native::{Receiver, Sender}; use uuid::Uuid; pub struct ClientConnection { @@ -455,6 +455,7 @@ impl ClientConnection { } /// Close the connection + #[allow(dead_code)] pub async fn close(&self) { let mut is_open_guard = self.is_open.write().await; if *is_open_guard { @@ -470,12 +471,14 @@ impl ClientConnection { let mut interested_guard = self.interested_users.write().await; *interested_guard = interested_ids; } + #[allow(dead_code)] pub async fn get_interested_users(self: Arc) -> Vec { let interested_guard = self.interested_users.read().await; interested_guard.clone() } /// Check if interested in a user and send notification + #[allow(dead_code)] pub async fn are_you_interested(self: Arc, user_id: i64) { let interested_guard = self.clone().get_interested_users().await; if interested_guard.contains(&user_id) { @@ -488,6 +491,7 @@ impl ClientConnection { } /// Handle connection close + #[allow(dead_code)] pub async fn handle_close(&self) { let user_id = self.get_user_id().await; if let Some(rho_conn) = rho_manager::get_rho_con_for_user(user_id as i64).await { diff --git a/src/rho/connection.rs b/src/rho/connection.rs index 2b530c7..a187c32 100755 --- a/src/rho/connection.rs +++ b/src/rho/connection.rs @@ -1,8 +1,8 @@ -use epsilon_core::{CommunicationType, CommunicationValue, DataTypes, DataValue}; -use epsilon_native::{Receiver, Sender}; use rand::{Rng, distributions::Alphanumeric}; use std::{sync::Arc, time::Duration}; use tokio::sync::RwLock; +use ttp_core::{CommunicationType, CommunicationValue, DataTypes, DataValue}; +use ttp_native::{Receiver, Sender}; use crate::{ anonymous_clients::anonymous_client_connection::AnonymousClientConnection, @@ -20,6 +20,7 @@ use crate::{ }; #[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[allow(dead_code)] pub enum ConnectionKind { Client, Iota, diff --git a/src/rho/iota_connection.rs b/src/rho/iota_connection.rs index 91a6111..05d3004 100755 --- a/src/rho/iota_connection.rs +++ b/src/rho/iota_connection.rs @@ -7,12 +7,6 @@ use crate::omega::omega_connection::get_omega_connection; use crate::rho::connection::GeneralConnection; use crate::util::logger::PrintType; use dashmap::DashMap; -use epsilon_core::CommunicationType; -use epsilon_core::CommunicationValue; -use epsilon_core::DataTypes; -use epsilon_core::DataValue; -use epsilon_native::Receiver; -use epsilon_native::Sender; use std::collections::BTreeMap; use std::{ collections::HashMap, @@ -21,11 +15,18 @@ use std::{ }; use tokio::sync::RwLock; use tokio::sync::mpsc; +use ttp_core::CommunicationType; +use ttp_core::CommunicationValue; +use ttp_core::DataTypes; +use ttp_core::DataValue; +use ttp_native::Receiver; +use ttp_native::Sender; use x448::PublicKey; use super::{rho_connection::RhoConnection, rho_manager}; use crate::omega::omega_connection::OmegaConnection; +#[allow(dead_code)] pub struct IotaConnection { pub iota_id: u64, pub sender: Arc, @@ -72,6 +73,7 @@ impl IotaConnection { self.iota_id } + #[allow(dead_code)] pub async fn get_public_key(&self) -> Option { if let Some(public_key) = self.pub_key.read().await.clone() { PublicKey::from_bytes(&public_key) @@ -163,11 +165,13 @@ impl IotaConnection { self.forward_to_client(cv).await; } + #[allow(dead_code)] async fn send_error_response(&self, message_id: u32, error_type: CommunicationType) { let error = CommunicationValue::new(error_type).with_id(message_id); self.send_message(&error).await; } + #[allow(dead_code)] async fn close(&self) { let _ = self.sender.close(); } @@ -346,12 +350,14 @@ impl IotaConnection { } } + #[allow(dead_code)] pub async fn handle_close(&self) { if let Some(rho_conn) = self.get_rho_connection().await { rho_conn.close_iota_connection().await; } } + #[allow(dead_code)] pub async fn await_response( self: Arc, cv: &CommunicationValue, diff --git a/src/rho/rho_connection.rs b/src/rho/rho_connection.rs index 9286d0b..af37187 100644 --- a/src/rho/rho_connection.rs +++ b/src/rho/rho_connection.rs @@ -2,10 +2,10 @@ use super::{client_connection::ClientConnection, iota_connection::IotaConnection use crate::data::user::UserStatus; use crate::omega::omega_connection::OmegaConnection; -use epsilon_core::{CommunicationType, CommunicationValue, DataTypes, DataValue}; use std::collections::HashMap; use std::sync::Arc; use tokio::sync::RwLock; +use ttp_core::{CommunicationType, CommunicationValue, DataTypes, DataValue}; pub struct RhoConnection { iota_connection: Arc, @@ -58,6 +58,7 @@ impl RhoConnection { } /// Add a client connection + #[allow(dead_code)] pub async fn add_client_connection(&self, connection: Arc) { let notification = CommunicationValue::new(CommunicationType::client_connected).add_data( DataTypes::user_id, @@ -145,6 +146,7 @@ impl RhoConnection { } /// Check if clients are interested in a user + #[allow(dead_code)] pub async fn are_they_interested(&self, user_id: i64) { let connections = self.client_connections.read().await; for connection in connections.iter() { @@ -166,11 +168,13 @@ impl RhoConnection { } /// Check if this RhoConnection contains a specific user ID + #[allow(dead_code)] pub fn contains_user(&self, user_id: &i64) -> bool { self.user_ids.contains(user_id) } /// Get count of active client connections + #[allow(dead_code)] pub async fn client_count(&self) -> usize { let connections = self.client_connections.read().await; connections.len() diff --git a/src/rho/rho_manager.rs b/src/rho/rho_manager.rs index f87dd3c..dd73497 100644 --- a/src/rho/rho_manager.rs +++ b/src/rho/rho_manager.rs @@ -26,6 +26,7 @@ pub async fn get_rho_con_for_user(user_id: i64) -> Option> { None } +#[allow(dead_code)] pub async fn contains_iota(iota_id: i64) -> bool { let connections = RHO_CONNECTIONS.read().await; connections.contains_key(&iota_id) @@ -45,6 +46,7 @@ pub async fn add_rho(rho_connection: Arc) { } /// Get a RhoConnection by Iota ID directly +#[allow(dead_code)] pub async fn get_rho_by_iota(iota_id: i64) -> Option> { let connections = RHO_CONNECTIONS.read().await; connections.get(&iota_id).map(Arc::clone) diff --git a/src/rho/server.rs b/src/rho/server.rs index 7ef3891..9e3946d 100644 --- a/src/rho/server.rs +++ b/src/rho/server.rs @@ -3,14 +3,14 @@ use crate::{ rho::connection::GeneralConnection, util::{file_util::load_file_vec, logger::PrintType}, }; -use epsilon_native::Host; +use ttp_native::Host; pub async fn start(port: u16) -> Result<(), Box> { let cert_pem = load_file_vec("certs", "cert.pem").expect("Error loading Pemfile"); let key_pem = load_file_vec("certs", "key.pem").expect("Error loading Keyfile"); - let mut host: Host = epsilon_native::host(port, cert_pem, key_pem).await?; + let mut host: Host = ttp_native::host(port, cert_pem, key_pem).await?; log!(0, PrintType::General, "Server listening on port {}", port); while let Some((sender, receiver)) = host.next().await { diff --git a/src/util/crypto_helper.rs b/src/util/crypto_helper.rs index bb086b8..cb3ae6a 100755 --- a/src/util/crypto_helper.rs +++ b/src/util/crypto_helper.rs @@ -8,6 +8,7 @@ use sha2::{Digest, Sha256}; use x448::{PublicKey, Secret, SharedSecret}; /// Errors for crypto operations +#[allow(dead_code)] #[derive(Debug)] pub enum CryptoError { Base64Decode(base64::DecodeError), @@ -23,11 +24,13 @@ impl From for CryptoError { } } +#[allow(dead_code)] pub struct KeyPair { pub secret: Secret, pub public: PublicKey, } +#[allow(dead_code)] pub fn generate_keypair() -> KeyPair { let mut buf = [0u8; 56]; let mut rng = OsRng; @@ -64,6 +67,7 @@ fn derive_aes_key(shared: &SharedSecret) -> [u8; 32] { key } +#[allow(dead_code)] pub fn encrypt_b64( base64_secret: &str, base64_peer_pub: &str, @@ -131,12 +135,14 @@ pub fn decrypt( Ok(plaintext) } +#[allow(dead_code)] pub fn hash_it(input: &str) -> Vec { let mut hasher = Sha256::new(); hasher.update(input.as_bytes()); hasher.finalize().to_vec() } +#[allow(dead_code)] pub fn hex_hash(input: &str) -> String { let digest = hash_it(input); digest.iter().map(|b| format!("{:02x}", b)).collect() diff --git a/src/util/crypto_util.rs b/src/util/crypto_util.rs index 0285552..26448e0 100644 --- a/src/util/crypto_util.rs +++ b/src/util/crypto_util.rs @@ -8,6 +8,7 @@ use sha2::{Digest, Sha256}; use x448::{PublicKey, Secret}; // --- Custom Errors --- +#[allow(dead_code)] #[derive(Debug)] pub enum SecurePayloadError { InvalidBase64, @@ -18,6 +19,7 @@ pub enum SecurePayloadError { } // --- Data Format Enum --- +#[allow(dead_code)] #[derive(Clone, Copy, Debug)] pub enum DataFormat { Raw, @@ -66,6 +68,7 @@ impl SecurePayload { } /// Helper to get the public key associated with this instance's private key. + #[allow(dead_code)] pub fn get_public_key(&self) -> [u8; 56] { *PublicKey::from(&self.private_key).as_bytes() } @@ -80,11 +83,13 @@ impl SecurePayload { } /// Access raw bytes directly + #[allow(dead_code)] pub fn get_bytes(&self) -> &[u8] { &self.inner_data } /// Returns the SHA-256 Hash of the data in the requested format + #[allow(dead_code)] pub fn get_hash(&self, format: DataFormat) -> String { let mut hasher = Sha256::new(); hasher.update(&self.inner_data); @@ -134,6 +139,7 @@ impl SecurePayload { } /// Decrypts the held data providing the sender's public key manually. + #[allow(dead_code)] pub fn decrypt_to_format( &self, peer_public_key_bytes: &[u8; 56], diff --git a/src/util/file_util.rs b/src/util/file_util.rs index 116ef37..cd214b1 100644 --- a/src/util/file_util.rs +++ b/src/util/file_util.rs @@ -37,6 +37,7 @@ pub fn delete_user_directory(user_id: i64) { let _ = delete_dir_recursive(&user_dir); } +#[allow(dead_code)] pub fn load_file_buf(path: &str, name: &str) -> io::Result> { let dir = Path::new(&get_directory()).join(path); let file_path = dir.join(name); @@ -63,6 +64,7 @@ pub fn load_file_buf(path: &str, name: &str) -> io::Result> { let file = File::open(&file_path)?; Ok(BufReader::new(file)) } +#[allow(dead_code)] pub fn has_file(path: &str, name: &str) -> bool { let dir = Path::new(&get_directory()).join(path); let file_path = dir.join(name); @@ -77,6 +79,7 @@ pub fn has_file(path: &str, name: &str) -> bool { true } +#[allow(dead_code)] pub fn has_dir(path: &str) -> bool { let dir = Path::new(&get_directory()).join(path); @@ -87,6 +90,7 @@ pub fn has_dir(path: &str) -> bool { true } +#[allow(dead_code)] pub fn load_file(path: &str, name: &str) -> String { let dir = Path::new(&get_directory()).join(path); let file_path = dir.join(name); @@ -130,6 +134,7 @@ pub fn load_file_vec(path: &str, name: &str) -> Result, std::io::Error> std::fs::read(file_path) } +#[allow(dead_code)] pub fn save_file(path: &str, name: &str, value: &str) { let dir = Path::new(&get_directory()).join(path); let file_path = dir.join(name); @@ -157,6 +162,7 @@ pub fn save_file(path: &str, name: &str, value: &str) { } } +#[allow(dead_code)] pub fn get_children(path: &str) -> Vec { let dir = Path::new(&get_directory()).join(path); let mut children = Vec::new(); diff --git a/src/util/logger.rs b/src/util/logger.rs index ecfa334..9e9a085 100644 --- a/src/util/logger.rs +++ b/src/util/logger.rs @@ -9,10 +9,11 @@ use std::{ }; use ansi_term::Color; -use epsilon_core::{CommunicationValue, DataTypes, DataValue}; +use ttp_core::{CommunicationValue, DataTypes, DataValue}; static LOGGER: OnceLock> = OnceLock::new(); +#[allow(dead_code)] #[derive(Clone, Copy)] pub enum PrintType { Call,