@bsv/message-box-client 2.0.1 → 2.0.3

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.1",
+  "version": "2.0.3",
   "publishConfig": {
     "access": "public"
   },
@@ -54,8 +54,8 @@
   "author": "BSV Blockchain Association",
   "license": "SEE LICENSE IN LICENSE.txt",
   "devDependencies": {
-    "@bsv/auth-express-middleware": "^2.0.2",
-    "@bsv/payment-express-middleware": "^2.0.0",
+    "@bsv/auth-express-middleware": "^2.0.4",
+    "@bsv/payment-express-middleware": "^2.0.1",
     "@eslint/js": "^9.20.0",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.13.2",
@@ -82,7 +82,7 @@
     "webpack-merge": "^6.0.1"
   },
   "dependencies": {
-    "@bsv/authsocket-client": "^2.0.1",
-    "@bsv/sdk": "^2.0.3"
+    "@bsv/authsocket-client": "^2.0.2",
+    "@bsv/sdk": "^2.0.4"
   }
 }

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
   }
 
   /**
@@ -700,10 +768,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 +822,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)

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"}'
+    })
+  })
+})