@bsv/message-box-client 1.2.4 → 1.2.6

package/package.json

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

package/src/MessageBoxClient.ts

@@ -116,7 +116,7 @@ export class MessageBoxClient {
    * })
    * await client.init()
    */
-  constructor(options: MessageBoxClientOptions = {}) {
+  constructor (options: MessageBoxClientOptions = {}) {
     const {
       host,
       walletClient,
@@ -168,7 +168,7 @@ export class MessageBoxClient {
    * await client.init()
    * await client.sendMessage({ recipient, messageBox: 'inbox', body: 'Hello' })
    */
-  async init(targetHost: string = this.host, originator?: string): Promise<void> {
+  async init (targetHost: string = this.host, originator?: string): Promise<void> {
     const normalizedHost = targetHost?.trim()
     if (normalizedHost === '') {
       throw new Error('Cannot anoint host: No valid host provided')
@@ -189,9 +189,14 @@ export class MessageBoxClient {
     // 3. If none our found, anoint this host
     if (firstAdvertisement == null || firstAdvertisement?.host?.trim() === '' || firstAdvertisement?.host !== normalizedHost) {
       Logger.log('[MB CLIENT] Anointing host:', normalizedHost)
-      const { txid } = await this.anointHost(normalizedHost, originator)
-      if (txid == null || txid.trim() === '') {
-        throw new Error('Failed to anoint host: No transaction ID returned')
+      try {
+        const { txid } = await this.anointHost(normalizedHost, originator)
+        if (txid == null || txid.trim() === '') {
+          throw new Error('Failed to anoint host: No transaction ID returned')
+        }
+      } catch (error) {
+        Logger.log('[MB CLIENT] Failed to anoint host, continuing with default functionality:', error)
+        // Continue with default host - client can still function for basic operations
       }
     }
     this.initialized = true
@@ -208,7 +213,7 @@ export class MessageBoxClient {
    *
    * Used automatically by all public methods that require initialization.
    */
-  private async assertInitialized(): Promise<void> {
+  private async assertInitialized (): Promise<void> {
     if (!this.initialized || this.host == null || this.host.trim() === '') {
       await this.init()
     }
@@ -221,7 +226,7 @@ export class MessageBoxClient {
    * Returns a live list of WebSocket rooms the client is subscribed to.
    * Useful for inspecting state or ensuring no duplicates are joined.
    */
-  public getJoinedRooms(): Set<string> {
+  public getJoinedRooms (): Set<string> {
     return this.joinedRooms
   }
 
@@ -233,7 +238,7 @@ export class MessageBoxClient {
  * Returns the client's identity key, used for signing, encryption, and addressing.
  * If not already loaded, it will fetch and cache it.
  */
-  public async getIdentityKey(originator?: string): Promise<string> {
+  public async getIdentityKey (originator?: string): Promise<string> {
     if (this.myIdentityKey != null && this.myIdentityKey.trim() !== '') {
       return this.myIdentityKey
     }
@@ -261,7 +266,7 @@ export class MessageBoxClient {
    * Note: Do not interact with the socket directly unless necessary.
    * Use the provided `sendLiveMessage`, `listenForLiveMessages`, and related methods.
    */
-  public get testSocket(): ReturnType<typeof AuthSocketClient> | undefined {
+  public get testSocket (): ReturnType<typeof AuthSocketClient> | undefined {
     return this.socket
   }
 
@@ -289,8 +294,7 @@ export class MessageBoxClient {
    * await mb.initializeConnection()
    * // WebSocket is now ready for use
    */
-  async initializeConnection(originator?: string): Promise<void> {
-    await this.assertInitialized()
+  async initializeConnection (originator?: string, overrideHost?: string): Promise<void> {
     Logger.log('[MB CLIENT] initializeConnection() STARTED')
 
     if (this.myIdentityKey == null || this.myIdentityKey.trim() === '') {
@@ -305,10 +309,11 @@ export class MessageBoxClient {
     Logger.log('[MB CLIENT] Setting up WebSocket connection...')
 
     if (this.socket == null) {
-      if (typeof this.host !== 'string' || this.host.trim() === '') {
-        throw new Error('Cannot initialize WebSocket: Host is not set')
+      const targetHost = overrideHost ?? this.host
+      if (typeof targetHost !== 'string' || targetHost.trim() === '') {
+        throw new Error('Cannot initialize WebSocket: No valid host provided')
       }
-      this.socket = AuthSocketClient(this.host, { wallet: this.walletClient })
+      this.socket = AuthSocketClient(targetHost, { wallet: this.walletClient })
 
       let identitySent = false
       let authenticated = false
@@ -383,7 +388,7 @@ export class MessageBoxClient {
    * @example
    * const host = await resolveHostForRecipient('028d...') // → returns either overlay host or this.host
    */
-  async resolveHostForRecipient(identityKey: string, originator?: string): Promise<string> {
+  async resolveHostForRecipient (identityKey: string, originator?: string): Promise<string> {
     const advertisementTokens = await this.queryAdvertisements(identityKey, undefined, originator)
     if (advertisementTokens.length === 0) {
       Logger.warn(`[MB CLIENT] No advertisements for ${identityKey}, using default host ${this.host}`)
@@ -401,7 +406,7 @@ export class MessageBoxClient {
    * @param host?        if passed, only look for adverts anointed at that host
    * @returns            0-length array if nothing valid was found
    */
-  async queryAdvertisements(
+  async queryAdvertisements (
     identityKey?: string,
     host?: string,
     originator?: string
@@ -466,14 +471,13 @@ export class MessageBoxClient {
    * await client.joinRoom('payment_inbox')
    * // Now listening for real-time messages in room '028d...-payment_inbox'
    */
-  async joinRoom(messageBox: string): Promise<void> {
-    await this.assertInitialized()
+  async joinRoom (messageBox: string, originator?: string, overrideHost?: string): Promise<void> {
     Logger.log(`[MB CLIENT] Attempting to join WebSocket room: ${messageBox}`)
 
     // Ensure WebSocket connection is established first
     if (this.socket == null) {
       Logger.log('[MB CLIENT] No WebSocket connection. Initializing...')
-      await this.initializeConnection()
+      await this.initializeConnection(originator, overrideHost)
     }
 
     if (this.myIdentityKey == null || this.myIdentityKey.trim() === '') {
@@ -525,20 +529,27 @@ export class MessageBoxClient {
    *   onMessage: (msg) => console.log('Received live message:', msg)
    * })
    */
-  async listenForLiveMessages({
+  async listenForLiveMessages ({
     onMessage,
     messageBox,
-    originator
+    originator,
+    overrideHost
   }: {
     onMessage: (message: PeerMessage) => void
     messageBox: string
     originator?: string
+    overrideHost?: string
   }): Promise<void> {
-    await this.assertInitialized()
     Logger.log(`[MB CLIENT] Setting up listener for WebSocket room: ${messageBox}`)
 
-    // Ensure WebSocket connection and room join
-    await this.joinRoom(messageBox)
+    // Ensure WebSocket connection is established first
+    if (this.socket == null) {
+      Logger.log('[MB CLIENT] No WebSocket connection. Initializing...')
+      await this.initializeConnection(originator, overrideHost)
+    }
+
+    // Join the room
+    await this.joinRoom(messageBox, originator, overrideHost)
 
     // Ensure identity key is available before creating roomId
     if (this.myIdentityKey == null || this.myIdentityKey.trim() === '') {
@@ -623,7 +634,7 @@ export class MessageBoxClient {
    *   body: { amount: 1000 }
    * })
    */
-  async sendLiveMessage({
+  async sendLiveMessage ({
     recipient,
     messageBox,
     body,
@@ -631,8 +642,7 @@ export class MessageBoxClient {
     skipEncryption,
     checkPermissions,
     originator
-  }: SendMessageParams): Promise<SendMessageResponse> {
-    await this.assertInitialized()
+  }: SendMessageParams, overrideHost?: string): Promise<SendMessageResponse> {
     if (recipient == null || recipient.trim() === '') {
       throw new Error('[MB CLIENT ERROR] Recipient identity key is required')
     }
@@ -644,12 +654,12 @@ export class MessageBoxClient {
     }
 
     // Ensure room is joined before sending
-    await this.joinRoom(messageBox)
+    await this.joinRoom(messageBox, originator, overrideHost)
 
     // Fallback to HTTP if WebSocket is not connected
     if (this.socket == null || !this.socket.connected) {
       Logger.warn('[MB CLIENT WARNING] WebSocket not connected, falling back to HTTP')
-      const targetHost = await this.resolveHostForRecipient(recipient)
+      const targetHost = overrideHost ?? await this.resolveHostForRecipient(recipient)
       return await this.sendMessage({ recipient, messageBox, body }, targetHost)
     }
 
@@ -781,7 +791,7 @@ export class MessageBoxClient {
    * @example
    * await client.leaveRoom('payment_inbox')
    */
-  async leaveRoom(messageBox: string): Promise<void> {
+  async leaveRoom (messageBox: string): Promise<void> {
     await this.assertInitialized()
     if (this.socket == null) {
       Logger.warn('[MB CLIENT] Attempted to leave a room but WebSocket is not connected.')
@@ -813,7 +823,7 @@ export class MessageBoxClient {
    * @example
    * await client.disconnectWebSocket()
    */
-  async disconnectWebSocket(): Promise<void> {
+  async disconnectWebSocket (): Promise<void> {
     await this.assertInitialized()
     if (this.socket != null) {
       Logger.log('[MB CLIENT] Closing WebSocket connection...')
@@ -851,7 +861,7 @@ export class MessageBoxClient {
    *   body: { type: 'ping' }
    * })
    */
-  async sendMessage(
+  async sendMessage (
     message: SendMessageParams,
     overrideHost?: string,
     originator?: string
@@ -1015,7 +1025,7 @@ export class MessageBoxClient {
    * @example
    * const { txid } = await client.anointHost('https://my-messagebox.io')
    */
-  async anointHost(host: string, originator?: string): Promise<{ txid: string }> {
+  async anointHost (host: string, originator?: string): Promise<{ txid: string }> {
     Logger.log('[MB CLIENT] Starting anointHost...')
     try {
       if (!host.startsWith('http')) {
@@ -1097,7 +1107,7 @@ export class MessageBoxClient {
    * @example
    * const { txid } = await client.revokeHost('https://my-messagebox.io')
    */
-  async revokeHostAdvertisement(advertisementToken: AdvertisementToken, originator?: string): Promise<{ txid: string }> {
+  async revokeHostAdvertisement (advertisementToken: AdvertisementToken, originator?: string): Promise<{ txid: string }> {
     Logger.log('[MB CLIENT] Starting revokeHost...')
     const outpoint = `${advertisementToken.txid}.${advertisementToken.outputIndex}`
     try {
@@ -1213,7 +1223,11 @@ export class MessageBoxClient {
 
     let hosts: string[] = host != null ? [host] : []
     if (hosts.length === 0) {
-      const advertisedHosts = await this.queryAdvertisements(await this.getIdentityKey(originator), originator)
+      const advertisedHosts = await this.queryAdvertisements(
+        await this.getIdentityKey(originator),
+        undefined,
+        originator
+      )
       hosts = Array.from(new Set([this.host, ...advertisedHosts.map(h => h.host)]))
     }
 
@@ -1340,7 +1354,7 @@ export class MessageBoxClient {
         if (
           messageContent != null &&
           typeof messageContent === 'object' &&
-          typeof (messageContent as any).encryptedMessage === 'string'
+          typeof (messageContent).encryptedMessage === 'string'
         ) {
           Logger.log(
             `[MB CLIENT] Decrypting message from ${String(message.sender)}…`
@@ -1522,7 +1536,7 @@ export class MessageBoxClient {
    * const success = await client.acknowledgeNotification(message)
    * console.log(success ? 'Payment received' : 'No payment or failed')
    */
-  async acknowledgeNotification(message: PeerMessage): Promise<boolean> {
+  async acknowledgeNotification (message: PeerMessage): Promise<boolean> {
     await this.acknowledgeMessage({ messageIds: [message.messageId] })
 
     const parsedBody: unknown =
@@ -1611,8 +1625,7 @@ export class MessageBoxClient {
    * @example
    * await client.acknowledgeMessage({ messageIds: ['msg123', 'msg456'] })
    */
-  async acknowledgeMessage({ messageIds, host, originator }: AcknowledgeMessageParams): Promise<string> {
-    await this.assertInitialized()
+  async acknowledgeMessage ({ messageIds, host, originator }: AcknowledgeMessageParams): Promise<string> {
     if (!Array.isArray(messageIds) || messageIds.length === 0) {
       throw new Error('Message IDs array cannot be empty')
     }
@@ -1694,11 +1707,10 @@ export class MessageBoxClient {
    *   recipientFee: -1
    * })
    */
-  async setMessageBoxPermission(
+  async setMessageBoxPermission (
     params: SetMessageBoxPermissionParams,
     overrideHost?: string
   ): Promise<void> {
-    await this.assertInitialized()
     const finalHost = overrideHost ?? this.host
 
     Logger.log('[MB CLIENT] Setting messageBox permission...')
@@ -1742,12 +1754,10 @@ export class MessageBoxClient {
    *   sender: '03abc123...'
    * })
    */
-  async getMessageBoxPermission(
+  async getMessageBoxPermission (
     params: GetMessageBoxPermissionParams,
     overrideHost?: string
   ): Promise<MessageBoxPermission | null> {
-    await this.assertInitialized()
-
     const finalHost = overrideHost ?? await this.resolveHostForRecipient(params.recipient)
     const queryParams = new URLSearchParams({
       recipient: params.recipient,
@@ -1789,9 +1799,7 @@ export class MessageBoxClient {
    *   messageBox: 'notifications'
    * })
    */
-  async getMessageBoxQuote(params: GetQuoteParams, overrideHost?: string): Promise<MessageBoxQuote> {
-    await this.assertInitialized()
-
+  async getMessageBoxQuote (params: GetQuoteParams, overrideHost?: string): Promise<MessageBoxQuote> {
     const finalHost = overrideHost ?? await this.resolveHostForRecipient(params.recipient)
     const queryParams = new URLSearchParams({
       recipient: params.recipient,
@@ -1847,9 +1855,7 @@ export class MessageBoxClient {
    *   offset: 0
    * })
    */
-  async listMessageBoxPermissions(params?: ListPermissionsParams, overrideHost?: string): Promise<MessageBoxPermission[]> {
-    await this.assertInitialized()
-
+  async listMessageBoxPermissions (params?: ListPermissionsParams, overrideHost?: string): Promise<MessageBoxPermission[]> {
     const finalHost = overrideHost ?? this.host
     const queryParams = new URLSearchParams()
 
@@ -1908,7 +1914,7 @@ export class MessageBoxClient {
    * await client.allowNotificationsFromPeer('03abc123...') // Always allow
    * await client.allowNotificationsFromPeer('03def456...', 5) // Allow for 5 sats
    */
-  async allowNotificationsFromPeer(identityKey: PubKeyHex, recipientFee: number = 0, overrideHost?: string): Promise<void> {
+  async allowNotificationsFromPeer (identityKey: PubKeyHex, recipientFee: number = 0, overrideHost?: string): Promise<void> {
     await this.setMessageBoxPermission({
       messageBox: 'notifications',
       sender: identityKey,
@@ -1928,7 +1934,7 @@ export class MessageBoxClient {
    * @example
    * await client.denyNotificationsFromPeer('03spam123...')
    */
-  async denyNotificationsFromPeer(identityKey: PubKeyHex, overrideHost?: string): Promise<void> {
+  async denyNotificationsFromPeer (identityKey: PubKeyHex, overrideHost?: string): Promise<void> {
     await this.setMessageBoxPermission({
       messageBox: 'notifications',
       sender: identityKey,
@@ -1949,7 +1955,7 @@ export class MessageBoxClient {
    * const status = await client.checkPeerNotificationStatus('03abc123...')
    * console.log(status.allowed) // true/false
    */
-  async checkPeerNotificationStatus(identityKey: PubKeyHex, overrideHost?: string): Promise<MessageBoxPermission | null> {
+  async checkPeerNotificationStatus (identityKey: PubKeyHex, overrideHost?: string): Promise<MessageBoxPermission | null> {
     const myIdentityKey = await this.getIdentityKey()
     return await this.getMessageBoxPermission({
       recipient: myIdentityKey,
@@ -1969,7 +1975,7 @@ export class MessageBoxClient {
    * @example
    * const notifications = await client.listPeerNotifications()
    */
-  async listPeerNotifications(overrideHost?: string): Promise<MessageBoxPermission[]> {
+  async listPeerNotifications (overrideHost?: string): Promise<MessageBoxPermission[]> {
     return await this.listMessageBoxPermissions({ messageBox: 'notifications' }, overrideHost)
   }
 
@@ -1992,7 +1998,7 @@ export class MessageBoxClient {
    * // Send with maximum payment limit for safety
    * await client.sendNotification('03def456...', { title: 'Alert', body: 'Important update' }, 50)
    */
-  async sendNotification(
+  async sendNotification (
     recipient: PubKeyHex,
     body: string | object,
     overrideHost?: string
@@ -2028,12 +2034,10 @@ export class MessageBoxClient {
    *   deviceId: 'iPhone15Pro'
    * })
    */
-  async registerDevice(
+  async registerDevice (
     params: DeviceRegistrationParams,
     overrideHost?: string
   ): Promise<DeviceRegistrationResponse> {
-    await this.assertInitialized()
-
     if (params.fcmToken == null || params.fcmToken.trim() === '') {
       throw new Error('fcmToken is required and must be a non-empty string')
     }
@@ -2095,11 +2099,9 @@ export class MessageBoxClient {
    *   console.log(`Device: ${device.platform} - ${device.fcmToken}`)
    * })
    */
-  async listRegisteredDevices(
+  async listRegisteredDevices (
     overrideHost?: string
   ): Promise<RegisteredDevice[]> {
-    await this.assertInitialized()
-
     const finalHost = overrideHost ?? this.host
 
     Logger.log('[MB CLIENT] Listing registered devices...')
@@ -2127,39 +2129,39 @@ export class MessageBoxClient {
   // PRIVATE HELPER METHODS
   // ===========================
 
-  private static getStatusFromFee(fee: number): 'always_allow' | 'blocked' | 'payment_required' {
+  private static getStatusFromFee (fee: number): 'always_allow' | 'blocked' | 'payment_required' {
     if (fee === -1) return 'blocked'
     if (fee === 0) return 'always_allow'
     return 'payment_required'
   }
 
-   /**
-   * @method createMessagePayment
-   * @private
-   * @param {string} recipient - Recipient's identity key.
-   * @param {MessageBoxQuote} quote - Quote object containing recipient and delivery fees.
-   * @param {string} [description='MessageBox delivery payment'] - Description for the payment action.
-   * @param {string} [originator] - Optional originator to use for wallet operations.
-   * @returns {Promise<Payment>} - Payment data including the transaction and remittance outputs.
-   *
-   * @description
-   * Constructs and signs a payment transaction covering both delivery and recipient fees for
-   * message delivery, based on a previously obtained quote.
-   *
-   * The transaction includes:
-   * - An optional delivery fee output for the MessageBox server.
-   * - An optional recipient fee output for the message recipient.
-   *
-   * Payment remittance metadata (derivation prefix/suffix, sender identity) is embedded to allow
-   * the payee to derive their private key and spend the output.
-   *
-   * @throws {Error} If no payment is required, key derivation fails, or the action creation fails.
-   *
-   * @example
-   * const payment = await client.createMessagePayment(recipientKey, quote)
-   * await client.sendMessage({ recipient, messageBox, body, payment })
-   */
-  private async createMessagePayment(
+  /**
+  * @method createMessagePayment
+  * @private
+  * @param {string} recipient - Recipient's identity key.
+  * @param {MessageBoxQuote} quote - Quote object containing recipient and delivery fees.
+  * @param {string} [description='MessageBox delivery payment'] - Description for the payment action.
+  * @param {string} [originator] - Optional originator to use for wallet operations.
+  * @returns {Promise<Payment>} - Payment data including the transaction and remittance outputs.
+  *
+  * @description
+  * Constructs and signs a payment transaction covering both delivery and recipient fees for
+  * message delivery, based on a previously obtained quote.
+  *
+  * The transaction includes:
+  * - An optional delivery fee output for the MessageBox server.
+  * - An optional recipient fee output for the message recipient.
+  *
+  * Payment remittance metadata (derivation prefix/suffix, sender identity) is embedded to allow
+  * the payee to derive their private key and spend the output.
+  *
+  * @throws {Error} If no payment is required, key derivation fails, or the action creation fails.
+  *
+  * @example
+  * const payment = await client.createMessagePayment(recipientKey, quote)
+  * await client.sendMessage({ recipient, messageBox, body, payment })
+  */
+  private async createMessagePayment (
     recipient: string,
     quote: MessageBoxQuote,
     description: string = 'MessageBox delivery payment',

package/src/PeerPayClient.ts

@@ -15,7 +15,7 @@ import { PeerMessage } from './types.js'
 import { WalletClient, P2PKH, PublicKey, createNonce, AtomicBEEF, AuthFetch, Base64String } from '@bsv/sdk'
 import * as Logger from './Utils/logger.js'
 
-function safeParse<T>(input: any): T {
+function safeParse<T> (input: any): T {
   try {
     return typeof input === 'string' ? JSON.parse(input) : input
   } catch (e) {
@@ -74,7 +74,7 @@ export class PeerPayClient extends MessageBoxClient {
   private readonly peerPayWalletClient: WalletClient
   private _authFetchInstance?: AuthFetch
 
-  constructor(config: PeerPayClientConfig) {
+  constructor (config: PeerPayClientConfig) {
     const { messageBoxHost = 'https://messagebox.babbage.systems', walletClient, enableLogging = false } = config
 
     // 🔹 Pass enableLogging to MessageBoxClient
@@ -83,7 +83,7 @@ export class PeerPayClient extends MessageBoxClient {
     this.peerPayWalletClient = walletClient
   }
 
-  private get authFetchInstance(): AuthFetch {
+  private get authFetchInstance (): AuthFetch {
     if (this._authFetchInstance === null || this._authFetchInstance === undefined) {
       this._authFetchInstance = new AuthFetch(this.peerPayWalletClient)
     }
@@ -102,7 +102,7 @@ export class PeerPayClient extends MessageBoxClient {
    * @returns {Promise<PaymentToken>} A valid payment token containing transaction details.
    * @throws {Error} If the recipient's public key cannot be derived.
    */
-  async createPaymentToken(payment: PaymentParams): Promise<PaymentToken> {
+  async createPaymentToken (payment: PaymentParams): Promise<PaymentToken> {
     if (payment.amount <= 0) {
       throw new Error('Invalid payment details: recipient and valid amount are required')
     };
@@ -175,10 +175,11 @@ export class PeerPayClient extends MessageBoxClient {
    * @param {PaymentParams} payment - The payment details.
    * @param {string} payment.recipient - The recipient's identity key.
    * @param {number} payment.amount - The amount in satoshis to send.
+   * @param {string} [hostOverride] - Optional host override for the message box server.
    * @returns {Promise<any>} Resolves with the payment result.
    * @throws {Error} If the recipient is missing or the amount is invalid.
    */
-  async sendPayment(payment: PaymentParams): Promise<any> {
+  async sendPayment (payment: PaymentParams, hostOverride?: string): Promise<any> {
     if (payment.recipient == null || payment.recipient.trim() === '' || payment.amount <= 0) {
       throw new Error('Invalid payment details: recipient and valid amount are required')
     }
@@ -190,23 +191,24 @@ export class PeerPayClient extends MessageBoxClient {
       recipient: payment.recipient,
       messageBox: STANDARD_PAYMENT_MESSAGEBOX,
       body: JSON.stringify(paymentToken)
-    })
+    }, hostOverride)
   }
 
   /**
    * Sends Bitcoin to a PeerPay recipient over WebSockets.
    *
    * This function generates a payment token and transmits it over WebSockets
-   * using `sendLiveMessage`. The recipient’s identity key is explicitly included
+   * using `sendLiveMessage`. The recipient's identity key is explicitly included
    * to ensure proper message routing.
    *
    * @param {PaymentParams} payment - The payment details.
    * @param {string} payment.recipient - The recipient's identity key.
    * @param {number} payment.amount - The amount in satoshis to send.
+   * @param {string} [overrideHost] - Optional host override for WebSocket connection.
    * @returns {Promise<void>} Resolves when the payment has been sent.
    * @throws {Error} If payment token generation fails.
    */
-  async sendLivePayment(payment: PaymentParams): Promise<void> {
+  async sendLivePayment (payment: PaymentParams, overrideHost?: string): Promise<void> {
     const paymentToken = await this.createPaymentToken(payment)
 
     try {
@@ -215,7 +217,7 @@ export class PeerPayClient extends MessageBoxClient {
         recipient: payment.recipient,
         messageBox: STANDARD_PAYMENT_MESSAGEBOX,
         body: JSON.stringify(paymentToken)
-      })
+      }, overrideHost)
     } catch (err) {
       Logger.warn('[PP CLIENT] sendLiveMessage failed, falling back to HTTP:', err)
 
@@ -224,7 +226,7 @@ export class PeerPayClient extends MessageBoxClient {
         recipient: payment.recipient,
         messageBox: STANDARD_PAYMENT_MESSAGEBOX,
         body: JSON.stringify(paymentToken)
-      })
+      }, overrideHost)
     }
   }
 
@@ -237,13 +239,19 @@ export class PeerPayClient extends MessageBoxClient {
    *
    * @param {Object} obj - The configuration object.
    * @param {Function} obj.onPayment - Callback function triggered when a payment is received.
+   * @param {string} [obj.overrideHost] - Optional host override for WebSocket connection.
    * @returns {Promise<void>} Resolves when the listener is successfully set up.
    */
-  async listenForLivePayments({
-    onPayment
-  }: { onPayment: (payment: IncomingPayment) => void }): Promise<void> {
+  async listenForLivePayments ({
+    onPayment,
+    overrideHost
+  }: {
+    onPayment: (payment: IncomingPayment) => void
+    overrideHost?: string
+  }): Promise<void> {
     await this.listenForLiveMessages({
       messageBox: STANDARD_PAYMENT_MESSAGEBOX,
+      overrideHost,
 
       // Convert PeerMessage → IncomingPayment before calling onPayment
       onMessage: (message: PeerMessage) => {
@@ -270,7 +278,7 @@ export class PeerPayClient extends MessageBoxClient {
    * @returns {Promise<any>} Resolves with the payment result if successful.
    * @throws {Error} If payment processing fails.
    */
-  async acceptPayment(payment: IncomingPayment): Promise<any> {
+  async acceptPayment (payment: IncomingPayment): Promise<any> {
     try {
       Logger.log(`[PP CLIENT] Processing payment: ${JSON.stringify(payment, null, 2)}`)
 
@@ -310,7 +318,7 @@ export class PeerPayClient extends MessageBoxClient {
    * @param {IncomingPayment} payment - The payment object containing transaction details.
    * @returns {Promise<void>} Resolves when the payment is either acknowledged or refunded.
    */
-  async rejectPayment(payment: IncomingPayment): Promise<void> {
+  async rejectPayment (payment: IncomingPayment): Promise<void> {
     Logger.log(`[PP CLIENT] Rejecting payment: ${JSON.stringify(payment, null, 2)}`)
 
     if (payment.token.amount - 1000 < 1000) {
@@ -368,10 +376,11 @@ export class PeerPayClient extends MessageBoxClient {
    * This function queries the message box for new messages and transforms
    * them into `IncomingPayment` objects by extracting relevant fields.
    *
+   * @param {string} [overrideHost] - Optional host override to list payments from
    * @returns {Promise<IncomingPayment[]>} Resolves with an array of pending payments.
    */
-  async listIncomingPayments(): Promise<IncomingPayment[]> {
-    const messages = await this.listMessages({ messageBox: STANDARD_PAYMENT_MESSAGEBOX })
+  async listIncomingPayments (overrideHost?: string): Promise<IncomingPayment[]> {
+    const messages = await this.listMessages({ messageBox: STANDARD_PAYMENT_MESSAGEBOX, host: overrideHost })
 
     return messages.map((msg: any) => {
       const parsedToken = safeParse<PaymentToken>(msg.body)

package/src/__tests/MessageBoxClient.test.ts

@@ -320,7 +320,6 @@ describe('MessageBoxClient', () => {
 
     const result = await messageBoxClient.listMessages({ messageBox: 'test_inbox' })
 
-
     expect(result).toEqual(JSON.parse(VALID_LIST_AND_READ_RESULT.body).messages)
   })
 
@@ -438,28 +437,6 @@ describe('MessageBoxClient', () => {
       .rejects.toThrow('Failed to acknowledge messages')
   })
 
-  it('Throws an error when WebSocket is not initialized before listening for messages', async () => {
-    const messageBoxClient = new MessageBoxClient({
-      walletClient: mockWalletClient,
-      host: 'https://messagebox.babbage.systems',
-      enableLogging: true
-    })
-    await messageBoxClient.init()
-
-    // Stub out the identity key to pass that check
-    ; (messageBoxClient as any).myIdentityKey = '02b463b8ef7f03c47fba2679c7334d13e4939b8ca30dbb6bbd22e34ea3e9b1b0e4'
-
-    // Stub out joinRoom to throw like the real one might
-    jest.spyOn(messageBoxClient, 'joinRoom').mockRejectedValue(new Error('WebSocket connection not initialized'))
-
-    await expect(
-      messageBoxClient.listenForLiveMessages({
-        onMessage: jest.fn(),
-        messageBox: 'test_inbox'
-      })
-    ).rejects.toThrow('WebSocket connection not initialized')
-  })
-
   it('Emits joinRoom event and listens for incoming messages', async () => {
     const messageBoxClient = new MessageBoxClient({
       walletClient: mockWalletClient,