@bsv/message-box-client 2.0.2 → 2.0.4

package/mod.ts

@@ -1,3 +1,4 @@
 export * from './src/MessageBoxClient.js'
 export * from './src/PeerPayClient.js'
 export * from './src/types.js'
+export * from './src/RemittanceAdapter.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/message-box-client",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "publishConfig": {
     "access": "public"
   },

package/src/MessageBoxClient.ts

@@ -96,6 +96,8 @@ export class MessageBoxClient {
   private readonly lookupResolver: LookupResolver
   private readonly networkPreset: 'local' | 'mainnet' | 'testnet'
   private initialized = false
+  private socketAuthenticated = false
+  private connectionInitPromise?: Promise<void>
   protected originator?: OriginatorDomainNameStringUnder250Bytes
   /**
    * @constructor
@@ -131,7 +133,7 @@ export class MessageBoxClient {
     } = options
 
     const defaultHost =
-      this.networkPreset === 'testnet'
+      networkPreset === 'testnet'
         ? DEFAULT_TESTNET_HOST
         : DEFAULT_MAINNET_HOST
 
@@ -313,6 +315,15 @@ export class MessageBoxClient {
 
     Logger.log('[MB CLIENT] Setting up WebSocket connection...')
 
+    if (this.socketAuthenticated && this.socket != null) {
+      return
+    }
+
+    if (this.connectionInitPromise != null) {
+      await this.connectionInitPromise
+      return
+    }
+
     if (this.socket == null) {
       const targetHost = overrideHost ?? this.host
       if (typeof targetHost !== 'string' || targetHost.trim() === '') {
@@ -320,58 +331,115 @@ export class MessageBoxClient {
       }
       this.socket = AuthSocketClient(targetHost, { wallet: this.walletClient, originator: this.originator })
 
-      let identitySent = false
-      let authenticated = false
-
       this.socket.on('connect', () => {
         Logger.log('[MB CLIENT] Connected to WebSocket.')
 
-        if (!identitySent) {
-          Logger.log('[MB CLIENT] Sending authentication data:', this.myIdentityKey)
-          if (this.myIdentityKey == null || this.myIdentityKey.trim() === '') {
-            Logger.error('[MB CLIENT ERROR] Cannot send authentication: Identity key is missing!')
-          } else {
-            this.socket?.emit('authenticated', { identityKey: this.myIdentityKey })
-            identitySent = true
-          }
+        Logger.log('[MB CLIENT] Sending authentication data:', this.myIdentityKey)
+        if (this.myIdentityKey == null || this.myIdentityKey.trim() === '') {
+          Logger.error('[MB CLIENT ERROR] Cannot send authentication: Identity key is missing!')
+        } else {
+          this.socket?.emit('authenticated', { identityKey: this.myIdentityKey })
         }
       })
 
       // Listen for authentication success from the server
       this.socket.on('authenticationSuccess', (data) => {
         Logger.log(`[MB CLIENT] WebSocket authentication successful: ${JSON.stringify(data)}`)
-        authenticated = true
+        this.socketAuthenticated = true
       })
 
       // Handle authentication failures
       this.socket.on('authenticationFailed', (data) => {
         Logger.error(`[MB CLIENT ERROR] WebSocket authentication failed: ${JSON.stringify(data)}`)
-        authenticated = false
+        this.socketAuthenticated = false
       })
 
       this.socket.on('disconnect', () => {
         Logger.log('[MB CLIENT] Disconnected from MessageBox server')
         this.socket = undefined
-        identitySent = false
-        authenticated = false
+        this.socketAuthenticated = false
       })
 
       this.socket.on('error', (error) => {
         Logger.error('[MB CLIENT ERROR] WebSocket error:', error)
       })
+    }
 
-      // Wait for authentication confirmation before proceeding
-      await new Promise<void>((resolve, reject) => {
-        setTimeout(() => {
-          if (authenticated) {
-            Logger.log('[MB CLIENT] WebSocket fully authenticated and ready!')
-            resolve()
-          } else {
-            reject(new Error('[MB CLIENT ERROR] WebSocket authentication timed out!'))
-          }
-        }, 5000) // Timeout after 5 seconds
-      })
+    if (this.socket?.connected && !this.socketAuthenticated) {
+      this.socket.emit('authenticated', { identityKey: this.myIdentityKey })
     }
+
+    this.connectionInitPromise = new Promise<void>((resolve, reject) => {
+      const socketAny = this.socket as any
+      let settled = false
+      let timeoutId: ReturnType<typeof setTimeout> | undefined
+
+      const finalizeResolve = (): void => {
+        if (settled) return
+        settled = true
+        if (timeoutId != null) {
+          clearTimeout(timeoutId)
+          timeoutId = undefined
+        }
+        if (typeof socketAny?.off === 'function') {
+          socketAny.off('authenticationSuccess', onSuccess)
+          socketAny.off('authenticationFailed', onFailed)
+          socketAny.off('disconnect', onDisconnectBeforeAuth)
+        }
+        this.connectionInitPromise = undefined
+        Logger.log('[MB CLIENT] WebSocket fully authenticated and ready!')
+        resolve()
+      }
+
+      const finalizeReject = (error: Error): void => {
+        if (settled) return
+        settled = true
+        if (timeoutId != null) {
+          clearTimeout(timeoutId)
+          timeoutId = undefined
+        }
+        if (typeof socketAny?.off === 'function') {
+          socketAny.off('authenticationSuccess', onSuccess)
+          socketAny.off('authenticationFailed', onFailed)
+          socketAny.off('disconnect', onDisconnectBeforeAuth)
+        }
+        this.connectionInitPromise = undefined
+        reject(error)
+      }
+
+      const onSuccess = (): void => {
+        this.socketAuthenticated = true
+        finalizeResolve()
+      }
+
+      const onFailed = (): void => {
+        this.socketAuthenticated = false
+        finalizeReject(new Error('[MB CLIENT ERROR] WebSocket authentication failed!'))
+      }
+
+      const onDisconnectBeforeAuth = (): void => {
+        this.socketAuthenticated = false
+      }
+
+      if (this.socketAuthenticated) {
+        finalizeResolve()
+        return
+      }
+
+      socketAny?.on('authenticationSuccess', onSuccess)
+      socketAny?.on('authenticationFailed', onFailed)
+      socketAny?.on('disconnect', onDisconnectBeforeAuth)
+
+      timeoutId = setTimeout(() => {
+        if (this.socketAuthenticated) {
+          finalizeResolve()
+        } else {
+          finalizeReject(new Error('[MB CLIENT ERROR] WebSocket authentication timed out!'))
+        }
+      }, 5000)
+    })
+
+    await this.connectionInitPromise
   }
 
   /**
@@ -453,7 +521,29 @@ export class MessageBoxClient {
     } catch (err) {
       Logger.error('[MB CLIENT ERROR] _queryAdvertisements failed:', err)
     }
-    return hosts
+    return hosts.filter(item => {
+      const h = item.host.trim().toLowerCase()
+      if (!h) return false
+      try {
+        const url = new URL(h)
+        if (url.protocol !== 'https:') return false
+        const hostname = url.hostname
+        if (
+          hostname === 'localhost' ||
+          hostname === '127.0.0.1' ||
+          hostname === '0.0.0.0' ||
+          hostname === '::1' ||
+          hostname.endsWith('.local') ||
+          hostname.endsWith('.example.com') ||
+          hostname.endsWith('.test') ||
+          hostname.endsWith('.invalid') ||
+          hostname.endsWith('.localhost')
+        ) return false
+        return true
+      } catch {
+        return false
+      }
+    })
   }
 
   /**
@@ -700,10 +790,15 @@ export class MessageBoxClient {
     return await new Promise((resolve, reject) => {
       const ackEvent = `sendMessageAck-${roomId}`
       let handled = false
+      let timeoutId: ReturnType<typeof setTimeout> | undefined
 
       const ackHandler = (response?: SendMessageResponse): void => {
         if (handled) return
         handled = true
+        if (timeoutId != null) {
+          clearTimeout(timeoutId)
+          timeoutId = undefined
+        }
 
         const socketAny = this.socket as any
         if (typeof socketAny?.off === 'function') {
@@ -749,9 +844,10 @@ export class MessageBoxClient {
       })
 
       // Timeout: Fallback to HTTP if no acknowledgment received
-      setTimeout(() => {
+      timeoutId = setTimeout(() => {
         if (!handled) {
           handled = true
+          timeoutId = undefined
           const socketAny = this.socket as any
           if (typeof socketAny?.off === 'function') {
             socketAny.off(ackEvent, ackHandler)
@@ -1063,14 +1159,14 @@ export class MessageBoxClient {
       throw new Error('Missing delivery agent identity keys in quote response.')
     }
     if (Object.keys(deliveryAgentIdentityKeyByHost).length > 1 && !overrideHost) {
-    // To keep the single-POST invariant, we require all recipients to share a host
+      // To keep the single-POST invariant, we require all recipients to share a host
       throw new Error('Recipients resolve to multiple hosts. Use overrideHost to force a single server or split by host.')
     }
 
     // pick the host to POST to
     const finalHost = (overrideHost ?? await this.resolveHostForRecipient(allowedRecipients[0])).replace(/\/+$/, '')
     const singleDeliveryKey = deliveryAgentIdentityKeyByHost[finalHost] ??
-    Object.values(deliveryAgentIdentityKeyByHost)[0]
+      Object.values(deliveryAgentIdentityKeyByHost)[0]
 
     if (!singleDeliveryKey) {
       throw new Error('Could not determine server delivery agent identity key.')
@@ -1100,7 +1196,7 @@ export class MessageBoxClient {
     if (skipEncryption === true) {
       finalBody = typeof body === 'string' ? body : JSON.stringify(body)
     } else {
-    // safest for now: send plaintext; the recipients can decrypt payload fields client-side if needed
+      // safest for now: send plaintext; the recipients can decrypt payload fields client-side if needed
       finalBody = typeof body === 'string' ? body : JSON.stringify(body)
     }
 
@@ -1143,18 +1239,18 @@ export class MessageBoxClient {
       const failed: Array<{ recipient: string, error: string }> = [] // handled server-side now
 
       const status: SendListResult['status'] =
-      sent.length === allowedRecipients.length
-        ? 'success'
-        : sent.length > 0
-          ? 'partial'
-          : 'error'
+        sent.length === allowedRecipients.length
+          ? 'success'
+          : sent.length > 0
+            ? 'partial'
+            : 'error'
 
       const description =
-      status === 'success'
-        ? `Sent to ${sent.length} recipients.`
-        : status === 'partial'
-          ? `Sent to ${sent.length} recipients; ${allowedRecipients.length - sent.length} failed; ${blocked.length} blocked.`
-          : `Failed to send to ${allowedRecipients.length} allowed recipients. ${blocked.length} blocked.`
+        status === 'success'
+          ? `Sent to ${sent.length} recipients.`
+          : status === 'partial'
+            ? `Sent to ${sent.length} recipients; ${allowedRecipients.length - sent.length} failed; ${blocked.length} blocked.`
+            : `Failed to send to ${allowedRecipients.length} allowed recipients. ${blocked.length} blocked.`
 
       return { status, description, sent, blocked, failed, totals }
     } catch (err) {
@@ -1681,7 +1777,7 @@ export class MessageBoxClient {
     }
   }
 
-  private async mapWithConcurrency<T, R> (
+  private async mapWithConcurrency<T, R>(
     items: T[],
     limit: number,
     fn: (item: T, index: number) => Promise<R>
@@ -1997,7 +2093,7 @@ export class MessageBoxClient {
     params: GetQuoteParams,
     overrideHost?: string
   ): Promise<MessageBoxQuote | MessageBoxMultiQuote> {
-  // ---------- SINGLE RECIPIENT (back-compat) ----------
+    // ---------- SINGLE RECIPIENT (back-compat) ----------
     if (!Array.isArray(params.recipient)) {
       const finalHost = overrideHost ?? await this.resolveHostForRecipient(params.recipient)
       const queryParams = new URLSearchParams({
@@ -2008,14 +2104,14 @@ export class MessageBoxClient {
       Logger.log('[MB CLIENT] Getting messageBox quote (single)...')
       console.log('HELP IM QUOTING', `${finalHost}/permissions/quote?${queryParams.toString()}`)
       const response = await this.authFetch.fetch(
-      `${finalHost}/permissions/quote?${queryParams.toString()}`,
-      { method: 'GET' }
+        `${finalHost}/permissions/quote?${queryParams.toString()}`,
+        { method: 'GET' }
       )
       console.log('server response from getquote]', response)
       if (!response.ok) {
         const errorData = await response.json().catch(() => ({}))
         throw new Error(
-        `Failed to get quote: HTTP ${response.status} - ${String(errorData.description) ?? response.statusText}`
+          `Failed to get quote: HTTP ${response.status} - ${String(errorData.description) ?? response.statusText}`
         )
       }
 
@@ -2088,7 +2184,7 @@ export class MessageBoxClient {
       if (!resp.ok) {
         const errorData = await resp.json().catch(() => ({}))
         throw new Error(
-        `Failed to get quote (host ${host}): HTTP ${resp.status} - ${String(errorData.description) ?? resp.statusText}`
+          `Failed to get quote (host ${host}): HTTP ${resp.status} - ${String(errorData.description) ?? resp.statusText}`
         )
       }
 
@@ -2103,7 +2199,7 @@ export class MessageBoxClient {
       // Server supports both shapes. For multi we expect:
       //  { quotesByRecipient, totals, blockedRecipients }
       if (Array.isArray(payload?.quotesByRecipient)) {
-      // merge quotes
+        // merge quotes
         for (const q of payload.quotesByRecipient) {
           quotesByRecipient.push({
             recipient: q.recipient,
@@ -2129,12 +2225,12 @@ export class MessageBoxClient {
           }
         }
       } else if (payload?.quote) {
-      // Defensive: if an overlay still returns single-quote shape for multi (shouldn’t),
-      // we map it to each recipient in the group uniformly.
+        // Defensive: if an overlay still returns single-quote shape for multi (shouldn’t),
+        // we map it to each recipient in the group uniformly.
         for (const r of groupRecipients) {
           const { deliveryFee, recipientFee } = payload.quote
           const status =
-          recipientFee === -1 ? 'blocked' : recipientFee === 0 ? 'always_allow' : 'payment_required'
+            recipientFee === -1 ? 'blocked' : recipientFee === 0 ? 'always_allow' : 'payment_required'
           quotesByRecipient.push({
             recipient: r,
             messageBox: params.messageBox,

package/src/RemittanceAdapter.ts

@@ -0,0 +1,164 @@
+/**
+ * RemittanceAdapter - Adapts MessageBoxClient to the CommsLayer interface
+ *
+ * This adapter bridges MessageBoxClient with the ts-sdk RemittanceManager by implementing
+ * the CommsLayer interface. It handles the protocol differences between the two systems,
+ * particularly around message body format (MessageBoxClient returns parsed objects,
+ * RemittanceManager expects JSON strings).
+ *
+ * @example
+ * ```typescript
+ * import { RemittanceAdapter } from '@bsv/message-box-client'
+ * import { RemittanceManager } from '@bsv/sdk'
+ * import { MessageBoxClient } from '@bsv/message-box-client'
+ * import { WalletClient } from '@bsv/sdk'
+ *
+ * const wallet = new WalletClient()
+ * const messageBox = new MessageBoxClient({ walletClient: wallet })
+ * const commsLayer = new RemittanceAdapter(messageBox)
+ *
+ * const manager = new RemittanceManager(
+ *   {
+ *     messageBox: 'remittance_inbox',
+ *     remittanceModules: [new Brc29RemittanceModule()]
+ *   },
+ *   wallet,
+ *   commsLayer
+ * )
+ * ```
+ */
+
+import { PubKeyHex } from '@bsv/sdk'
+import type {
+  CommsLayer as SdkCommsLayer,
+  PeerMessage as SdkRemittancePeerMessage
+} from '@bsv/sdk'
+import type { MessageBoxClient } from './MessageBoxClient.js'
+import type { PeerMessage as MessageBoxPeerMessage } from './types.js'
+
+export type CommsLayer = SdkCommsLayer
+export type RemittancePeerMessage = SdkRemittancePeerMessage
+
+/**
+ * Adapter that implements the CommsLayer interface for MessageBoxClient
+ *
+ * This class wraps MessageBoxClient to provide compatibility with the RemittanceManager
+ * communications interface. It handles format conversions, particularly ensuring message
+ * bodies are properly stringified for the RemittanceManager protocol.
+ */
+export class RemittanceAdapter implements SdkCommsLayer {
+  /**
+   * Creates a new RemittanceAdapter
+   * @param messageBox - The MessageBoxClient instance to adapt
+   */
+  constructor(private readonly messageBox: MessageBoxClient) { }
+
+  /**
+   * Sends a message over the store-and-forward channel
+   * @param args - Message parameters (recipient, messageBox, body)
+   * @param hostOverride - Optional host override
+   * @returns The transport message ID
+   */
+  async sendMessage(
+    args: { recipient: PubKeyHex, messageBox: string, body: string },
+    hostOverride?: string
+  ): Promise<string> {
+    const result = await this.messageBox.sendMessage({
+      recipient: args.recipient,
+      messageBox: args.messageBox,
+      body: args.body
+    }, hostOverride)
+
+    return result.messageId
+  }
+
+  /**
+   * Sends a message over the live channel.
+   * MessageBoxClient handles transport fallback internally (WebSocket -> HTTP).
+   * @param args - Message parameters (recipient, messageBox, body)
+   * @param hostOverride - Optional host override
+   * @returns The transport message ID
+   */
+  async sendLiveMessage(
+    args: { recipient: PubKeyHex, messageBox: string, body: string },
+    hostOverride?: string
+  ): Promise<string> {
+    const result = await this.messageBox.sendLiveMessage({
+      recipient: args.recipient,
+      messageBox: args.messageBox,
+      body: args.body
+    }, hostOverride)
+
+    return result.messageId
+  }
+
+  /**
+   * Lists pending messages for a message box
+   *
+   * Note: MessageBoxClient returns message bodies as parsed objects, but RemittanceManager
+   * expects them as JSON strings. This method handles the conversion.
+   *
+   * @param args - List parameters (messageBox, optional host)
+   * @returns Array of peer messages with stringified bodies
+   */
+  async listMessages(args: { messageBox: string, host?: string }): Promise<RemittancePeerMessage[]> {
+    const defaultRecipient = await this.messageBox.getIdentityKey() as PubKeyHex
+    const messages = await this.messageBox.listMessages({
+      messageBox: args.messageBox,
+      host: args.host
+    })
+
+    return messages.map(msg => this.toRemittancePeerMessage(msg, args.messageBox, defaultRecipient))
+  }
+
+  /**
+   * Acknowledges messages (deletes them from the server inbox)
+   * @param args - Array of message IDs to acknowledge
+   */
+  async acknowledgeMessage(args: { messageIds: string[] }): Promise<void> {
+    // MessageBoxClient's acknowledgeMessage expects the same format
+    await this.messageBox.acknowledgeMessage({ messageIds: args.messageIds })
+  }
+
+  /**
+   * Starts a live listener and normalizes inbound messages to the remittance PeerMessage shape.
+   */
+  async listenForLiveMessages(args: {
+    messageBox: string
+    overrideHost?: string
+    onMessage: (msg: RemittancePeerMessage) => void
+  }): Promise<void> {
+    const defaultRecipient = await this.messageBox.getIdentityKey() as PubKeyHex
+
+    await this.messageBox.listenForLiveMessages({
+      messageBox: args.messageBox,
+      overrideHost: args.overrideHost,
+      onMessage: (msg: MessageBoxPeerMessage) => {
+        args.onMessage(this.toRemittancePeerMessage(msg, args.messageBox, defaultRecipient))
+      }
+    })
+  }
+
+  private toRemittancePeerMessage (
+    msg: MessageBoxPeerMessage & { recipient?: string, messageBox?: string },
+    fallbackMessageBox: string,
+    fallbackRecipient: PubKeyHex
+  ): RemittancePeerMessage {
+    return {
+      messageId: msg.messageId,
+      sender: msg.sender as PubKeyHex,
+      recipient: (msg.recipient ?? fallbackRecipient) as PubKeyHex,
+      messageBox: msg.messageBox ?? fallbackMessageBox,
+      body: this.toBodyString(msg.body)
+    }
+  }
+
+  private toBodyString (body: unknown): string {
+    if (typeof body === 'string') return body
+    try {
+      return JSON.stringify(body)
+    } catch {
+      return String(body)
+    }
+  }
+}

package/src/__tests/RemittanceAdapter.test.ts

@@ -0,0 +1,153 @@
+/* eslint-env jest */
+import { jest } from '@jest/globals'
+import { RemittanceAdapter } from '../RemittanceAdapter.js'
+import type { MessageBoxClient } from '../MessageBoxClient.js'
+
+describe('RemittanceAdapter', () => {
+  const myIdentityKey = '02b463b8ef7f03c47fba2679c7334d13e4939b8ca30dbb6bbd22e34ea3e9b1b0e4'
+  const senderKey = '03f5d7a10f8ac22f0785a54d7d30fd009a77da27812f4e2f4ac9327dfcb5f65f86'
+
+  it('delegates sendMessage and returns the transport messageId', async () => {
+    const messageBox = {
+      sendMessage: jest.fn<() => Promise<{ status: string, messageId: string }>>().mockResolvedValue({
+        status: 'success',
+        messageId: 'http-mid'
+      })
+    } as unknown as MessageBoxClient
+
+    const adapter = new RemittanceAdapter(messageBox)
+    const result = await adapter.sendMessage({
+      recipient: senderKey,
+      messageBox: 'remittance_inbox',
+      body: '{"v":1}'
+    }, 'https://override-host')
+
+    expect(result).toBe('http-mid')
+    expect(messageBox.sendMessage).toHaveBeenCalledWith({
+      recipient: senderKey,
+      messageBox: 'remittance_inbox',
+      body: '{"v":1}'
+    }, 'https://override-host')
+  })
+
+  it('delegates sendLiveMessage (live path) and returns the transport messageId', async () => {
+    const messageBox = {
+      sendLiveMessage: jest.fn<() => Promise<{ status: string, messageId: string }>>().mockResolvedValue({
+        status: 'success',
+        messageId: 'ws-mid'
+      })
+    } as unknown as MessageBoxClient
+
+    const adapter = new RemittanceAdapter(messageBox)
+    const result = await adapter.sendLiveMessage({
+      recipient: senderKey,
+      messageBox: 'remittance_inbox',
+      body: '{"v":1}'
+    }, 'https://override-host')
+
+    expect(result).toBe('ws-mid')
+    expect(messageBox.sendLiveMessage).toHaveBeenCalledWith({
+      recipient: senderKey,
+      messageBox: 'remittance_inbox',
+      body: '{"v":1}'
+    }, 'https://override-host')
+  })
+
+  it('normalizes listMessages shape for remittance and forwards host', async () => {
+    const messageBox = {
+      getIdentityKey: jest.fn<() => Promise<string>>().mockResolvedValue(myIdentityKey),
+      listMessages: jest.fn<() => Promise<any[]>>().mockResolvedValue([
+        {
+          messageId: 'm1',
+          sender: senderKey,
+          created_at: '2026-01-01T00:00:00Z',
+          updated_at: '2026-01-01T00:00:00Z',
+          body: { kind: 'invoice', amount: 1 }
+        },
+        {
+          messageId: 'm2',
+          sender: senderKey,
+          recipient: '020202020202020202020202020202020202020202020202020202020202020202',
+          messageBox: 'custom_box',
+          created_at: '2026-01-01T00:00:00Z',
+          updated_at: '2026-01-01T00:00:00Z',
+          body: '{"kind":"receipt"}'
+        }
+      ])
+    } as unknown as MessageBoxClient
+
+    const adapter = new RemittanceAdapter(messageBox)
+    const result = await adapter.listMessages({
+      messageBox: 'remittance_inbox',
+      host: 'https://remote-host'
+    })
+
+    expect(messageBox.listMessages).toHaveBeenCalledWith({
+      messageBox: 'remittance_inbox',
+      host: 'https://remote-host'
+    })
+    expect(result).toEqual([
+      {
+        messageId: 'm1',
+        sender: senderKey,
+        recipient: myIdentityKey,
+        messageBox: 'remittance_inbox',
+        body: '{"kind":"invoice","amount":1}'
+      },
+      {
+        messageId: 'm2',
+        sender: senderKey,
+        recipient: '020202020202020202020202020202020202020202020202020202020202020202',
+        messageBox: 'custom_box',
+        body: '{"kind":"receipt"}'
+      }
+    ])
+  })
+
+  it('forwards live listener setup and normalizes inbound message shape', async () => {
+    const onPaymentMessage = jest.fn()
+    let forwardedListener: ((msg: {
+      messageId: string
+      sender: string
+      body: unknown
+      created_at: string
+      updated_at: string
+    }) => void) | undefined
+
+    const messageBox = {
+      getIdentityKey: jest.fn<() => Promise<string>>().mockResolvedValue(myIdentityKey),
+      listenForLiveMessages: jest.fn().mockImplementation(async ({ onMessage }) => {
+        forwardedListener = onMessage
+      })
+    } as unknown as MessageBoxClient
+
+    const adapter = new RemittanceAdapter(messageBox)
+    await adapter.listenForLiveMessages({
+      messageBox: 'remittance_inbox',
+      overrideHost: 'https://ws-host',
+      onMessage: onPaymentMessage
+    })
+
+    expect(messageBox.listenForLiveMessages).toHaveBeenCalledWith({
+      messageBox: 'remittance_inbox',
+      overrideHost: 'https://ws-host',
+      onMessage: expect.any(Function)
+    })
+
+    forwardedListener?.({
+      messageId: 'live-1',
+      sender: senderKey,
+      created_at: '2026-01-01T00:00:00Z',
+      updated_at: '2026-01-01T00:00:00Z',
+      body: { kind: 'settlement' }
+    })
+
+    expect(onPaymentMessage).toHaveBeenCalledWith({
+      messageId: 'live-1',
+      sender: senderKey,
+      recipient: myIdentityKey,
+      messageBox: 'remittance_inbox',
+      body: '{"kind":"settlement"}'
+    })
+  })
+})