KM Implementation on takesell and takebuy

src/cli/new_order.rs

@@ -141,24 +141,29 @@ pub async fn execute_new_order(
         false,
     )
     .await?;
-    let order_id = dm.iter()
+    let order_id = dm
+        .iter()
         .find_map(|el| {
             let message = el.0.get_inner_message_kind();
-            message.request_id
-                .filter(|&id| id == request_id)
-                .and_then(|_| message.payload.as_ref())
-                .and_then(|payload| {
-                    if let Payload::Order(order) = payload {
-                        order.id
-                    } else {
-                        None
-                    }
-                })
+            if message.request_id == Some(request_id) {
+                if let Some(Payload::Order(order)) = message.payload.as_ref() {
+                    return order.id;
+                }
+            }
+            None
         })
         .ok_or_else(|| anyhow::anyhow!("No matching order found in response"))?;
 
     println!("Order id {} created", order_id);
-    Order::save_new_id(&pool, db_order.id.clone().ok_or_else(|| anyhow::anyhow!("Missing order id"))?, order_id.to_string())
-        .await?;
+    Order::save_new_id(
+        &pool,
+        db_order
+            .id
+            .clone()
+            .ok_or(anyhow::anyhow!("Missing order id"))?,
+        order_id.to_string(),
+    )
+    .await?;
+
     Ok(())
 }

src/cli/take_buy.rs

@@ -4,7 +4,7 @@ use nostr_sdk::prelude::*;
 use uuid::Uuid;
 
 use crate::{
-    db::{connect, User},
+    db::{connect, Order, User},
     util::send_message_sync,
 };
 
@@ -22,17 +22,18 @@ pub async fn execute_take_buy(
         order_id,
         mostro_key.clone()
     );
+    let request_id = Uuid::new_v4().as_u128() as u64;
     let payload = amount.map(|amt: u32| Payload::Amount(amt as i64));
     // Create takebuy message
     let take_buy_message = Message::new_order(
         Some(*order_id),
-        None,
+        Some(request_id),
         Some(trade_index),
         Action::TakeBuy,
         payload,
     );
 
-    send_message_sync(
+    let dm = send_message_sync(
         client,
         Some(identity_keys),
         trade_keys,
@@ -44,6 +45,32 @@ pub async fn execute_take_buy(
     .await?;
 
     let pool = connect().await?;
+
+    let order = dm.iter().find_map(|el| {
+        let message = el.0.get_inner_message_kind();
+        if message.request_id == Some(request_id) {
+            if let Some(Payload::PaymentRequest(order, invoice, _)) = &message.payload {
+                println!(
+                    "Mostro sent you this hold invoice for order id: {}",
+                    order.as_ref().unwrap().id.unwrap()
+                );
+                println!();
+                println!("Pay this invoice to continue -->  {}", invoice);
+                println!();
+                return order.clone();
+            }
+        }
+        None
+    });
+    if let Some(o) = order {
+        match Order::new(&pool, o, trade_keys, Some(request_id as i64)).await {
+            Ok(order) => {
+                println!("Order {} created", order.id.unwrap());
+            }
+            Err(e) => println!("{}", e),
+        }
+    }
+
     // Update last trade index
     let mut user = User::get(&pool).await.unwrap();
     user.set_last_trade_index(trade_index);

src/cli/take_sell.rs

@@ -5,7 +5,7 @@ use nostr_sdk::prelude::*;
 use std::str::FromStr;
 use uuid::Uuid;
 
-use crate::db::{connect, User};
+use crate::db::{connect, Order, User};
 use crate::lightning::is_valid_invoice;
 use crate::util::send_message_sync;
 
@@ -49,16 +49,17 @@ pub async fn execute_take_sell(
             _ => None,
         };
     }
+    let request_id = Uuid::new_v4().as_u128() as u64;
     // Create takesell message
     let take_sell_message = Message::new_order(
         Some(*order_id),
-        None,
+        Some(request_id),
         Some(trade_index),
         Action::TakeSell,
         payload,
     );
 
-    send_message_sync(
+    let dm = send_message_sync(
         client,
         Some(identity_keys),
         trade_keys,
@@ -68,8 +69,25 @@ pub async fn execute_take_sell(
         false,
     )
     .await?;
-
     let pool = connect().await?;
+
+    let order = dm.iter().find_map(|el| {
+        let message = el.0.get_inner_message_kind();
+        if message.request_id == Some(request_id) {
+            if let Some(Payload::Order(order)) = message.payload.as_ref() {
+                return Some(order.clone());
+            }
+        }
+        None
+    });
+    if let Some(order) = order {
+        match Order::new(&pool, order, trade_keys, Some(request_id as i64)).await {
+            Ok(order) => {
+                println!("Order {} created", order.id.unwrap());
+            }
+            Err(e) => println!("{}", e),
+        }
+    }
     // Update last trade index
     let mut user = User::get(&pool).await.unwrap();
     user.set_last_trade_index(trade_index);

src/db.rs

@@ -227,8 +227,12 @@ impl Order {
         request_id: Option<i64>,
     ) -> Result<Self, Box<dyn std::error::Error>> {
         let trade_keys_hex = trade_keys.secret_key().to_secret_hex();
+        let id = match order.id {
+            Some(id) => id.to_string(),
+            None => uuid::Uuid::new_v4().to_string(),
+        };
         let order = Order {
-            id: Some(uuid::Uuid::new_v4().to_string()),
+            id: Some(id),
             kind: order.kind.as_ref().map(|k| k.to_string()),
             status: order.status.as_ref().map(|s| s.to_string()),
             amount: order.amount,

src/util.rs

@@ -7,7 +7,7 @@ use base64::Engine;
 use dotenvy::var;
 use log::{error, info};
 use mostro_core::dispute::Dispute;
-use mostro_core::message::{Message, Payload};
+use mostro_core::message::Message;
 use mostro_core::order::Kind as MostroKind;
 use mostro_core::order::{SmallOrder, Status};
 use mostro_core::NOSTR_REPLACEABLE_EVENT_KIND;
@@ -82,10 +82,9 @@ pub async fn send_message_sync(
     trade_keys: &Keys,
     receiver_pubkey: PublicKey,
     message: Message,
-    wait_for_dm_ans: bool,
+    wait_for_dm: bool,
     to_user: bool,
 ) -> Result<Vec<(Message, u64)>> {
-    let mut dm: Vec<(Message, u64)> = Vec::new();
     let message_json = message.as_json()?;
     // Send dm to receiver pubkey
     println!(
@@ -101,25 +100,15 @@ pub async fn send_message_sync(
         to_user,
     )
     .await?;
-    sleep(Duration::from_secs(1));
-
-    if wait_for_dm_ans {
-        dm = get_direct_messages(client, trade_keys, 1, to_user).await;
-        for el in dm.iter() {
-            if let Some(Payload::PaymentRequest(ord, inv, _)) =
-                &el.0.get_inner_message_kind().payload
-            {
-                println!("NEW MESSAGE:");
-                println!(
-                    "Mostro sent you this hold invoice for order id: {}",
-                    ord.as_ref().unwrap().id.unwrap()
-                );
-                println!();
-                println!("Pay this invoice to continue -->  {}", inv);
-                println!();
-            }
-        }
-    }
+    // FIXME: This is a hack to wait for the DM to be sent
+    sleep(Duration::from_secs(2));
+
+    let dm: Vec<(Message, u64)> = if wait_for_dm {
+        get_direct_messages(client, trade_keys, 15, to_user).await
+    } else {
+        Vec::new()
+    };
+
     Ok(dm)
 }