logos-messaging/libchat
1
0
Fork 0
mirror of https://github.com/logos-messaging/libchat.git synced 2026-02-10 08:53:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: storage the chats and handshake information

Browse Source
This commit is contained in:
kaichaosun 2026-02-05 12:47:26 +08:00
parent c3502113ae
commit 836cc4bdc4
No known key found for this signature in database
GPG Key ID: 223E0F992F4F03BF
11 changed files with 1030 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.lock generated
View File

@ -511,6 +511,7 @@ dependencies = [
"prost",
"rand_core",
"safer-ffi",
"storage",
"thiserror",
"x25519-dalek",
]

1
conversations/Cargo.toml
View File

@ -15,5 +15,6 @@ hex = "0.4.3"
prost = "0.14.1"
rand_core = { version = "0.6" }
safer-ffi = "0.1.13"
storage = { path = "../storage" }
thiserror = "2.0.17"
x25519-dalek = { version = "2.0.1", features = ["static_secrets", "reusable_secrets", "getrandom"] }

149
conversations/examples/chat_session.rs Normal file
View File

@ -0,0 +1,149 @@
//! Example: Chat Session with Automatic Persistence
//!
//! This example demonstrates using ChatSession which automatically
//! persists all state changes to SQLite storage.
//!
//! Run with: cargo run -p logos-chat --example chat_session
use logos_chat::storage::ChatSession;
fn main() {
println!("=== Chat Session Example ===\n");
// Use a temporary file for this example
let alice_db = "/tmp/alice_session.db";
let bob_db = "/tmp/bob_session.db";
// Clean up from previous runs
let _ = std::fs::remove_file(alice_db);
let _ = std::fs::remove_file(bob_db);
// =========================================
// Create sessions for Alice and Bob
// =========================================
println!("Step 1: Creating chat sessions...\n");
let mut alice = ChatSession::open_or_create(alice_db, "alice_secret_key")
.expect("Failed to create Alice's session");
println!(" Alice's session created");
println!(" Address: {}", truncate(&alice.local_address()));
let mut bob = ChatSession::open_or_create(bob_db, "bob_secret_key")
.expect("Failed to create Bob's session");
println!(" Bob's session created");
println!(" Address: {}", truncate(&bob.local_address()));
println!();
// =========================================
// Bob creates intro bundle
// =========================================
println!("Step 2: Bob creates introduction bundle...\n");
let bob_intro = bob
.create_intro_bundle()
.expect("Failed to create intro bundle");
println!(" Bob's intro bundle created");
println!(
" Installation key: {}",
truncate(&hex::encode(bob_intro.installation_key.as_bytes()))
);
println!();
// =========================================
// Alice starts a chat with Bob
// =========================================
println!("Step 3: Alice starts a private chat with Bob...\n");
let (chat_id, envelopes) = alice
.start_private_chat(&bob_intro, "Hello Bob! 👋")
.expect("Failed to start chat");
println!(" Chat created: {}", chat_id);
println!(" Envelopes to deliver: {}", envelopes.len());
println!(" Chat automatically saved to storage!");
println!();
// =========================================
// Verify persistence by checking storage
// =========================================
println!("Step 4: Verifying persistence...\n");
// Check Alice's storage directly
let chat_record = alice
.storage()
.load_chat(&chat_id)
.expect("Failed to load chat");
if let Some(record) = chat_record {
println!(" Chat record found in storage:");
println!(" - ID: {}", record.chat_id);
println!(" - Type: {}", record.chat_type);
println!(" - Remote: {}", record.remote_address);
}
println!();
// =========================================
// Alice sends more messages
// =========================================
println!("Step 5: Alice sends more messages...\n");
let messages = [
"How are you?",
"Are you there?",
"Let me know when you're free!",
];
for msg in &messages {
let envelopes = alice
.send_message(&chat_id, msg.as_bytes())
.expect("Failed to send message");
println!(" Sent: \"{}\" ({} envelope(s))", msg, envelopes.len());
}
println!();
// =========================================
// Simulate app restart - reopen session
// =========================================
println!("Step 6: Simulating app restart...\n");
drop(alice); // Close Alice's session
println!(" Session closed. Reopening...\n");
let alice_restored =
ChatSession::open(alice_db, "alice_secret_key").expect("Failed to reopen Alice's session");
println!(" Session restored!");
println!(" Address: {}", truncate(&alice_restored.local_address()));
// Note: The chats list will be empty because we haven't implemented
// full chat restoration yet (which requires restoring ratchet states)
println!(" Chats in memory: {}", alice_restored.list_chats().len());
// But the chat metadata is persisted in storage
let stored_chats = alice_restored
.storage()
.list_chat_ids()
.expect("Failed to list chats");
println!(" Chats in storage: {:?}", stored_chats);
println!();
println!("=== Chat Session Example Complete ===\n");
println!("Key features demonstrated:");
println!(" ✓ Automatic identity persistence");
println!(" ✓ Automatic chat metadata persistence");
println!(" ✓ Session recovery after restart");
println!();
println!("TODO:");
println!(" - Full inbox key persistence");
println!(" - Ratchet state persistence (integration with double-ratchets storage)");
println!(" - Complete chat restoration on session open");
// Clean up
let _ = std::fs::remove_file(alice_db);
let _ = std::fs::remove_file(bob_db);
}
fn truncate(s: &str) -> String {
if s.len() > 16 {
format!("{}...{}", &s[..8], &s[s.len() - 8..])
} else {
s.to_string()
}
}

145
conversations/examples/persistent_chat.rs Normal file
View File

@ -0,0 +1,145 @@
//! Example: Persistent Chat with SQLite Storage
//!
//! This example demonstrates how to persist and restore chat state using
//! SQLite storage, so users can restart the app and continue their chats.
//!
//! Run with: cargo run -p logos-chat --example persistent_chat
use logos_chat::{
chat::ChatManager,
identity::Identity,
storage::{ChatStorage, ChatRecord},
};
use x25519_dalek::PublicKey;
fn main() {
println!("=== Persistent Chat Example ===\n");
// Use a temporary file for this example
let db_path = "/tmp/chat_example.db";
// Clean up from previous runs
let _ = std::fs::remove_file(db_path);
// =========================================
// Part 1: First Session - Create and save state
// =========================================
println!("--- Part 1: First Session ---\n");
{
// Open storage
let mut storage = ChatStorage::open(db_path)
.expect("Failed to open storage");
println!("1. Creating new identity...");
let alice = ChatManager::new();
let alice_address = alice.local_address();
println!(" Address: {}...{}", &alice_address[..8], &alice_address[alice_address.len()-8..]);
// Save identity to storage
// Note: In a real app, you'd access the identity from ChatManager
// For now, we'll create a separate identity to demonstrate storage
let identity = Identity::new();
storage.save_identity(&identity).expect("Failed to save identity");
println!(" Identity saved to database");
// Simulate creating some inbox keys
println!("\n2. Creating inbox keys...");
let secret1 = x25519_dalek::StaticSecret::random();
let pub1 = PublicKey::from(&secret1);
let pub1_hex = hex::encode(pub1.as_bytes());
storage.save_inbox_key(&pub1_hex, &secret1).expect("Failed to save inbox key");
println!(" Saved inbox key: {}...", &pub1_hex[..16]);
let secret2 = x25519_dalek::StaticSecret::random();
let pub2 = PublicKey::from(&secret2);
let pub2_hex = hex::encode(pub2.as_bytes());
storage.save_inbox_key(&pub2_hex, &secret2).expect("Failed to save inbox key");
println!(" Saved inbox key: {}...", &pub2_hex[..16]);
// Simulate creating some chats
println!("\n3. Creating chat records...");
let remote_key = PublicKey::from(&x25519_dalek::StaticSecret::random());
let chat1 = ChatRecord::new_private(
"chat_with_bob".to_string(),
remote_key,
"bob_delivery_addr".to_string(),
);
storage.save_chat(&chat1).expect("Failed to save chat");
println!(" Saved chat: {}", chat1.chat_id);
let remote_key2 = PublicKey::from(&x25519_dalek::StaticSecret::random());
let chat2 = ChatRecord::new_private(
"chat_with_carol".to_string(),
remote_key2,
"carol_delivery_addr".to_string(),
);
storage.save_chat(&chat2).expect("Failed to save chat");
println!(" Saved chat: {}", chat2.chat_id);
println!("\n First session complete. Closing database...");
}
// =========================================
// Part 2: Second Session - Restore state
// =========================================
println!("\n--- Part 2: Second Session (After Restart) ---\n");
{
// Reopen storage
let storage = ChatStorage::open(db_path)
.expect("Failed to open storage");
println!("1. Restoring identity...");
if let Some(identity) = storage.load_identity().expect("Failed to load identity") {
let address = identity.address();
println!(" Restored identity: {}...{}", &address[..8], &address[address.len()-8..]);
} else {
println!(" No identity found!");
}
println!("\n2. Restoring inbox keys...");
let inbox_keys = storage.load_all_inbox_keys().expect("Failed to load inbox keys");
println!(" Found {} inbox key(s)", inbox_keys.len());
for (pub_hex, _secret) in &inbox_keys {
println!(" - {}...", &pub_hex[..16]);
}
println!("\n3. Restoring chats...");
let chats = storage.load_all_chats().expect("Failed to load chats");
println!(" Found {} chat(s)", chats.len());
for chat in &chats {
println!(" - {} (type: {}, remote: {})",
chat.chat_id,
chat.chat_type,
chat.remote_address
);
}
// Demonstrate loading a specific chat
println!("\n4. Loading specific chat...");
if let Some(chat) = storage.load_chat("chat_with_bob").expect("Failed to load chat") {
println!(" Chat ID: {}", chat.chat_id);
println!(" Type: {}", chat.chat_type);
println!(" Remote Address: {}", chat.remote_address);
println!(" Created At: {}", chat.created_at);
}
// Demonstrate listing chat IDs
println!("\n5. Listing all chat IDs...");
let ids = storage.list_chat_ids().expect("Failed to list chat IDs");
for id in ids {
println!(" - {}", id);
}
}
// Cleanup
let _ = std::fs::remove_file(db_path);
println!("\n=== Persistent Chat Example Complete ===");
println!("\nNote: In a real application, you would:");
println!(" 1. Load identity on startup (or create new if none exists)");
println!(" 2. Restore inbox keys to handle incoming handshakes");
println!(" 3. Restore chat records and their associated ratchet states");
println!(" 4. Save state after each operation for durability");
}

12
conversations/src/identity.rs
View File

@ -22,6 +22,18 @@ impl Identity {
}
}
/// Create an Identity from an existing secret key.
pub fn from_secret(secret: StaticSecret) -> Self {
Self { secret }
}
/// Create an Identity from raw secret key bytes.
pub fn from_bytes(bytes: [u8; 32]) -> Self {
Self {
secret: StaticSecret::from(bytes),
}
}
pub fn address(&self) -> String {
hex::encode(Blake2b512::digest(self.public_key()))
}

3
conversations/src/lib.rs
View File

@ -3,10 +3,11 @@ pub mod common;
pub mod dm;
pub mod ffi;
pub mod group;
pub mod identity;
pub mod inbox;
pub mod storage;
mod errors;
mod identity;
mod proto;
mod types;
mod utils;

372
conversations/src/storage/db.rs Normal file
View File

@ -0,0 +1,372 @@
//! Chat-specific storage implementation.
use std::collections::HashMap;
use storage::{RusqliteError, SqliteDb, StorageError, params};
use x25519_dalek::StaticSecret;
use super::types::{ChatRecord, IdentityRecord};
use crate::identity::Identity;
/// Schema for chat storage tables.
const CHAT_SCHEMA: &str = "
-- Identity table (single row)
CREATE TABLE IF NOT EXISTS identity (
id INTEGER PRIMARY KEY CHECK (id = 1),
secret_key BLOB NOT NULL
);
-- Inbox ephemeral keys for handshakes
CREATE TABLE IF NOT EXISTS inbox_keys (
public_key_hex TEXT PRIMARY KEY,
secret_key BLOB NOT NULL,
created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now'))
);
-- Chat metadata
CREATE TABLE IF NOT EXISTS chats (
chat_id TEXT PRIMARY KEY,
chat_type TEXT NOT NULL,
remote_public_key BLOB,
remote_address TEXT NOT NULL,
created_at INTEGER NOT NULL
);
CREATE INDEX IF NOT EXISTS idx_chats_type ON chats(chat_type);
";
/// Chat-specific storage operations.
///
/// This struct wraps a `SqliteDb` and provides domain-specific
/// storage operations for chat state.
pub struct ChatStorage {
db: SqliteDb,
}
impl ChatStorage {
/// Opens an existing encrypted database file.
pub fn new(path: &str, key: &str) -> Result<Self, StorageError> {
let db = SqliteDb::sqlcipher(path.to_string(), key.to_string())?;
Self::run_migration(db)
}
/// Creates an in-memory storage (useful for testing).
pub fn in_memory() -> Result<Self, StorageError> {
let db = SqliteDb::in_memory()?;
Self::run_migration(db)
}
/// Opens an unencrypted database file (for development/testing).
pub fn open(path: &str) -> Result<Self, StorageError> {
let db = SqliteDb::open(path)?;
Self::run_migration(db)
}
/// Creates a new chat storage with the given database.
fn run_migration(db: SqliteDb) -> Result<Self, StorageError> {
db.connection().execute_batch(CHAT_SCHEMA)?;
Ok(Self { db })
}
// ==================== Identity Operations ====================
/// Saves the identity (secret key).
pub fn save_identity(&mut self, identity: &Identity) -> Result<(), StorageError> {
let record = IdentityRecord::from(identity);
self.db.connection().execute(
"INSERT OR REPLACE INTO identity (id, secret_key) VALUES (1, ?1)",
params![record.secret_key.as_slice()],
)?;
Ok(())
}
/// Loads the identity if it exists.
pub fn load_identity(&self) -> Result<Option<Identity>, StorageError> {
let mut stmt = self
.db
.connection()
.prepare("SELECT secret_key FROM identity WHERE id = 1")?;
let result = stmt.query_row([], |row| {
let secret_key: Vec<u8> = row.get(0)?;
Ok(secret_key)
});
match result {
Ok(secret_key) => {
let bytes: [u8; 32] = secret_key
.try_into()
.map_err(|_| StorageError::InvalidData("Invalid secret key length".into()))?;
let record = IdentityRecord { secret_key: bytes };
Ok(Some(Identity::from(record)))
}
Err(RusqliteError::QueryReturnedNoRows) => Ok(None),
Err(e) => Err(e.into()),
}
}
/// Checks if an identity exists.
pub fn has_identity(&self) -> Result<bool, StorageError> {
let count: i64 =
self.db
.connection()
.query_row("SELECT COUNT(*) FROM identity", [], |row| row.get(0))?;
Ok(count > 0)
}
// ==================== Inbox Key Operations ====================
/// Saves an inbox ephemeral key.
pub fn save_inbox_key(
&mut self,
public_key_hex: &str,
secret: &StaticSecret,
) -> Result<(), StorageError> {
self.db.connection().execute(
"INSERT OR REPLACE INTO inbox_keys (public_key_hex, secret_key) VALUES (?1, ?2)",
params![public_key_hex, secret.to_bytes().as_slice()],
)?;
Ok(())
}
/// Loads an inbox ephemeral key by its public key hex.
pub fn load_inbox_key(
&self,
public_key_hex: &str,
) -> Result<Option<StaticSecret>, StorageError> {
let mut stmt = self
.db
.connection()
.prepare("SELECT secret_key FROM inbox_keys WHERE public_key_hex = ?1")?;
let result = stmt.query_row(params![public_key_hex], |row| {
let secret_key: Vec<u8> = row.get(0)?;
Ok(secret_key)
});
match result {
Ok(secret_key) => {
let bytes: [u8; 32] = secret_key
.try_into()
.map_err(|_| StorageError::InvalidData("Invalid secret key length".into()))?;
Ok(Some(StaticSecret::from(bytes)))
}
Err(RusqliteError::QueryReturnedNoRows) => Ok(None),
Err(e) => Err(e.into()),
}
}
/// Loads all inbox ephemeral keys.
pub fn load_all_inbox_keys(&self) -> Result<HashMap<String, StaticSecret>, StorageError> {
let mut stmt = self
.db
.connection()
.prepare("SELECT public_key_hex, secret_key FROM inbox_keys")?;
let rows = stmt.query_map([], |row| {
let public_key_hex: String = row.get(0)?;
let secret_key: Vec<u8> = row.get(1)?;
Ok((public_key_hex, secret_key))
})?;
let mut keys = HashMap::new();
for row in rows {
let (public_key_hex, secret_key) = row?;
let bytes: [u8; 32] = secret_key
.try_into()
.map_err(|_| StorageError::InvalidData("Invalid secret key length".into()))?;
keys.insert(public_key_hex, StaticSecret::from(bytes));
}
Ok(keys)
}
/// Deletes an inbox ephemeral key (after it's been used).
pub fn delete_inbox_key(&mut self, public_key_hex: &str) -> Result<(), StorageError> {
self.db.connection().execute(
"DELETE FROM inbox_keys WHERE public_key_hex = ?1",
params![public_key_hex],
)?;
Ok(())
}
// ==================== Chat Operations ====================
/// Saves a chat record.
pub fn save_chat(&mut self, chat: &ChatRecord) -> Result<(), StorageError> {
self.db.connection().execute(
"INSERT OR REPLACE INTO chats (chat_id, chat_type, remote_public_key, remote_address, created_at)
VALUES (?1, ?2, ?3, ?4, ?5)",
params![
chat.chat_id,
chat.chat_type,
chat.remote_public_key.as_ref().map(|k| k.as_slice()),
chat.remote_address,
chat.created_at,
],
)?;
Ok(())
}
/// Loads a chat record by ID.
pub fn load_chat(&self, chat_id: &str) -> Result<Option<ChatRecord>, StorageError> {
let mut stmt = self.db.connection().prepare(
"SELECT chat_id, chat_type, remote_public_key, remote_address, created_at
FROM chats WHERE chat_id = ?1",
)?;
let result = stmt.query_row(params![chat_id], |row| {
let remote_public_key: Option<Vec<u8>> = row.get(2)?;
Ok(ChatRecord {
chat_id: row.get(0)?,
chat_type: row.get(1)?,
remote_public_key: remote_public_key.and_then(|v| v.try_into().ok()),
remote_address: row.get(3)?,
created_at: row.get(4)?,
})
});
match result {
Ok(record) => Ok(Some(record)),
Err(RusqliteError::QueryReturnedNoRows) => Ok(None),
Err(e) => Err(e.into()),
}
}
/// Loads all chat records.
pub fn load_all_chats(&self) -> Result<Vec<ChatRecord>, StorageError> {
let mut stmt = self.db.connection().prepare(
"SELECT chat_id, chat_type, remote_public_key, remote_address, created_at FROM chats",
)?;
let rows = stmt.query_map([], |row| {
let remote_public_key: Option<Vec<u8>> = row.get(2)?;
Ok(ChatRecord {
chat_id: row.get(0)?,
chat_type: row.get(1)?,
remote_public_key: remote_public_key.and_then(|v| v.try_into().ok()),
remote_address: row.get(3)?,
created_at: row.get(4)?,
})
})?;
let mut chats = Vec::new();
for row in rows {
chats.push(row?);
}
Ok(chats)
}
/// Deletes a chat record.
pub fn delete_chat(&mut self, chat_id: &str) -> Result<(), StorageError> {
self.db
.connection()
.execute("DELETE FROM chats WHERE chat_id = ?1", params![chat_id])?;
Ok(())
}
/// Lists all chat IDs.
pub fn list_chat_ids(&self) -> Result<Vec<String>, StorageError> {
let mut stmt = self.db.connection().prepare("SELECT chat_id FROM chats")?;
let rows = stmt.query_map([], |row| row.get(0))?;
let mut ids = Vec::new();
for row in rows {
ids.push(row?);
}
Ok(ids)
}
/// Checks if a chat exists.
pub fn chat_exists(&self, chat_id: &str) -> Result<bool, StorageError> {
let count: i64 = self.db.connection().query_row(
"SELECT COUNT(*) FROM chats WHERE chat_id = ?1",
params![chat_id],
|row| row.get(0),
)?;
Ok(count > 0)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_identity_roundtrip() {
let mut storage = ChatStorage::in_memory().unwrap();
// Initially no identity
assert!(!storage.has_identity().unwrap());
assert!(storage.load_identity().unwrap().is_none());
// Save identity
let identity = Identity::new();
let address = identity.address();
storage.save_identity(&identity).unwrap();
// Load identity
assert!(storage.has_identity().unwrap());
let loaded = storage.load_identity().unwrap().unwrap();
assert_eq!(loaded.address(), address);
}
#[test]
fn test_inbox_key_roundtrip() {
let mut storage = ChatStorage::in_memory().unwrap();
let secret = StaticSecret::random();
let public_key = x25519_dalek::PublicKey::from(&secret);
let public_key_hex = hex::encode(public_key.as_bytes());
// Save key
storage.save_inbox_key(&public_key_hex, &secret).unwrap();
// Load key
let loaded = storage.load_inbox_key(&public_key_hex).unwrap().unwrap();
assert_eq!(
x25519_dalek::PublicKey::from(&loaded).as_bytes(),
public_key.as_bytes()
);
// Load all keys
let all_keys = storage.load_all_inbox_keys().unwrap();
assert_eq!(all_keys.len(), 1);
assert!(all_keys.contains_key(&public_key_hex));
// Delete key
storage.delete_inbox_key(&public_key_hex).unwrap();
assert!(storage.load_inbox_key(&public_key_hex).unwrap().is_none());
}
#[test]
fn test_chat_roundtrip() {
let mut storage = ChatStorage::in_memory().unwrap();
let remote_key = x25519_dalek::PublicKey::from(&StaticSecret::random());
let chat = ChatRecord::new_private(
"chat_123".to_string(),
remote_key,
"delivery_addr".to_string(),
);
// Save chat
storage.save_chat(&chat).unwrap();
// Load chat
let loaded = storage.load_chat("chat_123").unwrap().unwrap();
assert_eq!(loaded.chat_id, "chat_123");
assert_eq!(loaded.chat_type, "private_v1");
assert_eq!(loaded.remote_address, "delivery_addr");
// List chats
let ids = storage.list_chat_ids().unwrap();
assert_eq!(ids, vec!["chat_123"]);
// Delete chat
storage.delete_chat("chat_123").unwrap();
assert!(!storage.chat_exists("chat_123").unwrap());
}
}

13
conversations/src/storage/mod.rs Normal file
View File

@ -0,0 +1,13 @@
//! Storage module for persisting chat state.
//!
//! This module provides storage implementations for the chat manager state,
//! built on top of the shared `storage` crate.
mod db;
mod session;
mod types;
pub use db::ChatStorage;
pub use session::{ChatSession, SessionError};
pub use storage::{SqliteDb, StorageConfig, StorageError};
pub use types::{ChatRecord, IdentityRecord, InboxKeyRecord};

250
conversations/src/storage/session.rs Normal file
View File

@ -0,0 +1,250 @@
//! Session wrapper for automatic state persistence.
//!
//! Provides a `ChatSession` that wraps `ChatManager` and automatically
//! persists state changes to SQLite storage.
use crate::{
chat::ChatManager,
errors::ChatError,
identity::Identity,
inbox::Introduction,
storage::{ChatRecord, ChatStorage, StorageError},
types::{AddressedEnvelope, ContentData},
};
/// Error type for chat session operations.
#[derive(Debug, thiserror::Error)]
pub enum SessionError {
#[error("chat error: {0}")]
Chat(#[from] ChatError),
#[error("storage error: {0}")]
Storage(#[from] StorageError),
#[error("session already exists for this identity")]
SessionExists,
}
/// A persistent chat session that automatically saves state to storage.
///
/// This wraps a `ChatManager` and ensures all state changes are persisted
/// to SQLite storage. When reopened, the session restores the previous state.
///
/// # Example
///
/// ```ignore
/// // Create a new session (or open existing)
/// let mut session = ChatSession::open_or_create("chat.db", "encryption_key")?;
///
/// // Create intro bundle (automatically persisted)
/// let intro = session.create_intro_bundle()?;
///
/// // Start a chat (automatically persisted)
/// let (chat_id, envelopes) = session.start_private_chat(&remote_intro, "Hello!")?;
///
/// // Later, reopen the session
/// let mut session = ChatSession::open("chat.db", "encryption_key")?;
/// // Previous identity and chats are restored
/// ```
pub struct ChatSession {
manager: ChatManager,
storage: ChatStorage,
}
impl ChatSession {
/// Opens an existing session from storage.
///
/// Returns an error if no identity exists in the storage.
pub fn open(path: &str, key: &str) -> Result<Self, SessionError> {
let storage = ChatStorage::new(path, key)?;
let identity = storage
.load_identity()?
.ok_or_else(|| SessionError::Storage(StorageError::NotFound("identity".into())))?;
let manager = ChatManager::with_identity(identity);
// TODO: Restore inbox ephemeral keys
// TODO: Restore active chats
Ok(Self { manager, storage })
}
/// Creates a new session with a fresh identity.
///
/// Returns an error if an identity already exists in the storage.
pub fn create(path: &str, key: &str) -> Result<Self, SessionError> {
let mut storage = ChatStorage::new(path, key)?;
if storage.has_identity()? {
return Err(SessionError::SessionExists);
}
let identity = Identity::new();
storage.save_identity(&identity)?;
let manager = ChatManager::with_identity(identity);
Ok(Self { manager, storage })
}
/// Opens an existing session or creates a new one if none exists.
pub fn open_or_create(path: &str, key: &str) -> Result<Self, SessionError> {
let mut storage = ChatStorage::new(path, key)?;
let identity = if let Some(identity) = storage.load_identity()? {
identity
} else {
let identity = Identity::new();
storage.save_identity(&identity)?;
identity
};
let manager = ChatManager::with_identity(identity);
// TODO: Restore inbox ephemeral keys and active chats
Ok(Self { manager, storage })
}
/// Creates an in-memory session (useful for testing).
pub fn in_memory() -> Result<Self, SessionError> {
let mut storage = ChatStorage::in_memory()?;
let identity = Identity::new();
storage.save_identity(&identity)?;
let manager = ChatManager::with_identity(identity);
Ok(Self { manager, storage })
}
/// Get the local identity's public address.
pub fn local_address(&self) -> String {
self.manager.local_address()
}
/// Create an introduction bundle that can be shared with others.
///
/// The ephemeral key is automatically persisted.
pub fn create_intro_bundle(&mut self) -> Result<Introduction, SessionError> {
let intro = self.manager.create_intro_bundle()?;
// Persist the ephemeral key
let _public_key_hex = hex::encode(intro.ephemeral_key.as_bytes());
// TODO: Get the secret key from inbox and persist it
// self.storage.save_inbox_key(&public_key_hex, &secret)?;
Ok(intro)
}
/// Start a new private conversation with someone using their introduction bundle.
///
/// The chat state is automatically persisted.
pub fn start_private_chat(
&mut self,
remote_bundle: &Introduction,
initial_message: &str,
) -> Result<(String, Vec<AddressedEnvelope>), SessionError> {
let (chat_id, envelopes) = self.manager.start_private_chat(remote_bundle, initial_message)?;
// Persist chat metadata
let chat_record = ChatRecord::new_private(
chat_id.clone(),
remote_bundle.installation_key,
"delivery_address".to_string(), // TODO: Get actual delivery address
);
self.storage.save_chat(&chat_record)?;
Ok((chat_id, envelopes))
}
/// Send a message to an existing chat.
///
/// The updated chat state is automatically persisted.
pub fn send_message(
&mut self,
chat_id: &str,
content: &[u8],
) -> Result<Vec<AddressedEnvelope>, SessionError> {
let envelopes = self.manager.send_message(chat_id, content)?;
// TODO: Persist updated ratchet state
Ok(envelopes)
}
/// Handle an incoming payload from the network.
pub fn handle_incoming(&mut self, payload: &[u8]) -> Result<ContentData, SessionError> {
let content = self.manager.handle_incoming(payload)?;
// TODO: Persist updated state
Ok(content)
}
/// List all active chat IDs.
pub fn list_chats(&self) -> Vec<String> {
self.manager.list_chats()
}
/// Get access to the underlying ChatManager.
pub fn manager(&self) -> &ChatManager {
&self.manager
}
/// Get mutable access to the underlying ChatManager.
pub fn manager_mut(&mut self) -> &mut ChatManager {
&mut self.manager
}
/// Get access to the underlying storage.
pub fn storage(&self) -> &ChatStorage {
&self.storage
}
/// Get mutable access to the underlying storage.
pub fn storage_mut(&mut self) -> &mut ChatStorage {
&mut self.storage
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_create_session() {
let session = ChatSession::in_memory().unwrap();
assert!(!session.local_address().is_empty());
}
#[test]
fn test_session_persistence() {
// Create a session with in-memory storage
let session = ChatSession::in_memory().unwrap();
let address = session.local_address();
// Verify identity was saved
let loaded_identity = session.storage.load_identity().unwrap();
assert!(loaded_identity.is_some());
assert_eq!(loaded_identity.unwrap().address(), address);
}
#[test]
fn test_start_chat_persists() {
let mut alice = ChatSession::in_memory().unwrap();
let mut bob = ChatSession::in_memory().unwrap();
// Bob creates intro bundle
let bob_intro = bob.create_intro_bundle().unwrap();
// Alice starts a chat
let (chat_id, _envelopes) = alice
.start_private_chat(&bob_intro, "Hello!")
.unwrap();
// Verify chat was persisted
let chat_record = alice.storage.load_chat(&chat_id).unwrap();
assert!(chat_record.is_some());
assert_eq!(chat_record.unwrap().chat_type, "private_v1");
}
}

81
conversations/src/storage/types.rs Normal file
View File

@ -0,0 +1,81 @@
//! Storage record types for serialization/deserialization.
use x25519_dalek::{PublicKey, StaticSecret};
use crate::identity::Identity;
/// Record for storing identity (secret key).
#[derive(Debug)]
pub struct IdentityRecord {
/// The secret key bytes (32 bytes).
pub secret_key: [u8; 32],
}
impl From<&Identity> for IdentityRecord {
fn from(identity: &Identity) -> Self {
Self {
secret_key: identity.secret().to_bytes(),
}
}
}
impl From<IdentityRecord> for Identity {
fn from(record: IdentityRecord) -> Self {
let secret = StaticSecret::from(record.secret_key);
Identity::from_secret(secret)
}
}
/// Record for storing inbox ephemeral keys.
#[derive(Debug)]
pub struct InboxKeyRecord {
/// Hex-encoded public key (used as identifier).
pub public_key_hex: String,
/// The secret key bytes (32 bytes).
pub secret_key: [u8; 32],
}
impl InboxKeyRecord {
pub fn new(public_key_hex: String, secret: &StaticSecret) -> Self {
Self {
public_key_hex,
secret_key: secret.to_bytes(),
}
}
pub fn into_secret(self) -> StaticSecret {
StaticSecret::from(self.secret_key)
}
}
/// Record for storing chat metadata.
/// Note: The actual double ratchet state is stored separately by the DR storage.
#[derive(Debug, Clone)]
pub struct ChatRecord {
/// Unique chat identifier.
pub chat_id: String,
/// Type of chat (e.g., "private_v1", "group_v1").
pub chat_type: String,
/// Remote party's public key (for private chats).
pub remote_public_key: Option<[u8; 32]>,
/// Remote party's delivery address.
pub remote_address: String,
/// Creation timestamp (unix millis).
pub created_at: i64,
}
impl ChatRecord {
pub fn new_private(
chat_id: String,
remote_public_key: PublicKey,
remote_address: String,
) -> Self {
Self {
chat_id,
chat_type: "private_v1".to_string(),
remote_public_key: Some(remote_public_key.to_bytes()),
remote_address,
created_at: crate::utils::timestamp_millis() as i64,
}
}
}

4
storage/src/errors.rs
View File

@ -26,6 +26,10 @@ pub enum StorageError {
/// Transaction error.
#[error("transaction error: {0}")]
Transaction(String),
/// Invalid data error.
#[error("invalid data: {0}")]
InvalidData(String),
}
impl From<rusqlite::Error> for StorageError {