Aligning message management

Cargo.toml

@@ -39,7 +39,7 @@ uuid = { version = "1.18.1", features = [
 dotenvy = "0.15.6"
 lightning-invoice = { version = "0.33.2", features = ["std"] }
 reqwest = { version = "0.12.23", features = ["json"] }
-mostro-core = "0.6.50"
+mostro-core = "0.6.55"
 lnurl-rs = "0.9.0"
 pretty_env_logger = "0.5.0"
 openssl = { version = "0.10.73", features = ["vendored"] }

src/cli.rs

@@ -489,11 +489,11 @@ impl Commands {
 
             // DM retrieval commands
             Commands::GetDm { since, from_user } => {
-                execute_get_dm(Some(since), false, from_user, ctx).await
+                execute_get_dm(since, false, from_user, ctx).await
             }
             Commands::GetDmUser { since } => execute_get_dm_user(since, ctx).await,
             Commands::GetAdminDm { since, from_user } => {
-                execute_get_dm(Some(since), true, from_user, ctx).await
+                execute_get_dm(since, true, from_user, ctx).await
             }
 
             // Admin commands

src/cli/add_invoice.rs

@@ -1,3 +1,5 @@
+use crate::parser::dms::print_commands_results;
+use crate::parser::parse_dm_events;
 use crate::util::{send_dm, wait_for_dm};
 use crate::{cli::Context, db::Order, lightning::is_valid_invoice};
 use anyhow::Result;
@@ -52,45 +54,31 @@ pub async fn execute_add_invoice(order_id: &Uuid, invoice: &str, ctx: &Context)
         .as_json()
         .map_err(|_| anyhow::anyhow!("Failed to serialize message"))?;
 
-    // Subscribe to gift wrap events - ONLY NEW ONES WITH LIMIT 0
-    let subscription = Filter::new()
-        .pubkey(order_trade_keys.clone().public_key())
-        .kind(nostr_sdk::Kind::GiftWrap)
-        .limit(0);
-
-    let opts = SubscribeAutoCloseOptions::default().exit_policy(ReqExitPolicy::WaitForEvents(1));
-    ctx.client.subscribe(subscription, Some(opts)).await?;
-
-    // Clone the keys and client for the async call
-    let identity_keys_clone = ctx.identity_keys.clone();
-    let client_clone = ctx.client.clone();
-    let mostro_pubkey_clone = ctx.mostro_pubkey;
-    let order_trade_keys_clone = order_trade_keys.clone();
-
-    // Spawn a new task to send the DM
-    // This is so we can wait for the gift wrap event in the main thread
-    tokio::spawn(async move {
-        let _ = send_dm(
-            &client_clone,
-            Some(&identity_keys_clone),
-            &order_trade_keys,
-            &mostro_pubkey_clone,
-            message_json,
-            None,
-            false,
-        )
-        .await;
-    });
-
-    // Wait for the DM to be sent from mostro and update the order
-    wait_for_dm(
+    // Send the DM
+    send_dm(
         &ctx.client,
-        &order_trade_keys_clone,
-        request_id,
+        Some(&ctx.identity_keys),
+        &order_trade_keys,
+        &ctx.mostro_pubkey,
+        message_json,
         None,
-        Some(order),
-        &ctx.pool,
+        false,
     )
     .await?;
+
+    // Wait for the DM to be sent from mostro
+    let recv_event = wait_for_dm(ctx, Some(&order_trade_keys)).await?;
+
+    // Parse the incoming DM
+    let messages = parse_dm_events(recv_event, &order_trade_keys, None).await;
+    if let Some(message) = messages.first() {
+        let message = message.0.get_inner_message_kind();
+        if message.request_id == Some(request_id) {
+            if let Err(e) = print_commands_results(message, Some(order.clone()), ctx).await {
+                println!("Error in print_commands_results: {}", e);
+            }
+        }
+    }
+
     Ok(())
 }

src/cli/get_dm.rs

@@ -8,7 +8,7 @@ use crate::{
 };
 
 pub async fn execute_get_dm(
-    since: Option<&i64>,
+    since: &i64,
     admin: bool,
     from_user: &bool,
     ctx: &Context,
@@ -22,7 +22,8 @@ pub async fn execute_get_dm(
     };
 
     // Fetch the requested events
-    let all_fetched_events = { fetch_events_list(list_kind, None, None, None, ctx, since).await? };
+    let all_fetched_events =
+        fetch_events_list(list_kind, None, None, None, ctx, Some(since)).await?;
 
     // Extract (Message, u64) tuples from Event::MessageTuple variants
     let mut dm_events: Vec<(Message, u64)> = Vec::new();

src/cli/new_order.rs

@@ -1,9 +1,10 @@
 use crate::cli::Context;
+use crate::parser::dms::print_commands_results;
 use crate::parser::orders::print_order_preview;
+use crate::parser::parse_dm_events;
 use crate::util::{send_dm, uppercase_first, wait_for_dm};
 use anyhow::Result;
 use mostro_core::prelude::*;
-use nostr_sdk::prelude::*;
 use std::collections::HashMap;
 use std::io::{stdin, stdout, BufRead, Write};
 use std::process;
@@ -119,7 +120,8 @@ pub async fn execute_new_order(
 
     // Send dm to receiver pubkey
     println!(
-        "SENDING DM with trade keys: {:?}",
+        "SENDING DM with trade index: {} and trade keys: {:?}",
+        ctx.trade_index,
         ctx.trade_keys.public_key().to_hex()
     );
 
@@ -128,47 +130,39 @@ pub async fn execute_new_order(
         .as_json()
         .map_err(|_| anyhow::anyhow!("Failed to serialize message"))?;
 
-    // Clone the keys and client for the async call
-    let identity_keys_clone = ctx.identity_keys.clone();
-    let trade_keys_clone = ctx.trade_keys.clone();
-    let client_clone = ctx.client.clone();
-    let mostro_pubkey_clone = ctx.mostro_pubkey;
-
-    // Subscribe to gift wrap events - ONLY NEW ONES WITH LIMIT 0
-    let subscription = Filter::new()
-        .pubkey(ctx.trade_keys.public_key())
-        .kind(nostr_sdk::Kind::GiftWrap)
-        .limit(0);
-
-    let opts = SubscribeAutoCloseOptions::default().exit_policy(ReqExitPolicy::WaitForEvents(1));
-
-    ctx.client.subscribe(subscription, Some(opts)).await?;
-
-    // Spawn a new task to send the DM
-    // This is so we can wait for the gift wrap event in the main thread
-    tokio::spawn(async move {
-        let _ = send_dm(
-            &client_clone,
-            Some(&identity_keys_clone),
-            &trade_keys_clone,
-            &mostro_pubkey_clone,
-            message_json,
-            None,
-            false,
-        )
-        .await;
-    });
-
-    // Wait for the DM to be sent from mostro
-    wait_for_dm(
+    // Send the DM
+    send_dm(
         &ctx.client,
+        Some(&ctx.identity_keys),
         &ctx.trade_keys,
-        request_id,
-        Some(ctx.trade_index),
+        &ctx.mostro_pubkey,
+        message_json,
         None,
-        &ctx.pool,
+        false,
     )
     .await?;
 
+    // Wait for the DM to be sent from mostro
+    let recv_event = wait_for_dm(ctx, None).await?;
+
+    // Parse the incoming DM
+    let messages = parse_dm_events(recv_event, &ctx.trade_keys, None).await;
+    if let Some((message, _, _)) = messages.first() {
+        let message = message.0.get_inner_message_kind();
+        if message.request_id == Some(request_id) {
+            print_commands_results(message, None, ctx).await?;
+        } else {
+            return Err(anyhow::anyhow!(
+                "Received response with mismatched request_id. Expected: {}, Got: {:?}",
+                request_id,
+                message.request_id
+            ));
+        }
+    } else {
+        return Err(anyhow::anyhow!(
+            "No valid response received from Mostro after sending new order"
+        ));
+    }
+
     Ok(())
 }

src/cli/send_msg.rs

@@ -1,5 +1,7 @@
 use crate::cli::{Commands, Context};
 use crate::db::{Order, User};
+use crate::parser::dms::print_commands_results;
+use crate::parser::parse_dm_events;
 use crate::util::{send_dm, wait_for_dm};
 
 use anyhow::Result;
@@ -27,12 +29,13 @@ pub async fn execute_send_msg(
         }
     };
 
-    println!(
-        "Sending {} command for order {:?} to mostro pubId {}",
-        requested_action,
-        order_id.as_ref(),
-        &ctx.mostro_pubkey
-    );
+    match order_id {
+        Some(id) => println!(
+            "Sending {} command for order {} to mostro pubId {}",
+            requested_action, id, ctx.mostro_pubkey
+        ),
+        None => return Err(anyhow::anyhow!("Missing order id!")),
+    };
 
     // Determine payload
     let payload = match requested_action {
@@ -58,53 +61,42 @@ pub async fn execute_send_msg(
 
     // Create and send the message
     let message = Message::new_order(order_id, Some(request_id), None, requested_action, payload);
-    let idkey = ctx.identity_keys.to_owned();
 
     if let Some(order_id) = order_id {
         let order = Order::get_by_id(&ctx.pool, &order_id.to_string()).await?;
 
         if let Some(trade_keys_str) = order.trade_keys.clone() {
             let trade_keys = Keys::parse(&trade_keys_str)?;
-            // Subscribe to gift wrap events - ONLY NEW ONES WITH LIMIT 0
-            let subscription = Filter::new()
-                .pubkey(trade_keys.public_key())
-                .kind(nostr_sdk::Kind::GiftWrap)
-                .limit(0);
 
-            let opts =
-                SubscribeAutoCloseOptions::default().exit_policy(ReqExitPolicy::WaitForEvents(1));
-            // Subscribe to gift wrap events
-            ctx.client.subscribe(subscription, Some(opts)).await?;
             // Send DM
             let message_json = message
                 .as_json()
                 .map_err(|e| anyhow::anyhow!("Failed to serialize message: {e}"))?;
+
+            // Send DM
             send_dm(
                 &ctx.client,
-                Some(&idkey),
+                Some(&ctx.identity_keys),
                 &trade_keys,
                 &ctx.mostro_pubkey,
                 message_json,
                 None,
                 false,
             )
-            .await
-            .map_err(|e| anyhow::anyhow!("Failed to send DM: {e}"))?;
+            .await?;
 
-            // Wait for the DM to be sent from mostro
-            wait_for_dm(
-                &ctx.client,
-                &trade_keys,
-                request_id,
-                None,
-                Some(order),
-                &ctx.pool,
-            )
-            .await
-            .map_err(|e| anyhow::anyhow!("Failed to wait for DM: {e}"))?;
+            // Wait for incoming DM
+            let recv_event = wait_for_dm(ctx, Some(&trade_keys)).await?;
+            let messages = parse_dm_events(recv_event, &trade_keys, None).await;
+            if let Some(message) = messages.first() {
+                let message = message.0.get_inner_message_kind();
+                println!("Message: {:?}", message);
+                if message.request_id == Some(request_id) {
+                    let _ = print_commands_results(message, None, ctx).await;
+                }
+            }
         }
     }
-
     Ok(())
 }