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.56"
 lnurl-rs = "0.9.0"
 pretty_env_logger = "0.5.0"
 openssl = { version = "0.10.73", features = ["vendored"] }

README.md

@@ -4,52 +4,58 @@
 
 Very simple command line interface that show all new replaceable events from [Mostro](https://github.com/MostroP2P/mostro)
 
-## Requirements:
+## Requirements
 
 0. You need Rust version 1.64 or higher to compile.
 1. You will need a lightning network node
 
-## Install dependencies:
+## Install dependencies
 
 To compile on Ubuntu/Pop!\_OS, please install [cargo](https://www.rust-lang.org/tools/install), then run the following commands:
 
-```
-$ sudo apt update
-$ sudo apt install -y cmake build-essential pkg-config
+```bash
+sudo apt update
+sudo apt install -y cmake build-essential pkg-config
 ```
 
 ## Install
 
 To install you need to fill the env vars (`.env`) on the with your own private key and add a Mostro pubkey.
 
-```
-$ git clone https://github.com/MostroP2P/mostro-cli.git
-$ cd mostro-cli
-$ cp .env-sample .env
-$ cargo run
+```bash
+git clone https://github.com/MostroP2P/mostro-cli.git
+cd mostro-cli
+cp .env-sample .env
+cargo run
 ```
 
-# Usage
+## Usage
 
-```
+```bash
 Commands:
-  listorders       Requests open orders from Mostro pubkey
-  neworder         Create a new buy/sell order on Mostro
-  takesell         Take a sell order from a Mostro pubkey
-  takebuy          Take a buy order from a Mostro pubkey
-  addinvoice       Buyer add a new invoice to receive the payment
-  getdm            Get the latest direct messages from Mostro
-  fiatsent         Send fiat sent message to confirm payment to other user
-  release          Settle the hold invoice and pay to buyer
-  cancel           Cancel a pending order
-  rate             Rate counterpart after a successful trade
-  dispute          Start a dispute
-  admcancel        Cancel an order (only admin)
-  admsettle        Settle a seller's hold invoice (only admin)
-  admlistdisputes  Requests open disputes from Mostro pubkey
-  admaddsolver     Add a new dispute's solver (only admin)
-  admtakedispute   Admin or solver take a Pending dispute (only admin)
-  help             Print this message or the help of the given subcommand(s)
+  listorders         Requests open orders from Mostro pubkey
+  neworder           Create a new buy/sell order on Mostro
+  takesell           Take a sell order from a Mostro pubkey
+  takebuy            Take a buy order from a Mostro pubkey
+  addinvoice         Buyer add a new invoice to receive the payment
+  getdm              Get the latest direct messages
+  getadmindm         Get the latest direct messages for admin
+  senddm             Send direct message to a user
+  fiatsent           Send fiat sent message to confirm payment to other user
+  release            Settle the hold invoice and pay to buyer
+  cancel             Cancel a pending order
+  rate               Rate counterpart after a successful trade
+  restore            Restore session to recover all pending orders and disputes
+  dispute            Start a dispute
+  admcancel          Cancel an order (only admin)
+  admsettle          Settle a seller's hold invoice (only admin)
+  admlistdisputes    Requests open disputes from Mostro pubkey
+  admaddsolver       Add a new dispute's solver (only admin)
+  admtakedispute     Admin or solver take a Pending dispute (only admin)
+  admsenddm          Send gift wrapped direct message to a user (only admin)
+  conversationkey    Get the conversation key for direct messaging with a user
+  getlasttradeindex  Get last trade index of user
+  help               Print this message or the help of the given subcommand(s)
 
 Options:
   -v, --verbose
@@ -60,9 +66,9 @@ Options:
   -V, --version                      Print version
 ```
 
-# Examples
+## Examples
 
-```
+```bash
 $ mostro-cli -m npub1ykvsmrmw2hk7jgxgy64zr8tfkx4nnjhq9eyfxdlg3caha3ph0skq6jr3z0 -r 'wss://nos.lol,wss://relay.damus.io,wss://nostr-pub.wellorder.net,wss://nostr.mutinywallet.com,wss://relay.nostr.band,wss://nostr.cizmar.net,wss://140.f7z.io,wss://nostrrelay.com,wss://relay.nostrr.de' listorders
 
 # You can set the env vars to avoid the -m, -n and -r flags

src/cli.rs

@@ -4,6 +4,7 @@ pub mod conversation_key;
 pub mod dm_to_user;
 pub mod get_dm;
 pub mod get_dm_user;
+pub mod last_trade_index;
 pub mod list_disputes;
 pub mod list_orders;
 pub mod new_order;
@@ -20,6 +21,7 @@ use crate::cli::conversation_key::execute_conversation_key;
 use crate::cli::dm_to_user::execute_dm_to_user;
 use crate::cli::get_dm::execute_get_dm;
 use crate::cli::get_dm_user::execute_get_dm_user;
+use crate::cli::last_trade_index::execute_last_trade_index;
 use crate::cli::list_disputes::execute_list_disputes;
 use crate::cli::list_orders::execute_list_orders;
 use crate::cli::new_order::execute_new_order;
@@ -291,6 +293,8 @@ pub enum Commands {
         #[arg(short, long)]
         pubkey: String,
     },
+    /// Get last trade index of user
+    GetLastTradeIndex {},
 }
 
 fn get_env_var(cli: &Cli) {
@@ -415,9 +419,12 @@ impl Commands {
             | Commands::Release { order_id }
             | Commands::Dispute { order_id }
             | Commands::Cancel { order_id } => {
-                crate::util::run_simple_order_msg(self.clone(), order_id, ctx).await
+                crate::util::run_simple_order_msg(self.clone(), Some(*order_id), ctx).await
+            }
+            // Last trade index commands
+            Commands::GetLastTradeIndex {} => {
+                execute_last_trade_index(&ctx.identity_keys, ctx.mostro_pubkey, ctx).await
             }
-
             // DM commands with pubkey parsing
             Commands::SendDm {
                 pubkey,
@@ -489,11 +496,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,4 +1,4 @@
-use crate::util::{send_dm, wait_for_dm};
+use crate::util::{print_dm_events, send_dm, wait_for_dm};
 use crate::{cli::Context, db::Order, lightning::is_valid_invoice};
 use anyhow::Result;
 use lnurl::lightning_address::LightningAddress;
@@ -8,11 +8,14 @@ use std::str::FromStr;
 use uuid::Uuid;
 
 pub async fn execute_add_invoice(order_id: &Uuid, invoice: &str, ctx: &Context) -> Result<()> {
+    // Get order from order id
     let order = Order::get_by_id(&ctx.pool, &order_id.to_string()).await?;
+    // Get trade keys of specific order
     let trade_keys = order
         .trade_keys
         .clone()
         .ok_or(anyhow::anyhow!("Missing trade keys"))?;
+
     let order_trade_keys = Keys::parse(&trade_keys)?;
     println!(
         "Order trade keys: {:?}",
@@ -52,45 +55,22 @@ 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?;
+    // Send the DM
+    let sent_message = send_dm(
+        &ctx.client,
+        Some(&ctx.identity_keys),
+        &order_trade_keys,
+        &ctx.mostro_pubkey,
+        message_json,
+        None,
+        false,
+    );
 
-    // 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();
+    // Wait for the DM to be sent from mostro
+    let recv_event = wait_for_dm(ctx, Some(&order_trade_keys), sent_message).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),
-            &order_trade_keys,
-            &mostro_pubkey_clone,
-            message_json,
-            None,
-            false,
-        )
-        .await;
-    });
+    // Parse the incoming DM
+    print_dm_events(recv_event, request_id, ctx, Some(&order_trade_keys)).await?;
 
-    // Wait for the DM to be sent from mostro and update the order
-    wait_for_dm(
-        &ctx.client,
-        &order_trade_keys_clone,
-        request_id,
-        None,
-        Some(order),
-        &ctx.pool,
-    )
-    .await?;
     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/last_trade_index.rs

@@ -0,0 +1,60 @@
+use anyhow::Result;
+use mostro_core::prelude::*;
+use nostr_sdk::prelude::*;
+
+use crate::{
+    cli::Context,
+    parser::{dms::print_commands_results, parse_dm_events},
+    util::{send_dm, wait_for_dm},
+};
+
+pub async fn execute_last_trade_index(
+    identity_keys: &Keys,
+    mostro_key: PublicKey,
+    ctx: &Context,
+) -> Result<()> {
+    let kind = MessageKind::new(None, None, None, Action::LastTradeIndex, None);
+    let last_trade_index_message = Message::Restore(kind);
+    let message_json = last_trade_index_message
+        .as_json()
+        .map_err(|_| anyhow::anyhow!("Failed to serialize message"))?;
+
+    // Send the last trade index message to Mostro server
+    let sent_message = send_dm(
+        &ctx.client,
+        Some(identity_keys),
+        identity_keys,
+        &mostro_key,
+        message_json,
+        None,
+        false,
+    );
+
+    // Log the sent message
+    println!(
+        "Sent request to Mostro to get last trade index of user {}",
+        identity_keys.public_key()
+    );
+
+    // Wait for incoming DM
+    let recv_event = wait_for_dm(ctx, Some(identity_keys), sent_message).await?;
+
+    // Parse the incoming DM
+    let messages = parse_dm_events(recv_event, identity_keys, None).await;
+    if let Some((message, _, _)) = messages.first() {
+        let message = message.get_inner_message_kind();
+        if message.action == Action::LastTradeIndex {
+            print_commands_results(message, None, ctx).await?
+        } else {
+            return Err(anyhow::anyhow!(
+                "Received response with mismatched action. Expected: {:?}, Got: {:?}",
+                Action::LastTradeIndex,
+                message.action
+            ));
+        }
+    } else {
+        return Err(anyhow::anyhow!("No response received from Mostro"));
+    }
+
+    Ok(())
+}