@bsv/message-box-client 1.1.7

package/src/__tests/integration/integrationWS.test.ts

@@ -0,0 +1,147 @@
+/* eslint-env jest */
+import { MessageBoxClient } from '../../MessageBoxClient.js'
+import { PeerMessage } from '../../types.js'
+import { WalletClient } from '@bsv/sdk'
+import { webcrypto } from 'crypto'
+
+(global as any).self = { crypto: webcrypto }
+
+jest.setTimeout(20000)
+
+const WS_URL = 'https://messagebox.babbage.systems'
+
+let recipientKey: string
+const messageBox = 'testBox'
+const testMessage = 'Hello, this is a WebSocket integration test.'
+
+const walletClient = new WalletClient('json-api', 'localhost')
+const messageBoxClient = new MessageBoxClient({
+  host: WS_URL,
+  walletClient
+})
+
+describe('MessageBoxClient WebSocket Integration Tests', () => {
+  beforeAll(async () => {
+    const keyResult = await walletClient.getPublicKey({ identityKey: true })
+    recipientKey = keyResult.publicKey
+    console.log(`Recipient Key: ${recipientKey}`)
+
+    await messageBoxClient.initializeConnection()
+  })
+
+  afterAll(async () => {
+    console.log('Closing WebSocket connection after tests.')
+    await messageBoxClient.disconnectWebSocket()
+  })
+
+  /** TEST 1: Authenticate WebSocket Connection **/
+  test('should authenticate and connect via WebSocket', async () => {
+    expect(messageBoxClient.testSocket).toBeDefined()
+    console.log('[TEST] WebSocket authenticated and connected')
+  }, 15000)
+
+  /** TEST 2: Join a WebSocket Room **/
+  test('should join a WebSocket room successfully', async () => {
+    await messageBoxClient.joinRoom(messageBox)
+    console.log(`[TEST] Joined WebSocket room: ${messageBox}`)
+
+    const identityKey = await messageBoxClient.getIdentityKey()
+    expect(messageBoxClient.getJoinedRooms().has(`${identityKey}-${messageBox}`)).toBe(true)
+  }, 15000)
+
+  /** TEST 3: Send and Receive a Message via WebSocket **/
+  test('should send and receive a message via WebSocket', async () => {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    let receivedMessage: PeerMessage | null = null
+
+    const messagePromise = new Promise<PeerMessage>((resolve, reject) => {
+      messageBoxClient
+        .listenForLiveMessages({
+          messageBox,
+          onMessage: (message: PeerMessage) => {
+            try {
+              receivedMessage = message
+              console.log('[TEST] Received message:', JSON.stringify(message, null, 2))
+              resolve(message)
+            } catch (error) {
+              console.error('[ERROR] Error processing message:', error)
+              reject(error)
+            }
+          }
+        })
+        .catch(reject)
+
+      setTimeout(() => {
+        reject(new Error('Test timed out: No message received over WebSocket'))
+      }, 10000)
+    })
+
+    await messageBoxClient.joinRoom(messageBox)
+
+    console.log(`[TEST] Sending message to WebSocket room: ${messageBox}`)
+
+    const response = await messageBoxClient.sendLiveMessage({
+      recipient: recipientKey,
+      messageBox,
+      body: testMessage
+    })
+
+    expect(response).toHaveProperty('status', 'success')
+
+    const received = await messagePromise
+    expect(received).not.toBeNull()
+    expect(received.body).toBe(testMessage)
+    expect(received.sender).toBe(recipientKey)
+  }, 15000)
+
+  /** TEST 4: Leave a WebSocket Room **/
+  test('should leave a WebSocket room successfully', async () => {
+    await messageBoxClient.leaveRoom(messageBox)
+    console.log(`[TEST] Left WebSocket room: ${messageBox}`)
+
+    const identityKey = await messageBoxClient.getIdentityKey()
+    expect(messageBoxClient.getJoinedRooms().has(`${identityKey}-${messageBox}`)).toBe(false)
+  }, 15000)
+
+  /** TEST 5: Send and Receive a Message via WebSocket without Encryption **/
+  test('should send and receive a message via WebSocket without encryption', async () => {
+    const unencryptedMessage = 'Plaintext WebSocket message'
+
+    const messagePromise = new Promise<PeerMessage>((resolve, reject) => {
+      messageBoxClient
+        .listenForLiveMessages({
+          messageBox,
+          onMessage: (message: PeerMessage) => {
+            try {
+              console.log('[TEST] Received unencrypted message:', message)
+              resolve(message)
+            } catch (error) {
+              console.error('[ERROR] Error processing message:', error)
+              reject(error)
+            }
+          }
+        })
+        .catch(reject)
+
+      setTimeout(() => {
+        reject(new Error('Test timed out: No unencrypted message received'))
+      }, 10000)
+    })
+
+    await messageBoxClient.joinRoom(messageBox)
+
+    const response = await messageBoxClient.sendLiveMessage({
+      recipient: recipientKey,
+      messageBox,
+      body: unencryptedMessage,
+      skipEncryption: true
+    })
+
+    expect(response).toHaveProperty('status', 'success')
+
+    const received = await messagePromise
+    expect(received).not.toBeNull()
+    expect(received.body).toBe(unencryptedMessage)
+    expect(received.sender).toBe(recipientKey)
+  }, 15000)
+})

package/src/__tests/integration/testServer.ts

@@ -0,0 +1,68 @@
+import { spawn } from 'child_process'
+import { resolve } from 'path'
+
+let serverProcess: any | null = null
+
+async function isServerRunning (): Promise<boolean> {
+  try {
+    await fetch('http://localhost:8080/health') // Use an actual health check route
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Starts the MessageBoxServer as a separate process if not already running.
+ */
+export async function startTestServer (): Promise<void> {
+  if (await isServerRunning()) {
+    console.log('Test server already running.')
+    return
+  }
+
+  console.log('Starting test server...')
+  serverProcess = spawn('npm', ['run', 'dev'], {
+    cwd: resolve(__dirname, '../../../MessageBoxServer'),
+    stdio: 'inherit',
+    shell: true
+  })
+
+  await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error('Test server startup timed out'))
+    }, 10000)
+
+    serverProcess.on('error', (err) => {
+      console.error('Test server failed to start:', err)
+      clearTimeout(timeout)
+      reject(err)
+    })
+
+    setTimeout(() => {
+      console.log('Test server started.')
+      clearTimeout(timeout)
+      resolve(undefined)
+    }, 3000)
+  })
+}
+
+/**
+ * Stops the MessageBoxServer process after tests.
+ */
+export async function stopTestServer (): Promise<void> {
+  if (serverProcess === null) {
+    console.warn('Test server process is already stopped or undefined.')
+    return
+  }
+
+  console.log('Stopping test server...')
+  try {
+    serverProcess.kill()
+    console.log('Test server stopped.')
+  } catch (error) {
+    console.error('Error stopping test server:', error)
+  }
+
+  serverProcess = null
+}

package/src/types.ts

@@ -0,0 +1,108 @@
+import { Base64String, WalletClient } from '@bsv/sdk'
+
+/**
+ * Configuration options for initializing a MessageBoxClient.
+ */
+export interface MessageBoxClientOptions {
+  /**
+   * Wallet instance used for auth, identity, and encryption.
+   * If not provided, a new WalletClient will be created.
+   */
+  walletClient?: WalletClient
+
+  /**
+   * Base URL of the MessageBox server.
+   * @default 'https://messagebox.babbage.systems'
+   */
+  host?: string
+
+  /**
+   * If true, enables detailed logging to the console.
+   * @default false
+   */
+  enableLogging?: boolean
+
+  /**
+   * Overlay network preset for routing resolution.
+   * @default 'local'
+   */
+  networkPreset?: 'local' | 'mainnet' | 'testnet'
+}
+
+/**
+ * Represents a decrypted message received from a MessageBox.
+ * Includes metadata such as sender identity, timestamps, and optional acknowledgment status.
+ *
+ * Used in both HTTP and WebSocket message retrieval responses.
+ */
+export interface PeerMessage {
+  messageId: string
+  body: string | Record<string, any>
+  sender: string
+  created_at: string
+  updated_at: string
+  acknowledged?: boolean
+}
+
+/**
+ * Parameters required to send a message.
+ * Message content may be a string or object, and encryption is enabled by default.
+ *
+ * @example
+ * {
+ *   recipient: "03abc...",
+ *   messageBox: "payment_inbox",
+ *   body: { type: "ping" },
+ *   skipEncryption: false
+ * }
+ */
+export interface SendMessageParams {
+  recipient: string
+  messageBox: string
+  body: string | object
+  messageId?: string
+  skipEncryption?: boolean
+}
+
+/**
+ * Server response structure for successful message delivery.
+ *
+ * Returned by both `sendMessage` and `sendLiveMessage`.
+ */
+export interface SendMessageResponse {
+  status: string
+  messageId: string
+}
+
+/**
+ * Parameters for acknowledging messages in the system.
+ *
+ * @interface AcknowledgeMessageParams
+ *
+ * @property {string[]} messageIds - An array of message IDs to acknowledge.
+ * @property {string} [host] - Optional host URL where the messages originated.
+ */
+export interface AcknowledgeMessageParams {
+  messageIds: string[]
+  host?: string
+}
+
+/**
+ * Parameters for listing messages in a message box.
+ *
+ * @property messageBox - The identifier of the message box to retrieve messages from.
+ * @property host - (Optional) The host URL to connect to for retrieving messages.
+ */
+export interface ListMessagesParams {
+  messageBox: string
+  host?: string
+}
+
+/**
+ * Encapsulates an AES-256-GCM encrypted message body.
+ *
+ * Used when transmitting encrypted payloads to the MessageBox server.
+ */
+export interface EncryptedMessage {
+  encryptedMessage: Base64String
+}