...

iota-storage/Cargo.toml

@@ -4,6 +4,10 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+iota-logger = { path = "../iota-logger" }
+iota-state = { path = "../iota-state" }
+iota-util = { path = "../iota-util" }
+
 ttp-core = { git = "https://github.com/Tensamin/TTP.git", package = "ttp-core" }
 ttp-native = { git = "https://github.com/Tensamin/TTP.git", package = "ttp-native" }
 

iota-storage/src/lib.rs

@@ -1,2 +1,2 @@
-mod users;
-mod util;
+pub mod users;
+pub mod util;

iota-storage/src/users/user_community_util.rs

@@ -1,4 +1,4 @@
-use crate::util::file_util::save_file;
+use iota_util::file_util::save_file;
 use json::{self, Array, JsonValue};
 use std::fs;
 use std::path::Path;

iota-storage/src/users/user_manager.rs

@@ -1,12 +1,9 @@
-use crate::omikron::omikron_connection::OMIKRON_CONNECTION;
 use crate::users::user_profile::UserProfile;
-use crate::util::crypto_helper::{self, public_key_to_base64};
-use crate::util::file_util::{load_file, save_file};
-use crate::util::logger::PrintType;
-use crate::{RELOAD, SHUTDOWN};
-use crate::{log, log_cv};
 use base64::{Engine as _, engine::general_purpose::STANDARD};
 use hex::{self};
+use iota_logger::{log, log_cv};
+use iota_util::crypto_helper::{self, public_key_to_base64};
+use iota_util::file_util::{load_file, save_file};
 use json::JsonValue;
 use once_cell::sync::Lazy;
 use rand::Rng;
@@ -48,84 +45,7 @@ pub async fn load_from_tu(username: &str) -> Result<(), ()> {
     Ok(())
 }
 
-pub async fn create_user(username: &str) -> (Option<UserProfile>, Option<String>) {
-    let register_cv = CommunicationValue::new(CommunicationType::get_register);
-
-    let conn = OMIKRON_CONNECTION.clone();
-
-    let response_cv = match conn
-        .await_response(&register_cv, Some(Duration::from_secs(20)))
-        .await
-    {
-        Ok(cv) => cv,
-        Err(_) => return (None, None),
-    };
-    log_cv!(PrintType::Omega, response_cv);
-
-    let user_id = match response_cv.get_data(DataTypes::user_id).as_number() {
-        Some(id) => id,
-        None => return (None, None),
-    };
-    let mut buf = [0u8; 56];
-    let mut rng = OsRng;
-    rng.fill_bytes(&mut buf);
-    let private_key = Secret::from_bytes(&buf).unwrap();
-    let public_key = PublicKey::from(&private_key);
-
-    let mut hasher = Sha256::new();
-    hasher.update(&STANDARD.encode(&private_key.as_bytes()).as_bytes());
-    let result = hasher.finalize();
-    let private_key_hash = hex::encode(result);
-
-    let mut bytes = [0u8; 192];
-    OsRng.fill(bytes.as_mut());
-    let reset_token = STANDARD.encode(&bytes);
-
-    let up = UserProfile::new(
-        user_id,
-        username.to_string(),
-        None,
-        STANDARD.encode(&public_key.as_bytes()),
-        private_key_hash,
-        reset_token.clone(),
-    );
-
-    let cv = CommunicationValue::new(CommunicationType::complete_register_user)
-        .add_data(DataTypes::user_id, DataValue::Number(user_id))
-        .add_data(DataTypes::username, DataValue::Str(username.to_string()))
-        .add_data(
-            DataTypes::public_key,
-            DataValue::Str(public_key_to_base64(&public_key)),
-        )
-        .add_data(DataTypes::iota_id, DataValue::Number(user_id))
-        .add_data(DataTypes::reset_token, DataValue::Str(reset_token));
-
-    let response_cv = conn
-        .await_response(&cv, Some(Duration::from_secs(20)))
-        .await;
-
-    if let Ok(resp) = response_cv {
-        log_cv!(PrintType::Omega, resp);
-        if !resp.is_type(CommunicationType::success) {
-            return (None, None);
-        }
-    } else {
-        return (None, None);
-    }
-    *SHUTDOWN.write().await = true;
-    *RELOAD.write().await = true;
-    log!("Created User");
-    save_file(
-        "",
-        &format!("{}.tu", username),
-        &format!("{}::{}", user_id, STANDARD.encode(&private_key.as_bytes())),
-    );
-
-    USERS.lock().unwrap().push(up.clone());
-    save_users();
-    (Some(up), Some(STANDARD.encode(&private_key.as_bytes())))
-}
-
+pub fn add_user(user: UserProfile) { USERS.lock().unwrap().push(user); }
 pub fn get_user_by_username(username: &str) -> Option<UserProfile> {
     USERS
         .lock()

iota-storage/src/users/user_profile.rs

@@ -1,6 +1,6 @@
 use std::time::{SystemTime, UNIX_EPOCH};
 
-use crate::util::file_util::{has_file, load_file, used_dir_space};
+use iota_util::file_util::{has_file, load_file, used_dir_space};
 use base64::{Engine as _, engine::general_purpose};
 use json::{JsonValue, object};
 use rand::Rng;

iota-storage/src/util/chat_files.rs

@@ -1,5 +1,5 @@
-use crate::log;
 use crate::util::db;
+use iota_logger::log;
 use json::{JsonValue, array, object};
 use rusqlite::params;
 use std::io;

iota-storage/src/util/config_util.rs

@@ -1,4 +1,4 @@
-use crate::util::file_util::{load_file, save_file};
+use iota_util::file_util::{load_file, save_file};
 use json::JsonValue;
 use once_cell::sync::Lazy;
 use tokio::sync::RwLock;

iota-storage/src/util/db.rs

@@ -5,7 +5,7 @@
 //! reuse. The goal is to centralize the "open and initialize" logic and
 //! provide small convenience helpers used by other util modules.
 
-use crate::util::file_util::get_directory;
+use iota_util::file_util::get_directory;
 use rusqlite::{Connection, Error as RusqliteError};
 use std::path::PathBuf;
 use std::sync::{Arc, Mutex};

iota-storage/src/util/mod.rs

@@ -2,8 +2,4 @@ pub mod chat_files;
 pub mod chats_util;
 pub mod communities_util;
 pub mod config_util;
-pub mod crypto_helper;
-pub mod crypto_util;
 pub mod db;
-pub mod file_util;
-pub mod logger;