Enhance chat and market integration with message forwarding

- Make ChatService globally available for other modules, enabling market-related message handling.
- Introduce a market message handler in ChatService to process market-related direct messages (DMs).
- Update useMarket to register the market message handler with ChatService, streamlining order-related DM processing.
- Refactor message handling logic to differentiate between market messages and regular chat messages, improving message management.
- Enhance order update logging in nostrmarketService for better debugging and verification of order status.

src/modules/chat/index.ts

@@ -35,6 +35,9 @@ export const chatModule: ModulePlugin = {
     const chatService = new ChatService(config)
     container.provide(CHAT_SERVICE_TOKEN, chatService)
     
+    // Also make it globally available for other modules (like market)
+    ;(globalThis as any).chatService = chatService
+
     // Register global components
     app.component('ChatComponent', ChatComponent)
 

src/modules/chat/services/chat-service.ts

@@ -15,6 +15,7 @@ export class ChatService {
   private config: ChatConfig
   private subscriptionUnsubscriber?: () => void
   private isInitialized = ref(false)
+  private marketMessageHandler?: (event: any) => Promise<void>
 
   constructor(config: ChatConfig) {
     this.config = config
@@ -24,6 +25,11 @@ export class ChatService {
     this.deferredInitialization()
   }
 
+  // Register market message handler for forwarding market-related DMs
+  setMarketMessageHandler(handler: (event: any) => Promise<void>) {
+    this.marketMessageHandler = handler
+  }
+
   // Defer initialization until services are ready
   private deferredInitialization(): void {
     // Try initialization immediately
@@ -511,22 +517,45 @@ export class ChatService {
             // Decrypt the message
             const decryptedContent = await nip04.decrypt(userPrivkey, senderPubkey, event.content)
 
-            // Create a chat message
+            // Check if this is a market-related message (JSON with type field)
-            const message: ChatMessage = {
+            let isMarketMessage = false
-              id: event.id,
+            try {
-              content: decryptedContent,
+              const parsedContent = JSON.parse(decryptedContent)
-              created_at: event.created_at,
+              if (parsedContent && typeof parsedContent.type === 'number' && (parsedContent.type === 1 || parsedContent.type === 2)) {
-              sent: false,
+                // This is a market message (payment request type 1 or status update type 2)
-              pubkey: senderPubkey
+                isMarketMessage = true
+                console.log('🛒 Forwarding market message to market handler:', parsedContent.type)
+                
+                // Forward to market handler
+                if (this.marketMessageHandler) {
+                  await this.marketMessageHandler(event)
+                } else {
+                  console.warn('Market message handler not available, message will be treated as chat')
+                }
+              }
+            } catch (e) {
+              // Not JSON or not a market message, treat as regular chat
             }
 
-            // Ensure we have a peer record for the sender
+            // Only process as chat message if it's not a market message
-            this.addPeer(senderPubkey)
+            if (!isMarketMessage) {
+              // Create a chat message
+              const message: ChatMessage = {
+                id: event.id,
+                content: decryptedContent,
+                created_at: event.created_at,
+                sent: false,
+                pubkey: senderPubkey
+              }
 
-            // Add the message
+              // Ensure we have a peer record for the sender
-            this.addMessage(senderPubkey, message)
+              this.addPeer(senderPubkey)
 
-            console.log('Received encrypted message from:', senderPubkey.slice(0, 8))
+              // Add the message
+              this.addMessage(senderPubkey, message)
+
+              console.log('Received encrypted chat message from:', senderPubkey.slice(0, 8))
+            }
 
           } catch (error) {
             console.error('Failed to decrypt incoming message:', error)

src/modules/market/composables/useMarket.ts

@@ -28,6 +28,22 @@ export function useMarket() {
     throw new Error('AuthService not available. Make sure base module is installed.')
   }
 
+  // Register market DM handler with chat service (if available)
+  const registerMarketMessageHandler = () => {
+    try {
+      // Try to get the chat service (it might not be available if chat module isn't loaded)
+      const chatService = (globalThis as any).chatService
+      if (chatService && chatService.setMarketMessageHandler) {
+        chatService.setMarketMessageHandler(handleOrderDM)
+        console.log('🛒 Registered market message handler with chat service')
+      } else {
+        console.log('🛒 Chat service not available, market will use its own DM subscription')
+      }
+    } catch (error) {
+      console.log('🛒 Could not register with chat service:', error)
+    }
+  }
+
   // State
   const isLoading = ref(false)
   const error = ref<Error | null>(null)
@@ -403,12 +419,14 @@ export function useMarket() {
       // Handle different types of messages
       switch (messageData.type) {
         case 1: // Payment request
-          console.log('💰 Processing payment request')
+          console.log('💰 Processing payment request for order:', messageData.id)
           await nostrmarketService.handlePaymentRequest(messageData)
+          console.log('✅ Payment request processed successfully')
           break
         case 2: // Order status update  
-          console.log('📦 Processing order status update')
+          console.log('📦 Processing order status update for order:', messageData.id)
           await nostrmarketService.handleOrderStatusUpdate(messageData)
+          console.log('✅ Order status update processed successfully')
           break
         default:
           console.log('❓ Unknown message type:', messageData.type)
@@ -558,6 +576,9 @@ export function useMarket() {
 
       console.log('🛒 Market connected successfully')
       
+      // Register market message handler with chat service
+      registerMarketMessageHandler()
+      
       // Load market data
       console.log('🛒 Loading basic market data...')
       // TODO: Confirm if this should use nostrStore.account?.pubkey or authService.user.value?.pubkey
@@ -580,9 +601,8 @@ export function useMarket() {
       console.log('🛒 Subscribing to market updates...')
       subscribeToMarketUpdates()
       
-      // Subscribe to order-related DMs
+      // Note: Order-related DMs are now handled by chat service forwarding
-      console.log('🛒 Subscribing to order updates...')
+      // No need for separate subscription
-      subscribeToOrderUpdates()
 
     } catch (err) {
       console.error('🛒 Failed to connect to market:', err)

src/modules/market/services/nostrmarketService.ts

@@ -377,6 +377,16 @@ export class NostrmarketService {
         paymentStatus: updatedOrder.paymentStatus,
         hasQRCode: !!updatedOrder.qrCodeDataUrl
       })
+      
+      // Debug: Check if the order was actually updated in the store
+      const verifyOrder = Object.values(marketStore.orders).find(o => 
+        o.id === paymentRequest.id || o.originalOrderId === paymentRequest.id
+      )
+      console.log('Verified order in store after update:', {
+        found: !!verifyOrder,
+        hasPaymentRequest: !!verifyOrder?.paymentRequest,
+        paymentStatus: verifyOrder?.paymentStatus
+      })
     } else {
       console.warn('Payment request received for unknown order:', paymentRequest.id)
     }

src/modules/market/stores/market.ts

@@ -641,9 +641,26 @@ export const useMarketStore = defineStore('market', () => {
   const updateOrder = (orderId: string, updatedOrder: Partial<Order>) => {
     const order = orders.value[orderId]
     if (order) {
-      Object.assign(order, updatedOrder)
+      // Create a completely new order object to ensure reactivity
-      order.updatedAt = Date.now() / 1000
+      const newOrder = {
+        ...order,
+        ...updatedOrder,
+        updatedAt: Date.now() / 1000
+      }
+      
+      // Replace the entire order object to trigger reactivity
+      orders.value[orderId] = newOrder
+      
+      console.log('🔄 Order updated in store:', {
+        orderId,
+        hasPaymentRequest: !!newOrder.paymentRequest,
+        status: newOrder.status,
+        paymentStatus: newOrder.paymentStatus
+      })
+      
       saveOrdersToStorage()
+    } else {
+      console.warn('updateOrder: Order not found:', orderId)
     }
   }