feat(transport): Phase 2 — protocol-v2 (NIP-44 direct) selection

Phase 2 of docs/TRANSPORT_V2_SPEC.md — the CLI can now speak the node's wire
transport (protocol v1 gift wrap, kind 1059, or protocol v2 NIP-44 direct,
kind 14), enabling trading against a `transport = "nip44"` node and exercising
the daemon's anti-spam gates (MostroP2P/mostro#780).

- Config: `--transport <gift-wrap|nip44>` (-t) sets a TRANSPORT env var,
  resolved via `messaging::parse_transport_env()` (default gift-wrap →
  wire-identical to today). Read from the env like POW/SECRET already are, so
  send_dm's signature and its ~14 callers are untouched.
- Send: send_dm / send_plain_text_dm route through a new `publish_wrapped` →
  `wrap_message_with(transport, …)`, replacing the hard-wired `wrap_message`.
  The NIP-17 peer-chat path (to_user) is untouched.
- Receive: `wait_for_dm` subscribes on `transport.event_kind()` and matches it
  in the notification loop; on v2 it additionally pins `author = mostro_pubkey`
  so a Mostro reply is never confused with NIP-17 peer chat (same kind 14).
- Unwrap: `parse_dm_events` gains `mostro_protocol: bool` — true → decode via
  `unwrap_incoming` (dispatches on kind 1059/14); false → NIP-17 peer-chat
  path. All Mostro-reply / Mostro→user-DM call sites pass true; the one
  peer-chat listing passes false.

Tests: Transport::from_str→event_kind mapping; a wrap_message_with(Nip44Direct)
→ unwrap_incoming roundtrip (kind 14, author = trade key, message round-trips).
Full suite green; clippy --all-targets --all-features and fmt clean.

Known gap (Phase 3): the get-dm historical-listing filter still hard-codes
gift wrap, so listing past Mostro DMs on a v2 node returns nothing. The
interactive request/response path (what exercises the anti-spam gate) is fully
v2.

Based on the mostro-core 0.13.0 bump (Phase 1, #176).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: grunch

docs/TRANSPORT_V2_SPEC.md

@@ -1,6 +1,6 @@
 # mostro-cli — Transport v2 (NIP-44 Direct) client support
 
-**Status:** Phase 1 implemented · Phases 2–3 pending
+**Status:** Phases 1–2 implemented · Phase 3 pending
 **Daemon spec:** `MostroP2P/mostro` → `docs/TRANSPORT_V2_SPEC.md`
 **Issue:** [#626 — Messaging Transport Abstraction Layer](https://github.com/MostroP2P/mostro/issues/626)
 **Core:** `transport` module shipped in **mostro-core 0.13.0**
@@ -93,32 +93,50 @@ Acceptance: `cargo build`, `cargo test`, `cargo clippy --all-targets
 --all-features`, `cargo fmt --check` all clean; behaviour identical to before
 against a gift-wrap node.
 
-### Phase 2 — Transport selection (v2 capability) — PENDING
-
-Teach the CLI to send and receive on either transport, selected explicitly.
-
-- **Config:** a `TRANSPORT` env var / `--transport <gift-wrap|nip44>` flag,
-  parsed into `Transport` (default `gift-wrap` — wire-identical to today).
-  Mirrors the daemon's `[mostro] transport` knob. Store it on `Context`.
-- **Send:** route the Mostro-protocol path of `send_dm` through
-  `wrap_message_with(ctx.transport, …)` instead of the hard-wired
-  `wrap_message`. The NIP-17 peer-chat path (`to_user`) is untouched.
-- **Receive:** replace the hard-coded `Kind::GiftWrap` filter in `wait_for_dm`
-  (and the notification-loop kind check) with `ctx.transport.event_kind()`.
-  For v2, additionally constrain the filter to `author = mostro_pubkey` so the
-  Mostro reply is not confused with NIP-17 peer chat on the same kind.
-- **Unwrap:** `parse_dm_events` calls `unwrap_incoming` instead of
-  `unwrap_message`, so it transparently handles whichever kind arrived.
-- **Blast radius:** the ~12 command call sites of `send_dm` thread
-  `ctx.transport` through; no per-command logic changes.
-
-Acceptance: against a `transport = "nip44"` daemon, a full
-`new-order → take → add-invoice → fiat-sent → release` round-trips; against a
-gift-wrap daemon, behaviour is unchanged. This is the phase that lets us test
-the daemon's Phase 2 anti-spam gates.
+### Phase 2 — Transport selection (v2 capability) — IMPLEMENTED
+
+Teaches the CLI to send and receive on either transport, selected explicitly.
+
+- **Config:** a `--transport <gift-wrap|nip44>` flag (`-t`) that sets a
+  `TRANSPORT` env var, resolved via `messaging::parse_transport_env()` into
+  `Transport` (default `gift-wrap` — wire-identical to today). This mirrors how
+  `POW` / `SECRET` are already read from the environment rather than threaded
+  through every call site, so `send_dm`'s signature (and its ~14 callers) is
+  untouched. Mirrors the daemon's `[mostro] transport` knob.
+- **Send:** the Mostro-protocol path of `send_dm` / `send_plain_text_dm` goes
+  through a new `publish_wrapped` → `wrap_message_with(transport, …)`,
+  replacing the hard-wired `wrap_message`. The NIP-17 peer-chat path
+  (`to_user`) is untouched.
+- **Receive:** `wait_for_dm` subscribes on `transport.event_kind()` (and its
+  notification loop matches that kind). For v2 it additionally pins
+  `author = mostro_pubkey` so the Mostro reply is never confused with NIP-17
+  peer chat on the same kind 14.
+- **Unwrap:** `parse_dm_events` gains a `mostro_protocol: bool`; when `true` it
+  decodes via `unwrap_incoming` (dispatches on kind: 1059 / 14), when `false`
+  it keeps the NIP-17 peer-chat path. All Mostro-reply / Mostro→user-DM call
+  sites pass `true`; the one peer-chat listing call passes `false`.
+
+Tests: `Transport::from_str` → `event_kind` mapping, and a
+`wrap_message_with(Nip44Direct) → unwrap_incoming` roundtrip (kind 14, author =
+trade key, message round-trips). Full suite green; clippy + fmt clean.
+
+Known gap (deferred to Phase 3): the `get-dm` **historical listing** filter
+(`create_filter` for the `DirectMessages*` kinds) still hard-codes gift wrap,
+so listing past Mostro DMs on a v2 node returns nothing. The interactive
+request/response path (the one that exercises the daemon's anti-spam gate) is
+fully v2.
+
+Acceptance: against a `transport = "nip44"` daemon, run the CLI with
+`--transport nip44` and a full `new-order → take → add-invoice → fiat-sent →
+release` round-trips; against a gift-wrap daemon (default), behaviour is
+unchanged. This is the phase that lets us test the daemon's Phase 2 anti-spam
+gates.
 
 ### Phase 3 — Capability auto-detection + docs/UX — PENDING
 
+- Make the `get-dm` historical-listing filter transport-aware
+  (`create_filter` for the `DirectMessages*` kinds: kind 14 + `author =
+  mostro_pubkey` on v2), closing the Phase 2 known gap.
 - Read the node's `protocol_versions` tag from its kind-`38385` info event
   (same fetch path as the existing `pow` probe) and, when `--transport` is not
   given, auto-select the matching transport — warning on a mismatch

src/cli.rs

@@ -92,6 +92,11 @@ pub struct Cli {
     pub pow: Option<String>,
     #[arg(short, long)]
     pub secret: bool,
+    /// Wire transport to speak to the node: "gift-wrap" (protocol v1, default)
+    /// or "nip44" (protocol v2). Must match the node's `transport` setting
+    /// (advertised on its kind-38385 info event). See docs/TRANSPORT_V2_SPEC.md.
+    #[arg(short, long)]
+    pub transport: Option<String>,
 }
 
 #[derive(Subcommand, Clone)]
@@ -371,6 +376,10 @@ fn get_env_var(cli: &Cli) {
     if cli.secret {
         set_var("SECRET", "true");
     }
+
+    if let Some(ref transport) = cli.transport {
+        set_var("TRANSPORT", transport.clone());
+    }
 }
 
 // Check range with two values value

src/cli/last_trade_index.rs

@@ -48,7 +48,7 @@ pub async fn execute_last_trade_index(
     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;
+    let messages = parse_dm_events(recv_event, identity_keys, None, true).await;
     if let Some((message, _, _)) = messages.first() {
         let message = message.get_inner_message_kind();
         if message.action == Action::LastTradeIndex {

src/cli/orders_info.rs

@@ -52,7 +52,8 @@ pub async fn execute_orders_info(order_ids: &[Uuid], ctx: &Context) -> Result<()
     let recv_event = wait_for_dm(ctx, Some(&ctx.identity_keys), sent_message).await?;
 
     // Parse the incoming DM and handle the response
-    let messages = crate::parser::dms::parse_dm_events(recv_event, &ctx.identity_keys, None).await;
+    let messages =
+        crate::parser::dms::parse_dm_events(recv_event, &ctx.identity_keys, None, true).await;
     if let Some((message, _, _)) = messages.first() {
         let message_kind = message.get_inner_message_kind();
 

src/cli/restore.rs

@@ -57,7 +57,7 @@ pub async fn execute_restore(
     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;
+    let messages = parse_dm_events(recv_event, identity_keys, None, true).await;
     if let Some((message, _, _)) = messages.first() {
         let message = message.get_inner_message_kind();
         if message.action == Action::RestoreSession {

src/cli/send_msg.rs

@@ -131,7 +131,7 @@ pub async fn execute_send_msg(
                         .client
                         .fetch_events(subscription, FETCH_EVENTS_TIMEOUT)
                         .await?;
-                    let messages = parse_dm_events(events, &next_trade_key, Some(&2)).await;
+                    let messages = parse_dm_events(events, &next_trade_key, Some(&2), true).await;
                     if !messages.is_empty() {
                         for (message, _, _) in messages {
                             let message_kind = message.get_inner_message_kind();

src/cli/take_dispute.rs

@@ -112,7 +112,7 @@ pub async fn execute_admin_cancel_dispute(
             )
         })?;
 
-    let messages = parse_dm_events(recv_event, admin_keys, None).await;
+    let messages = parse_dm_events(recv_event, admin_keys, None, true).await;
     let (message, _, sender_pubkey) = messages
         .first()
         .ok_or_else(|| anyhow::anyhow!("No response received from Mostro"))?;
@@ -204,7 +204,7 @@ pub async fn execute_admin_settle_dispute(
             )
         })?;
 
-    let messages = parse_dm_events(recv_event, admin_keys, None).await;
+    let messages = parse_dm_events(recv_event, admin_keys, None, true).await;
     let (message, _, sender_pubkey) = messages
         .first()
         .ok_or_else(|| anyhow::anyhow!("No response received from Mostro"))?;
@@ -277,7 +277,7 @@ pub async fn execute_take_dispute(dispute_id: &Uuid, ctx: &Context) -> Result<()
     let recv_event = wait_for_dm(ctx, Some(admin_keys), sent_message).await?;
 
     // Parse the incoming DM
-    let messages = parse_dm_events(recv_event, admin_keys, None).await;
+    let messages = parse_dm_events(recv_event, admin_keys, None, true).await;
     if let Some((message, _, sender_pubkey)) = messages.first() {
         let message_kind = message.get_inner_message_kind();
         if *sender_pubkey != ctx.mostro_pubkey {

src/parser/dms.rs

@@ -876,10 +876,25 @@ pub async fn print_commands_results(message: &MessageKind, ctx: &Context) -> Res
     }
 }
 
+/// Parse a batch of incoming events into `(Message, created_at, sender)`.
+///
+/// `mostro_protocol` selects how each event is decoded:
+/// - `true` — Mostro-protocol messages: route every event through
+///   mostro-core's [`unwrap_incoming`], which dispatches on the event kind
+///   (1059 gift wrap, v1 / 14 NIP-44 direct, v2) and returns the same
+///   `UnwrappedMessage`. This is the receive path for replies to commands and
+///   for Mostro→user DM listings.
+/// - `false` — NIP-17 peer-to-peer chat: kind-14 events are decrypted with the
+///   trade↔peer conversation key (these are *not* Mostro-protocol messages and
+///   carry a bare `Message`, not the v2 tuple).
+///
+/// Keeping the two explicit avoids misparsing peer chat as a Mostro message on
+/// the v2 transport, where both share kind 14 (see docs/TRANSPORT_V2_SPEC.md).
 pub async fn parse_dm_events(
     events: Events,
     pubkey: &Keys,
     since: Option<&i64>,
+    mostro_protocol: bool,
 ) -> Vec<(Message, u64, PublicKey)> {
     let mut id_set = HashSet::<EventId>::new();
     let mut direct_messages: Vec<(Message, u64, PublicKey)> = Vec::new();
@@ -890,49 +905,61 @@ pub async fn parse_dm_events(
             continue;
         }
 
-        let (created_at, message, sender) = match dm.kind {
-            nostr_sdk::Kind::GiftWrap => match unwrap_message(dm, pubkey).await {
+        let (created_at, message, sender) = if mostro_protocol {
+            match unwrap_incoming(dm, pubkey).await {
                 Ok(Some(u)) => (u.created_at, u.message, u.sender),
-                Ok(None) => continue, // outer NIP-44 failed → not addressed to us
+                Ok(None) => continue, // decrypt failed → not addressed to us
                 Err(e) => {
-                    eprintln!("Warning: could not unwrap gift wrap (event {}): {e}", dm.id);
+                    eprintln!("Warning: could not unwrap message (event {}): {e}", dm.id);
                     continue;
                 }
-            },
-            nostr_sdk::Kind::PrivateDirectMessage => {
-                let ck = if let Ok(ck) = ConversationKey::derive(pubkey.secret_key(), &dm.pubkey) {
-                    ck
-                } else {
-                    continue;
-                };
-                let b64decoded_content =
-                    match general_purpose::STANDARD.decode(dm.content.as_bytes()) {
-                        Ok(b64decoded_content) => b64decoded_content,
+            }
+        } else {
+            match dm.kind {
+                nostr_sdk::Kind::GiftWrap => match unwrap_message(dm, pubkey).await {
+                    Ok(Some(u)) => (u.created_at, u.message, u.sender),
+                    Ok(None) => continue, // outer NIP-44 failed → not addressed to us
+                    Err(e) => {
+                        eprintln!("Warning: could not unwrap gift wrap (event {}): {e}", dm.id);
+                        continue;
+                    }
+                },
+                nostr_sdk::Kind::PrivateDirectMessage => {
+                    let ck =
+                        if let Ok(ck) = ConversationKey::derive(pubkey.secret_key(), &dm.pubkey) {
+                            ck
+                        } else {
+                            continue;
+                        };
+                    let b64decoded_content =
+                        match general_purpose::STANDARD.decode(dm.content.as_bytes()) {
+                            Ok(b64decoded_content) => b64decoded_content,
+                            Err(_) => {
+                                continue;
+                            }
+                        };
+                    let unencrypted_content = match decrypt_to_bytes(&ck, &b64decoded_content) {
+                        Ok(bytes) => bytes,
                         Err(_) => {
                             continue;
                         }
                     };
-                let unencrypted_content = match decrypt_to_bytes(&ck, &b64decoded_content) {
-                    Ok(bytes) => bytes,
-                    Err(_) => {
-                        continue;
-                    }
-                };
-                let message_str = match String::from_utf8(unencrypted_content) {
-                    Ok(s) => s,
-                    Err(_) => {
-                        continue;
-                    }
-                };
-                let message = match Message::from_json(&message_str) {
-                    Ok(m) => m,
-                    Err(_) => {
-                        continue;
-                    }
-                };
-                (dm.created_at, message, dm.pubkey)
+                    let message_str = match String::from_utf8(unencrypted_content) {
+                        Ok(s) => s,
+                        Err(_) => {
+                            continue;
+                        }
+                    };
+                    let message = match Message::from_json(&message_str) {
+                        Ok(m) => m,
+                        Err(_) => {
+                            continue;
+                        }
+                    };
+                    (dm.created_at, message, dm.pubkey)
+                }
+                _ => continue,
             }
-            _ => continue,
         };
         // check if the message is older than the since time if it is, skip it
         if let Some(since_time) = since {

src/util/events.rs

@@ -192,7 +192,8 @@ pub async fn fetch_events_list(
                 .client
                 .fetch_events(filters, FETCH_EVENTS_TIMEOUT)
                 .await?;
-            let direct_messages_mostro = parse_dm_events(fetched_events, admin_keys, since).await;
+            let direct_messages_mostro =
+                parse_dm_events(fetched_events, admin_keys, since, true).await;
             Ok(direct_messages_mostro
                 .into_iter()
                 .map(|(message, timestamp, sender_pubkey)| {
@@ -213,8 +214,10 @@ pub async fn fetch_events_list(
                     .client
                     .fetch_events(filter, FETCH_EVENTS_TIMEOUT)
                     .await?;
+                // NIP-17 peer-to-peer chat (not Mostro-protocol): decode with
+                // the trade↔peer conversation key.
                 let direct_messages_for_trade_key =
-                    parse_dm_events(fetched_user_messages, &trade_key, since).await;
+                    parse_dm_events(fetched_user_messages, &trade_key, since, false).await;
                 // Extend the direct messages
                 direct_messages.extend(direct_messages_for_trade_key);
             }
@@ -233,8 +236,9 @@ pub async fn fetch_events_list(
                     .client
                     .fetch_events(filter, FETCH_EVENTS_TIMEOUT)
                     .await?;
+                // Mostro→user DMs (gift wrap, v1): Mostro-protocol messages.
                 let direct_messages_for_trade_key =
-                    parse_dm_events(fetched_user_messages, &trade_key, since).await;
+                    parse_dm_events(fetched_user_messages, &trade_key, since, true).await;
                 // Extend the direct messages
                 direct_messages.extend(direct_messages_for_trade_key);
             }