@bsv/message-box-client 1.1.7

package/src/__tests/PeerPayClientUnit.test.ts

@@ -0,0 +1,245 @@
+/* eslint-env jest */
+import { PeerPayClient } from '../PeerPayClient.js'
+import { WalletClient, CreateHmacResult, PrivateKey } from '@bsv/sdk'
+import { jest } from '@jest/globals'
+
+const toArray = (msg: any, enc?: 'hex' | 'utf8' | 'base64'): any[] => {
+  if (Array.isArray(msg)) return msg.slice()
+  if (msg === undefined) return []
+
+  if (typeof msg !== 'string') {
+    return Array.from(msg, (item: any) => item | 0)
+  }
+
+  switch (enc) {
+    case 'hex': {
+      const matches = msg.match(/.{1,2}/g)
+      return matches != null ? matches.map(byte => parseInt(byte, 16)) : []
+    }
+    case 'base64':
+      return Array.from(Buffer.from(msg, 'base64'))
+    default:
+      return Array.from(Buffer.from(msg, 'utf8'))
+  }
+}
+
+// Mock dependencies
+jest.mock('@bsv/sdk', () => {
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+  const actualSDK = jest.requireActual('@bsv/sdk') as any
+
+  return {
+    ...actualSDK,
+    WalletClient: jest.fn().mockImplementation(() => ({
+      getPublicKey: jest.fn(),
+      createAction: jest.fn(),
+      internalizeAction: jest.fn(),
+      createHmac: jest.fn<() => Promise<CreateHmacResult>>().mockResolvedValue({
+        hmac: [1, 2, 3, 4, 5]
+      })
+    }))
+  }
+})
+
+describe('PeerPayClient Unit Tests', () => {
+  let peerPayClient: PeerPayClient
+  let mockWalletClient: jest.Mocked<WalletClient>
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+
+    mockWalletClient = new WalletClient() as jest.Mocked<WalletClient>
+
+    // Ensure a valid compressed public key (33 bytes, hex format)
+    mockWalletClient.getPublicKey.mockResolvedValue({
+      publicKey: PrivateKey.fromRandom().toPublicKey().toString()
+    })
+
+    mockWalletClient.createAction.mockResolvedValue({
+      tx: toArray('mockedTransaction', 'utf8')
+    })
+
+    peerPayClient = new PeerPayClient({
+      messageBoxHost: 'https://messagebox.babbage.systems',
+      walletClient: mockWalletClient
+    })
+  })
+
+  describe('createPaymentToken', () => {
+    it('should create a valid payment token', async () => {
+      mockWalletClient.getPublicKey.mockResolvedValue({
+        publicKey: PrivateKey.fromRandom().toPublicKey().toString()
+      })
+      mockWalletClient.createAction.mockResolvedValue({ tx: toArray('mockedTransaction', 'utf8') })
+
+      const payment = { recipient: PrivateKey.fromRandom().toPublicKey().toString(), amount: 5 }
+      const token = await peerPayClient.createPaymentToken(payment)
+
+      expect(token).toHaveProperty('amount', 5)
+      expect(mockWalletClient.getPublicKey).toHaveBeenCalledWith(expect.any(Object))
+      expect(mockWalletClient.createAction).toHaveBeenCalledWith(expect.any(Object))
+    })
+
+    it('should throw an error if recipient public key cannot be derived', async () => {
+      mockWalletClient.getPublicKey.mockResolvedValue({ publicKey: '' }) // Empty key
+
+      await expect(peerPayClient.createPaymentToken({ recipient: 'invalid', amount: 5 }))
+        .rejects.toThrow('Failed to derive recipient’s public key')
+    })
+
+    it('should throw an error if amount is <= 0', async () => {
+      (mockWalletClient.getPublicKey as jest.MockedFunction<typeof mockWalletClient.getPublicKey>)
+        .mockResolvedValue({
+          publicKey: PrivateKey.fromRandom().toPublicKey().toString()
+        })
+
+      await expect(peerPayClient.createPaymentToken({
+        recipient: PrivateKey.fromRandom().toPublicKey().toString(),
+        amount: 0
+      }))
+        .rejects.toThrow('Invalid payment details: recipient and valid amount are required')
+    })
+  })
+
+  // Test: sendPayment
+  describe('sendPayment', () => {
+    it('should call sendMessage with valid payment', async () => {
+      const sendMessageSpy = jest.spyOn(peerPayClient, 'sendMessage').mockResolvedValue({
+        status: 'success',
+        messageId: 'mockedMessageId'
+      })
+
+      const payment = { recipient: 'recipientKey', amount: 3 }
+
+      console.log('[TEST] Calling sendPayment...')
+      await peerPayClient.sendPayment(payment)
+      console.log('[TEST] sendPayment finished.')
+
+      expect(sendMessageSpy).toHaveBeenCalledWith({
+        recipient: 'recipientKey',
+        messageBox: 'payment_inbox',
+        body: expect.any(String)
+      })
+    }, 10000)
+  })
+
+  // Test: sendLivePayment
+  describe('sendLivePayment', () => {
+    it('should call createPaymentToken and sendLiveMessage with correct parameters', async () => {
+      jest.spyOn(peerPayClient, 'createPaymentToken').mockResolvedValue({
+        customInstructions: {
+          derivationPrefix: 'prefix',
+          derivationSuffix: 'suffix'
+        },
+        transaction: Array.from(new Uint8Array([1, 2, 3, 4, 5])),
+        amount: 2
+      })
+
+      jest.spyOn(peerPayClient, 'sendLiveMessage').mockResolvedValue({
+        status: 'success',
+        messageId: 'mockedMessageId'
+      })
+
+      const payment = { recipient: 'recipientKey', amount: 2 }
+      await peerPayClient.sendLivePayment(payment)
+
+      expect(peerPayClient.createPaymentToken).toHaveBeenCalledWith(payment)
+      expect(peerPayClient.sendLiveMessage).toHaveBeenCalledWith({
+        recipient: 'recipientKey',
+        messageBox: 'payment_inbox',
+        body: "{\"customInstructions\":{\"derivationPrefix\":\"prefix\",\"derivationSuffix\":\"suffix\"},\"transaction\":[1,2,3,4,5],\"amount\":2}"
+      })
+    })
+  })
+
+  // Test: acceptPayment
+  describe('acceptPayment', () => {
+    it('should call internalizeAction and acknowledgeMessage', async () => {
+      mockWalletClient.internalizeAction.mockResolvedValue({ accepted: true })
+      jest.spyOn(peerPayClient, 'acknowledgeMessage').mockResolvedValue('acknowledged')
+
+      const payment = {
+        messageId: '123',
+        sender: 'senderKey',
+        token: {
+          customInstructions: { derivationPrefix: 'prefix', derivationSuffix: 'suffix' },
+          transaction: toArray('mockedTransaction', 'utf8'),
+          amount: 6
+        }
+      }
+
+      await peerPayClient.acceptPayment(payment)
+
+      expect(mockWalletClient.internalizeAction).toHaveBeenCalled()
+      expect(peerPayClient.acknowledgeMessage).toHaveBeenCalledWith({ messageIds: ['123'] })
+    })
+  })
+
+  // Test: rejectPayment
+  describe('rejectPayment', () => {
+    it('should refund payment minus fee', async () => {
+      jest.spyOn(peerPayClient, 'acceptPayment').mockResolvedValue(undefined)
+      jest.spyOn(peerPayClient, 'sendPayment').mockResolvedValue(undefined)
+      jest.spyOn(peerPayClient, 'acknowledgeMessage').mockResolvedValue('acknowledged')
+
+      const payment = {
+        messageId: '123',
+        sender: 'senderKey',
+        token: {
+          customInstructions: { derivationPrefix: 'prefix', derivationSuffix: 'suffix' },
+          transaction: toArray('mockedTransaction', 'utf8'),
+          amount: 2000
+        }
+      }
+
+      await peerPayClient.rejectPayment(payment)
+
+      expect(peerPayClient.acceptPayment).toHaveBeenCalledWith(payment)
+      expect(peerPayClient.sendPayment).toHaveBeenCalledWith({
+        recipient: 'senderKey',
+        amount: 1000 // Deduct satoshi fee
+      })
+      expect(peerPayClient.acknowledgeMessage).toHaveBeenCalledWith({
+        messageIds: ['123']
+      })
+    })
+  })
+
+  // Test: listIncomingPayments
+  describe('listIncomingPayments', () => {
+    it('should return parsed payment messages', async () => {
+      jest.spyOn(peerPayClient, 'listMessages').mockResolvedValue([
+        {
+          messageId: '1',
+          sender: 'sender1',
+          created_at: '2025-03-05T12:00:00Z',
+          updated_at: '2025-03-05T12:05:00Z',
+          body: JSON.stringify({
+            customInstructions: { derivationPrefix: 'prefix1', derivationSuffix: 'suffix1' },
+            transaction: toArray('mockedTransaction1', 'utf8'),
+            amount: 3
+          })
+        },
+        {
+          messageId: '2',
+          sender: 'sender2',
+          created_at: '2025-03-05T12:10:00Z',
+          updated_at: '2025-03-05T12:15:00Z',
+          body: JSON.stringify({
+            customInstructions: { derivationPrefix: 'prefix2', derivationSuffix: 'suffix2' },
+            transaction: toArray('mockedTransaction2', 'utf8'),
+            amount: 9
+          })
+        }
+      ])
+
+      const payments = await peerPayClient.listIncomingPayments()
+
+      expect(payments).toHaveLength(2)
+      expect(payments[0]).toHaveProperty('sender', 'sender1')
+      expect(payments[0].token.amount).toBe(3)
+      expect(payments[1]).toHaveProperty('sender', 'sender2')
+      expect(payments[1].token.amount).toBe(9)
+    })
+  })
+})

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

@@ -0,0 +1,103 @@
+/* eslint-env jest */
+import { MessageBoxClient } from '../../MessageBoxClient.js'
+import { WalletClient } from '@bsv/sdk'
+import { webcrypto } from 'crypto'
+import { expect, test, describe, beforeAll } from '@jest/globals'
+
+(global as any).self = { crypto: webcrypto }
+
+jest.setTimeout(20000)
+
+const walletClient = new WalletClient('json-api', 'https://messagebox.babbage.systems')
+const messageBoxClient = new MessageBoxClient({
+  host: 'https://messagebox.babbage.systems',
+  walletClient,
+  enableLogging: true,
+  networkPreset: 'local'
+})
+
+let identityKey: string
+
+describe('Encryption Integration Tests', () => {
+  const messageBox = 'testBox'
+  const plaintext = 'This is a secure test message.'
+
+  beforeAll(async () => {
+    const result = await walletClient.getPublicKey({ identityKey: true })
+    identityKey = result.publicKey
+
+    await messageBoxClient.initializeConnection()
+  })
+
+  test('encrypts and decrypts a message to self successfully', async () => {
+    // Encrypt
+    const { ciphertext } = await walletClient.encrypt({
+      plaintext: Array.from(new TextEncoder().encode(plaintext)),
+      protocolID: [1, 'messagebox'],
+      keyID: '1',
+      counterparty: 'self'
+    })
+
+    expect(Array.isArray(ciphertext)).toBe(true)
+    expect(ciphertext.length).toBeGreaterThan(0)
+
+    // Decrypt
+    const { plaintext: decryptedBytes } = await walletClient.decrypt({
+      ciphertext,
+      protocolID: [1, 'messagebox'],
+      keyID: '1',
+      counterparty: 'self'
+    })
+
+    const decrypted = new TextDecoder().decode(Uint8Array.from(decryptedBytes))
+    expect(decrypted).toBe(plaintext)
+  })
+
+  test('sends and receives encrypted message using MessageBoxClient', async () => {
+    // Send message to self
+    const sendResult = await messageBoxClient.sendMessage({
+      recipient: identityKey,
+      messageBox,
+      body: plaintext
+    })
+
+    expect(sendResult.status).toBe('success')
+    expect(typeof sendResult.messageId).toBe('string')
+
+    // List and decrypt
+    const messages = await messageBoxClient.listMessages({ messageBox })
+    const last = messages.at(-1)
+
+    expect(last).toBeDefined()
+    expect(last?.body).toBe(plaintext)
+  })
+
+  test('encrypted message is not stored or transmitted as plaintext', async () => {
+    // Send encrypted message to self
+    const sendResult = await messageBoxClient.sendMessage({
+      recipient: identityKey,
+      messageBox,
+      body: plaintext
+    })
+
+    expect(sendResult.status).toBe('success')
+
+    // Manually fetch raw HTTP response
+    const fetch = await messageBoxClient.authFetch.fetch(
+      'https://messagebox.babbage.systems/listMessages',
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ messageBox })
+      }
+    )
+
+    const raw = await fetch.json()
+    const rawBody = raw.messages.at(-1)?.body
+
+    expect(typeof rawBody).toBe('string')
+    const parsed = JSON.parse(rawBody)
+    expect(typeof parsed.encryptedMessage).toBe('string')
+    expect(parsed.encryptedMessage.includes(plaintext)).toBe(false)
+  })
+})

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

@@ -0,0 +1,158 @@
+/* eslint-env jest */
+import { MessageBoxClient } from '../../MessageBoxClient.js'
+import { WalletClient } from '@bsv/sdk'
+import { webcrypto } from 'crypto'
+
+// Ensure Jest doesn't mock WalletClient
+jest.unmock('@bsv/sdk');
+
+(global as any).self = { crypto: webcrypto }
+
+jest.setTimeout(20000)
+
+// Explicitly initialize WalletClient with Meta Net Client (MNC)
+const walletClient = new WalletClient('json-api', 'localhost')
+
+// Initialize MessageBoxClient for HTTP-Only Testing
+const messageBoxClient = new MessageBoxClient({
+  host: 'https://messagebox.babbage.systems',
+  walletClient
+})
+
+describe('MessageBoxClient HTTP Integration Tests (No WebSocket)', () => {
+  let recipientKey: string
+  let testMessageId: string
+  const messageBox = 'testBox'
+  const testMessage = 'Hello, this is an integration test.'
+  const testMessage2 = 'Another test message to avoid duplicates.'
+
+  beforeAll(async () => {
+    try {
+      console.log('[DEBUG] Retrieving public key...')
+      const publicKeyResponse = await walletClient.getPublicKey({ identityKey: true })
+
+      if (
+        publicKeyResponse?.publicKey == null ||
+        typeof publicKeyResponse.publicKey !== 'string' ||
+        publicKeyResponse.publicKey.trim() === ''
+      ) {
+        throw new Error('[ERROR] getPublicKey returned an invalid key!')
+      }
+
+      recipientKey = publicKeyResponse.publicKey.trim()
+      console.log('[DEBUG] Successfully assigned recipientKey:', recipientKey)
+
+      // Ensure identity key is set internally in MessageBoxClient
+      await messageBoxClient.initializeConnection()
+    } catch (error) {
+      console.error('[ERROR] Failed to set up test:', error)
+      throw error
+    }
+  })
+
+  afterAll(async () => {
+    try {
+      if (testMessageId !== undefined && testMessageId !== '') {
+        console.log('[DEBUG] Cleaning up test messages...')
+      }
+    } catch (error) {
+      console.error('[ERROR] Failed to acknowledge test message:', error)
+    }
+  })
+
+  /** TEST 1: Send a Message with Correct Payment **/
+  test('should send a message successfully with correct payment', async () => {
+    const response = await messageBoxClient.sendMessage({
+      recipient: recipientKey,
+      messageBox,
+      body: testMessage,
+      skipEncryption: true // TEMPORARY to test if this fixes the 400
+    })
+
+    console.log('[DEBUG] SendMessage Response:', response)
+
+    expect(response).toHaveProperty('status', 'success')
+    expect(response).toHaveProperty('messageId', expect.any(String))
+
+    testMessageId = response.messageId // Store for cleanup
+  }, 30000)
+
+  /** TEST 2: List Messages **/
+  test('should list messages from messageBox', async () => {
+    const messages = await messageBoxClient.listMessages({ messageBox })
+    expect(messages.length).toBeGreaterThan(0)
+    expect(messages.some(msg => msg.body === testMessage)).toBe(true)
+  }, 15000)
+
+  /** TEST 3: List Messages from an Empty MessageBox **/
+  test('should return an empty list if no messages exist', async () => {
+    const messages = await messageBoxClient.listMessages({ messageBox: 'emptyBox' })
+    expect(messages).toEqual([])
+  }, 15000)
+
+  /** TEST 4: Acknowledge a Message **/
+  test('should acknowledge (delete) a message', async () => {
+    const ackResponse = await messageBoxClient.acknowledgeMessage({ messageIds: [testMessageId] })
+    expect(ackResponse).toBe('success')
+  }, 15000)
+
+  /** TEST 5: Acknowledge a Nonexistent Message **/
+  test('should fail to acknowledge a nonexistent message', async () => {
+    await expect(
+      messageBoxClient.acknowledgeMessage({ messageIds: ['fakeMessageId'] })
+    ).rejects.toThrow('Message not found!')
+  }, 15000)
+
+  /** TEST 6: Send Message with Invalid Recipient **/
+  test('should fail if recipient is invalid', async () => {
+    await expect(
+      messageBoxClient.sendMessage({
+        recipient: '', // Invalid recipient
+        messageBox,
+        body: testMessage
+      })
+    ).rejects.toThrow('You must provide a message recipient!')
+  }, 15000)
+
+  /** TEST 7: Send Message with Empty Body **/
+  test('should fail if message body is empty', async () => {
+    await expect(
+      messageBoxClient.sendMessage({
+        recipient: recipientKey,
+        messageBox,
+        body: '' // Empty message
+      })
+    ).rejects.toThrow('Every message must have a body!')
+  }, 15000)
+
+  /** TEST 8: Send Message with Excessive Payment (Should still succeed) **/
+  test('should send a message even if payment is more than required', async () => {
+    const response = await messageBoxClient.sendMessage({
+      recipient: recipientKey,
+      messageBox,
+      body: testMessage2,
+      skipEncryption: true
+    })
+
+    console.log('[DEBUG] Overpayment SendMessage Response:', response)
+
+    expect(response.status).toBe('success')
+  }, 15000)
+
+  /** TEST: Send a message without encryption **/
+  test('should send a message without encryption when skipEncryption is true', async () => {
+    const plaintextMessage = 'Unencrypted test message'
+    const response = await messageBoxClient.sendMessage({
+      recipient: recipientKey,
+      messageBox,
+      body: plaintextMessage,
+      skipEncryption: true // Bypass encryption
+    })
+
+    expect(response).toHaveProperty('status', 'success')
+    expect(response).toHaveProperty('messageId', expect.any(String))
+
+    const messages = await messageBoxClient.listMessages({ messageBox })
+    expect(messages.some(msg => msg.body === plaintextMessage)).toBe(true)
+  }, 30000)
+})

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

@@ -0,0 +1,163 @@
+/* eslint-env jest */
+import { MessageBoxClient } from '../../MessageBoxClient.js'
+import { WalletClient } from '@bsv/sdk'
+import { webcrypto } from 'crypto'
+
+(global as any).self = { crypto: webcrypto }
+
+jest.setTimeout(20000)
+
+const MESSAGEBOX_HOST = 'http://localhost:5001'
+
+const walletA = new WalletClient('json-api', 'localhost')
+const walletB = new WalletClient('json-api', 'localhost')
+
+const clientA = new MessageBoxClient({
+  host: MESSAGEBOX_HOST,
+  walletClient: walletA,
+  networkPreset: 'local',
+  enableLogging: true
+})
+
+const clientB = new MessageBoxClient({
+  host: MESSAGEBOX_HOST,
+  walletClient: walletB,
+  networkPreset: 'local',
+  enableLogging: true
+})
+
+let identityKeyA: string
+let identityKeyB: string
+
+beforeAll(async () => {
+  identityKeyA = (await walletA.getPublicKey({ identityKey: true })).publicKey
+  identityKeyB = (await walletB.getPublicKey({ identityKey: true })).publicKey
+  await clientA.initializeConnection()
+  await clientB.initializeConnection()
+})
+
+afterAll(async () => {
+  await clientA.disconnectWebSocket()
+  await clientB.disconnectWebSocket()
+})
+
+describe('Overlay Integration Tests', () => {
+  const selfBox = 'overlay_self_box'
+  const peerBox = 'forwarded_overlay_box'
+
+  test('clientA broadcasts overlay advertisement', async () => {
+    const result = await clientA.anointHost(MESSAGEBOX_HOST)
+    expect(result).toHaveProperty('txid')
+    await new Promise(resolve => setTimeout(resolve, 3000))
+  })
+
+  test('clientA resolves own host via overlay', async () => {
+    const resolved = await (clientA as any).resolveHostForRecipient(identityKeyA)
+    console.log('[TEST] Resolved host:', resolved)
+    expect(resolved).toBe(MESSAGEBOX_HOST)
+  })
+
+  test('clientA sends message to self via overlay', async () => {
+    const response = await clientA.sendMessage({
+      recipient: identityKeyA,
+      messageBox: selfBox,
+      body: 'hello via overlay'
+    })
+    expect(response.status).toBe('success')
+  })
+
+  test('clientA lists self messages via overlay', async () => {
+    const messages = await clientA.listMessages({ messageBox: selfBox })
+    expect(messages.length).toBeGreaterThan(0)
+    expect(messages.at(-1)?.body).toContain('hello via overlay')
+  })
+
+  test('clientA acknowledges self messages via overlay', async () => {
+    const messages = await clientA.listMessages({ messageBox: selfBox })
+    const ids = messages.map(m => m.messageId).filter(Boolean)
+    expect(ids.length).toBeGreaterThan(0)
+    const status = await clientA.acknowledgeMessage({ messageIds: ids })
+    expect(status).toBe('success')
+  })
+
+  test('clientB broadcasts overlay advertisement', async () => {
+    const result = await clientB.anointHost(MESSAGEBOX_HOST)
+    expect(result).toHaveProperty('txid')
+    await new Promise(resolve => setTimeout(resolve, 3000))
+  })
+
+  test('clientA sends message to clientB via overlay', async () => {
+    const response = await clientA.sendMessage({
+      recipient: identityKeyB,
+      messageBox: peerBox,
+      body: 'delivered to peer via overlay'
+    })
+    expect(response.status).toBe('success')
+  })
+
+  test('clientB receives overlay message from clientA', async () => {
+    const messages = await clientB.listMessages({ messageBox: peerBox })
+    expect(messages.some(m => m.body.includes('delivered to peer via overlay'))).toBe(true)
+  })
+
+  test('clientB acknowledges overlay message from clientA', async () => {
+    const messages = await clientB.listMessages({ messageBox: peerBox })
+    const ids = messages.map(m => m.messageId).filter(Boolean)
+    const result = await clientB.acknowledgeMessage({ messageIds: ids })
+    expect(result).toBe('success')
+  })
+
+  test('clientA verifies clientB host resolution', async () => {
+    const resolved = await (clientA as any).resolveHostForRecipient(identityKeyB)
+    expect(resolved).toBe(MESSAGEBOX_HOST)
+  })
+
+  test('overlay advertisement is idempotent', async () => {
+    const result1 = await clientA.anointHost(MESSAGEBOX_HOST)
+    const result2 = await clientA.anointHost(MESSAGEBOX_HOST)
+    expect(result1.txid).not.toBe(result2.txid)
+  })
+
+  test('clientA sends and acknowledges multiple messages to clientB', async () => {
+    const contents = ['msg1', 'msg2', 'msg3']
+    for (const msg of contents) {
+      const response = await clientA.sendMessage({
+        recipient: identityKeyB,
+        messageBox: peerBox,
+        body: msg
+      })
+      expect(response.status).toBe('success')
+    }
+
+    await new Promise(resolve => setTimeout(resolve, 1000))
+    const messages = await clientB.listMessages({ messageBox: peerBox })
+    const matched = contents.every(c => messages.some(m => m.body.includes(c)))
+    expect(matched).toBe(true)
+
+    const ids = messages.map(m => m.messageId).filter(Boolean)
+    const status = await clientB.acknowledgeMessage({ messageIds: ids })
+    expect(status).toBe('success')
+  })
+
+  test('clientA reinitializes with init() and correctly anoints host', async () => {
+    const tempClient = new MessageBoxClient({
+      walletClient: walletA,
+      networkPreset: 'local',
+      enableLogging: true
+      // No host provided here!
+    })
+
+    // Call init manually
+    await tempClient.init(MESSAGEBOX_HOST)
+
+    // Verify client is initialized and host is correct
+    expect((tempClient as any).initialized).toBe(true)
+    expect((tempClient as any).host).toBe(MESSAGEBOX_HOST)
+
+    // Optionally, test that resolving our own identity also works
+    const resolvedHost = await (tempClient as any).resolveHostForRecipient(identityKeyA)
+    expect(resolvedHost).toBe(MESSAGEBOX_HOST)
+
+    await tempClient.disconnectWebSocket()
+  })
+})