Include dispute initiator in Nostr dispute events

src/app/admin_cancel.rs

@@ -72,6 +72,13 @@ pub async fn admin_cancel_action(
     // we check if there is a dispute
     let dispute = find_dispute_by_order_id(pool, order.id).await;
 
+    // Get the creator of the dispute
+    let dispute_initiator = match (order.seller_dispute, order.buyer_dispute) {
+        (true, false) => "seller",
+        (false, true) => "buyer",
+        (_, _) => return Err(MostroInternalErr(ServiceError::DisputeEventError)),
+    };
+
     if let Ok(mut d) = dispute {
         let dispute_id = d.id;
         // we update the dispute
@@ -85,6 +92,11 @@ pub async fn admin_cancel_action(
                 TagKind::Custom(Cow::Borrowed("s")),
                 vec![DisputeStatus::SellerRefunded.to_string()],
             ),
+            // Who is the dispute creator
+            Tag::custom(
+                TagKind::Custom(std::borrow::Cow::Borrowed("initiator")),
+                vec![dispute_initiator],
+            ),
             Tag::custom(
                 TagKind::Custom(Cow::Borrowed("y")),
                 vec!["mostro".to_string()],
@@ -98,6 +110,9 @@ pub async fn admin_cancel_action(
         let event = new_event(my_keys, "", dispute_id.to_string(), tags)
             .map_err(|e| MostroInternalErr(ServiceError::NostrError(e.to_string())))?;
 
+        // Publish dispute event with update
+        info!("Dispute event to be published: {event:#?}");
+
         match get_nostr_client() {
             Ok(client) => {
                 if let Err(e) = client.send_event(&event).await {

src/app/admin_settle.rs

@@ -48,7 +48,7 @@ pub async fn admin_settle_action(
         _ => {}
     }
 
-    // Was orde cooperatively cancelled?
+    // Was order cooperatively cancelled?
     if order.check_status(Status::CooperativelyCanceled).is_ok() {
         enqueue_order_msg(
             request_id,
@@ -85,12 +85,25 @@ pub async fn admin_settle_action(
         d.update(pool)
             .await
             .map_err(|e| MostroInternalErr(ServiceError::DbAccessError(e.to_string())))?;
+
+        // Get the creator of the dispute
+        let dispute_initiator = match (order.seller_dispute, order.buyer_dispute) {
+            (true, false) => "seller",
+            (false, true) => "buyer",
+            (_, _) => return Err(MostroInternalErr(ServiceError::DisputeEventError)),
+        };
+
         // We create a tag to show status of the dispute
         let tags: Tags = Tags::from_list(vec![
             Tag::custom(
                 TagKind::Custom(std::borrow::Cow::Borrowed("s")),
                 vec![DisputeStatus::Settled.to_string()],
             ),
+            // Who is the dispute creator
+            Tag::custom(
+                TagKind::Custom(std::borrow::Cow::Borrowed("initiator")),
+                vec![dispute_initiator],
+            ),
             Tag::custom(
                 TagKind::Custom(std::borrow::Cow::Borrowed("y")),
                 vec!["mostro".to_string()],
@@ -105,6 +118,9 @@ pub async fn admin_settle_action(
         let event = new_event(my_keys, "", dispute_id.to_string(), tags)
             .map_err(|e| MostroInternalErr(ServiceError::NostrError(e.to_string())))?;
 
+        // Print event dispute with update
+        tracing::info!("Dispute event to be published: {event:#?}");
+
         match get_nostr_client() {
             Ok(client) => {
                 if let Err(e) = client.send_event(&event).await {

src/app/admin_take_dispute.rs

@@ -211,12 +211,24 @@ pub async fn admin_take_dispute_action(
     .await
     .map_err(|e| MostroInternalErr(ServiceError::NostrError(e.to_string())))?;
 
+    // Get the creator of the dispute
+    let dispute_initiator = match (order.seller_dispute, order.buyer_dispute) {
+        (true, false) => "seller",
+        (false, true) => "buyer",
+        (_, _) => return Err(MostroInternalErr(ServiceError::DisputeEventError)),
+    };
+
     // We create a tag to show status of the dispute
     let tags: Tags = Tags::from_list(vec![
         Tag::custom(
             TagKind::Custom(std::borrow::Cow::Borrowed("s")),
             vec![Status::InProgress.to_string()],
         ),
+        // Who is the dispute creator
+        Tag::custom(
+            TagKind::Custom(std::borrow::Cow::Borrowed("initiator")),
+            vec![dispute_initiator],
+        ),
         Tag::custom(
             TagKind::Custom(std::borrow::Cow::Borrowed("y")),
             vec!["mostro".to_string()],

src/app/dispute.rs

@@ -15,16 +15,31 @@ use uuid::Uuid;
 
 /// Publishes a dispute event to the Nostr network.
 ///
-/// Creates and publishes a NIP-33 replaceable event containing dispute details
-/// including status and application metadata.
-async fn publish_dispute_event(dispute: &Dispute, my_keys: &Keys) -> Result<(), MostroError> {
+/// Creates and publishes a NIP-33 replaceable event containing dispute details,
+/// including status, initiator (`buyer` or `seller`), and application metadata.
+async fn publish_dispute_event(
+    dispute: &Dispute,
+    my_keys: &Keys,
+    is_buyer_dispute: bool,
+) -> Result<(), MostroError> {
+    // Create initiator string
+    let initiator = match is_buyer_dispute {
+        true => "buyer",
+        false => "seller",
+    };
+
     // Create tags for the dispute event
     let tags = Tags::from_list(vec![
         // Status tag - indicates the current state of the dispute
         Tag::custom(
             TagKind::Custom(Cow::Borrowed("s")),
             vec![dispute.status.to_string()],
         ),
+        // Who is the dispute creator
+        Tag::custom(
+            TagKind::Custom(Cow::Borrowed("initiator")),
+            vec![initiator.to_string()],
+        ),
         // Application identifier tag
         Tag::custom(
             TagKind::Custom(Cow::Borrowed("y")),
@@ -218,7 +233,7 @@ pub async fn dispute_action(
     .await?;
 
     // Publish dispute event to network
-    publish_dispute_event(&dispute, my_keys)
+    publish_dispute_event(&dispute, my_keys, is_buyer_dispute)
         .await
         .map_err(|_| MostroInternalErr(ServiceError::DisputeEventError))?;