coderabbit suggestions

Author: Catrya

src/cli.rs

@@ -433,8 +433,7 @@ pub async fn run() -> Result<()> {
                 let id_key = match std::env::var("NSEC_PRIVKEY") {
                     Ok(id_key) => Keys::parse(&id_key)?,
                     Err(e) => {
-                        println!("Failed to get mostro admin private key: {}", e);
-                        std::process::exit(1);
+                        anyhow::bail!("NSEC_PRIVKEY not set: {e}");
                     }
                 };
                 execute_admin_add_solver(npubkey, &id_key, &trade_keys, mostro_key, &client).await?
@@ -476,8 +475,7 @@ pub async fn run() -> Result<()> {
                 let id_key = match std::env::var("NSEC_PRIVKEY") {
                     Ok(id_key) => Keys::parse(&id_key)?,
                     Err(e) => {
-                        println!("Failed to get mostro admin private key: {}", e);
-                        std::process::exit(1);
+                        anyhow::bail!("NSEC_PRIVKEY not set: {e}");
                     }
                 };
                 execute_admin_settle_dispute(order_id, &id_key, &trade_keys, mostro_key, &client)
@@ -487,8 +485,7 @@ pub async fn run() -> Result<()> {
                 let id_key = match std::env::var("NSEC_PRIVKEY") {
                     Ok(id_key) => Keys::parse(&id_key)?,
                     Err(e) => {
-                        println!("Failed to get mostro admin private key: {}", e);
-                        std::process::exit(1);
+                        anyhow::bail!("NSEC_PRIVKEY not set: {e}");
                     }
                 };
                 execute_admin_cancel_dispute(order_id, &id_key, &trade_keys, mostro_key, &client)
@@ -498,8 +495,7 @@ pub async fn run() -> Result<()> {
                 let id_key = match std::env::var("NSEC_PRIVKEY") {
                     Ok(id_key) => Keys::parse(&id_key)?,
                     Err(e) => {
-                        println!("Failed to get mostro admin private key: {}", e);
-                        std::process::exit(1);
+                        anyhow::bail!("NSEC_PRIVKEY not set: {e}");
                     }
                 };
 

src/cli/adm_send_dm.rs

@@ -10,9 +10,7 @@ pub async fn execute_adm_send_dm(
     let admin_keys = match std::env::var("NSEC_PRIVKEY") {
         Ok(key) => Keys::parse(&key)?,
         Err(e) => {
-            println!("Failed to get admin private key: {}", e);
-            println!("Make sure NSEC_PRIVKEY environment variable is set");
-            std::process::exit(1);
+            anyhow::bail!("NSEC_PRIVKEY not set: {e}");
         }
     };
 

src/cli/dm_to_user.rs

@@ -11,16 +11,12 @@ pub async fn execute_dm_to_user(
 ) -> Result<()> {
     let pool = crate::db::connect().await?;
 
-    let trade_keys = if let Ok(order) = Order::get_by_id(&pool, &order_id.to_string()).await {
-        match order.trade_keys.as_ref() {
-            Some(trade_keys) => Keys::parse(trade_keys)?,
-            None => {
-                anyhow::bail!("No trade_keys found for this order");
-            }
-        }
-    } else {
-        println!("order {} not found", order_id);
-        std::process::exit(0)
+    let order = Order::get_by_id(&pool, &order_id.to_string())
+        .await
+        .map_err(|_| anyhow::anyhow!("order {} not found", order_id))?;
+    let trade_keys = match order.trade_keys.as_ref() {
+        Some(trade_keys) => Keys::parse(trade_keys)?,
+        None => anyhow::bail!("No trade_keys found for this order"),
     };
 
     println!("SENDING DM with trade keys: {}", trade_keys.public_key().to_hex());

src/cli/get_dm.rs

@@ -21,7 +21,7 @@ pub async fn execute_get_dm(
     if !admin {
         for index in 1..=trade_index {
             let keys = User::get_trade_keys(&pool, index).await?;
-            let dm_temp = get_direct_messages(client, &keys, *since, from_user, Some(&mostro_pubkey)).await;
+            let dm_temp = get_direct_messages(client, &keys, *since, from_user, Some(mostro_pubkey)).await;
             dm.extend(dm_temp);
         }
     } else {

src/util.rs

@@ -12,13 +12,17 @@ use std::thread::sleep;
 use std::time::Duration;
 use std::{fs, path::Path};
 
-pub async fn send_admin_gift_wrap_dm(
+async fn send_gift_wrap_dm_internal(
     client: &Client,
-    admin_keys: &Keys,
+    sender_keys: &Keys,
     receiver_pubkey: &PublicKey,
     message: &str,
+    is_admin: bool,
 ) -> Result<()> {
-    let pow: u8 = var("POW").unwrap_or('0'.to_string()).parse().unwrap();
+    let pow: u8 = var("POW")
+        .unwrap_or_else(|_| "0".to_string())
+        .parse()
+        .unwrap_or(0);
 
     // Create Message struct for consistency with Mostro protocol
     let dm_message = Message::new_dm(
@@ -34,48 +38,34 @@ pub async fn send_admin_gift_wrap_dm(
     // Create the rumor with JSON content
     let rumor = EventBuilder::text_note(content)
         .pow(pow)
-        .build(admin_keys.public_key());
+        .build(sender_keys.public_key());
 
-    // Create gift wrap using admin_keys as the signing key
-    let event = EventBuilder::gift_wrap(admin_keys, receiver_pubkey, rumor, Tags::new()).await?;
+    // Create gift wrap using sender_keys as the signing key
+    let event = EventBuilder::gift_wrap(sender_keys, receiver_pubkey, rumor, Tags::new()).await?;
 
-    info!("Sending admin gift wrap event: {event:#?}");
+    let sender_type = if is_admin { "admin" } else { "user" };
+    info!("Sending {} gift wrap event to {}", sender_type, receiver_pubkey);
     client.send_event(&event).await?;
 
     Ok(())
 }
 
+pub async fn send_admin_gift_wrap_dm(
+    client: &Client,
+    admin_keys: &Keys,
+    receiver_pubkey: &PublicKey,
+    message: &str,
+) -> Result<()> {
+    send_gift_wrap_dm_internal(client, admin_keys, receiver_pubkey, message, true).await
+}
+
 pub async fn send_gift_wrap_dm(
     client: &Client,
     trade_keys: &Keys,
     receiver_pubkey: &PublicKey,
     message: &str,
 ) -> Result<()> {
-    let pow: u8 = var("POW").unwrap_or('0'.to_string()).parse().unwrap();
-    
-    // Create Message struct for consistency with Mostro protocol
-    let dm_message = Message::new_dm(
-        None,
-        None,
-        Action::SendDm,
-        Some(Payload::TextMessage(message.to_string())),
-    );
-    
-    // Serialize as JSON with the expected format (Message, Option<Signature>)
-    let content = serde_json::to_string(&(dm_message, None::<String>))?;
-    
-    // Create the rumor with JSON content
-    let rumor = EventBuilder::text_note(content)
-        .pow(pow)
-        .build(trade_keys.public_key());
-    
-    // Create gift wrap using trade_keys as ephemeral key
-    let event = EventBuilder::gift_wrap(trade_keys, receiver_pubkey, rumor, Tags::new()).await?;
-    
-    info!("Sending gift wrap event: {event:#?}");
-    client.send_event(&event).await?;
-    
-    Ok(())
+    send_gift_wrap_dm_internal(client, trade_keys, receiver_pubkey, message, false).await
 }
 
 pub async fn send_dm(
@@ -211,15 +201,24 @@ pub async fn get_direct_messages_from_trade_keys(
     since: i64,
     mostro_pubkey: &PublicKey,
 ) -> Vec<(Message, u64, PublicKey)> {
+    if trade_keys_hex.is_empty() {
+        return Vec::new();
+    }
+
     let fake_since = 2880;
     let fake_since_time = chrono::Utc::now()
         .checked_sub_signed(chrono::Duration::minutes(fake_since))
         .unwrap()
         .timestamp() as u64;
     let fake_timestamp = Timestamp::from(fake_since_time);
+    
+    let since_time = chrono::Utc::now()
+        .checked_sub_signed(chrono::Duration::minutes(since))
+        .unwrap()
+        .timestamp() as u64;
 
     let mut all_direct_messages: Vec<(Message, u64, PublicKey)> = Vec::new();
-    let mut id_list = Vec::<EventId>::new();
+    let mut id_set = std::collections::HashSet::<EventId>::new();
 
     for trade_key_hex in trade_keys_hex {
         if let Ok(trade_keys) = Keys::parse(&trade_key_hex) {
@@ -233,48 +232,45 @@ pub async fn get_direct_messages_from_trade_keys(
 
             if let Ok(events) = client.fetch_events(filters, Duration::from_secs(15)).await {
                 for dm in events.iter() {
-                    if !id_list.contains(&dm.id) {
-                        id_list.push(dm.id);
-                        
-                        let unwrapped_gift = match nip59::extract_rumor(&trade_keys, dm).await {
-                            Ok(u) => u,
-                            Err(_) => {
-                                println!("Error unwrapping gift for trade key: {}", trade_keys.public_key());
-                                continue;
-                            }
-                        };
-                        
-                        // Filter: only process messages NOT from Mostro (user-to-user messages)
-                        if unwrapped_gift.rumor.pubkey == *mostro_pubkey {
-                            continue; // Skip Mostro messages
-                        }
+                    if !id_set.insert(dm.id) {
+                        continue; // Already processed
+                    }
 
-                        let since_time = chrono::Utc::now()
-                            .checked_sub_signed(chrono::Duration::minutes(since))
-                            .unwrap()
-                            .timestamp() as u64;
-
-                        if unwrapped_gift.rumor.created_at.as_u64() < since_time {
+                    let unwrapped_gift = match nip59::extract_rumor(&trade_keys, dm).await {
+                        Ok(u) => u,
+                        Err(_) => {
+                            error!("Error unwrapping gift for trade key: {}", trade_keys.public_key());
                             continue;
                         }
+                    };
+                    
+                    // Filter: only process messages NOT from Mostro (user-to-user messages)
+                    if unwrapped_gift.rumor.pubkey == *mostro_pubkey {
+                        continue; // Skip Mostro messages
+                    }
 
-                        // Parse JSON content (all messages should be JSON now)
-                        let (message, _): (Message, Option<String>) = match serde_json::from_str(&unwrapped_gift.rumor.content) {
-                            Ok(parsed) => parsed,
-                            Err(_) => {
-                                println!("Error parsing JSON content from: {}", unwrapped_gift.rumor.pubkey);
-                                continue;
-                            }
-                        };
-                        
-                        all_direct_messages.push((
-                            message, 
-                            unwrapped_gift.rumor.created_at.as_u64(),
-                            unwrapped_gift.rumor.pubkey
-                        ));
+                    if unwrapped_gift.rumor.created_at.as_u64() < since_time {
+                        continue;
                     }
+
+                    // Parse JSON content (all messages should be JSON now)
+                    let (message, _): (Message, Option<String>) = match serde_json::from_str(&unwrapped_gift.rumor.content) {
+                        Ok(parsed) => parsed,
+                        Err(_) => {
+                            error!("Error parsing JSON content from: {}", unwrapped_gift.rumor.pubkey);
+                            continue;
+                        }
+                    };
+                    
+                    all_direct_messages.push((
+                        message, 
+                        unwrapped_gift.rumor.created_at.as_u64(),
+                        unwrapped_gift.rumor.pubkey
+                    ));
                 }
             }
+        } else {
+            error!("Failed to parse trade key: {}", trade_key_hex);
         }
     }