@bsv/wallet-toolbox 1.7.13 → 1.7.15

package/mobile/node_modules/@bsv/sdk/src/identity/__tests/IdentityClient.test.ts

@@ -0,0 +1,772 @@
+import { WalletCertificate, WalletInterface } from '../../wallet/index'
+import { IdentityClient } from '../IdentityClient'
+import { Certificate } from '../../auth/certificates/index.js'
+import { KNOWN_IDENTITY_TYPES, defaultIdentity } from '../types/index.js'
+
+// ----- Mocks for external dependencies -----
+jest.mock('../../script', () => {
+  return {
+    PushDrop: jest.fn().mockImplementation(() => ({
+      lock: jest.fn().mockResolvedValue({
+        toHex: () => 'lockingScriptHex'
+      }),
+      unlock: jest.fn()
+    }))
+  }
+})
+
+jest.mock('../../overlay-tools/index.js', () => {
+  return {
+    TopicBroadcaster: jest.fn().mockImplementation(() => ({
+      broadcast: jest.fn().mockResolvedValue('broadcastResult')
+    }))
+  }
+})
+
+jest.mock('../../transaction/index.js', () => {
+  return {
+    Transaction: {
+      fromAtomicBEEF: jest.fn().mockImplementation((tx) => ({
+        toHexBEEF: () => 'transactionHex'
+      })),
+      fromBEEF: jest.fn().mockReturnValue({
+        outputs: [{ lockingScript: { toHex: () => 'mockLockingScript' } }]
+      })
+    }
+  }
+})
+
+jest.mock('../../script', () => {
+  const mockPushDropInstance = {
+    lock: jest.fn().mockResolvedValue({
+      toHex: () => 'lockingScriptHex'
+    }),
+    unlock: jest.fn().mockReturnValue({
+      sign: jest.fn().mockResolvedValue({
+        toHex: () => 'unlockingScriptHex'
+      })
+    })
+  }
+
+  const mockPushDrop: any = jest.fn().mockImplementation(() => mockPushDropInstance)
+  mockPushDrop.decode = jest.fn().mockReturnValue({
+    fields: [new Uint8Array([1, 2, 3, 4])]
+  })
+
+  return {
+    PushDrop: mockPushDrop,
+    // Provide LockingScript.fromHex to satisfy ContactsManager.getContacts decode path
+    LockingScript: {
+      fromHex: jest.fn().mockImplementation((hex: string) => ({ toHex: () => hex }))
+    }
+  }
+})
+
+jest.mock('../../primitives/index.js', () => {
+  return {
+    Utils: {
+      toBase64: jest.fn().mockReturnValue('mockKeyID'),
+      toArray: jest.fn().mockReturnValue(new Uint8Array()),
+      toUTF8: jest.fn().mockImplementation((data) => {
+        return new TextDecoder().decode(data)
+      }),
+      toHex: jest.fn().mockReturnValue('0102030405060708')
+    },
+    Random: jest.fn().mockReturnValue(new Uint8Array(32)),
+    PrivateKey: jest.fn().mockImplementation(() => ({
+      toPublicKey: jest.fn().mockReturnValue({
+        toString: jest.fn().mockReturnValue('mockPublicKeyString')
+      })
+    }))
+  }
+})
+
+// ----- Begin Test Suite -----
+describe('IdentityClient', () => {
+  let walletMock: Partial<WalletInterface>
+  let identityClient: IdentityClient
+
+  beforeEach(() => {
+    // Mock localStorage for Node.js environment
+    const localStorageMock = {
+      getItem: jest.fn(),
+      setItem: jest.fn(),
+      removeItem: jest.fn()
+    }
+    Object.defineProperty(global, 'localStorage', {
+      value: localStorageMock,
+      writable: true
+    })
+
+    // Create a fake wallet implementing the methods used by IdentityClient.
+    walletMock = {
+      proveCertificate: jest.fn().mockResolvedValue({ keyringForVerifier: 'fakeKeyring' }),
+      createAction: jest.fn().mockResolvedValue({
+        tx: [1, 2, 3],
+        signableTransaction: { tx: [1, 2, 3], reference: 'ref' }
+      }),
+      listCertificates: jest.fn().mockResolvedValue({ certificates: [] }),
+      acquireCertificate: jest.fn().mockResolvedValue({
+        fields: { name: 'Alice' },
+        verify: jest.fn().mockResolvedValue(true)
+      }),
+      signAction: jest.fn().mockResolvedValue({ tx: [4, 5, 6] }),
+      getNetwork: jest.fn().mockResolvedValue({ network: 'testnet' }),
+      discoverByIdentityKey: jest.fn(),
+      discoverByAttributes: jest.fn(),
+      // ContactsManager specific methods
+      listOutputs: jest.fn().mockResolvedValue({ outputs: [], BEEF: [] }),
+      createHmac: jest.fn().mockResolvedValue({ hmac: new Uint8Array([1, 2, 3, 4]) }),
+      decrypt: jest.fn().mockResolvedValue({ plaintext: new Uint8Array() }),
+      encrypt: jest.fn().mockResolvedValue({ ciphertext: new Uint8Array([5, 6, 7, 8]) })
+    }
+
+    identityClient = new IdentityClient(walletMock as WalletInterface)
+
+    // Clear any previous calls/spies.
+    jest.clearAllMocks()
+  })
+
+  describe('publiclyRevealAttributes', () => {
+    it('should throw an error if certificate has no fields', async () => {
+      const certificate = {
+        fields: {},
+        verify: jest.fn().mockResolvedValue(true)
+      } as any as WalletCertificate
+      const fieldsToReveal = ['name']
+      await expect(
+        identityClient.publiclyRevealAttributes(certificate, fieldsToReveal)
+      ).rejects.toThrow('Certificate has no fields to reveal!')
+    })
+
+    it('should throw an error if fieldsToReveal is empty', async () => {
+      const certificate = {
+        fields: { name: 'Alice' },
+        verify: jest.fn().mockResolvedValue(true)
+      } as any as WalletCertificate
+      const fieldsToReveal: string[] = []
+      await expect(
+        identityClient.publiclyRevealAttributes(certificate, fieldsToReveal)
+      ).rejects.toThrow('You must reveal at least one field!')
+    })
+
+    it('should throw an error if certificate verification fails', async () => {
+      const certificate = {
+        fields: { name: 'Alice' },
+        verify: jest.fn().mockRejectedValue(new Error('Verification error')),
+        type: 'dummyType',
+        serialNumber: 'dummySerial',
+        subject: 'dummySubject',
+        certifier: 'dummyCertifier',
+        revocationOutpoint: 'dummyRevocation',
+        signature: 'dummySignature'
+      } as any as WalletCertificate
+      const fieldsToReveal = ['name']
+      await expect(
+        identityClient.publiclyRevealAttributes(certificate, fieldsToReveal)
+      ).rejects.toThrow('Certificate verification failed!')
+    })
+
+    it('should publicly reveal attributes successfully', async () => {
+      // Prepare a dummy certificate with all required properties.
+      const certificate = {
+        fields: { name: 'Alice' },
+        verify: jest.fn().mockResolvedValue(true), // this property is not used since the Certificate is re-instantiated
+        type: 'xCert',
+        serialNumber: '12345',
+        subject: 'abcdef1234567890',
+        certifier: 'CertifierX',
+        revocationOutpoint: 'outpoint1',
+        signature: 'signature1'
+      } as any as WalletCertificate
+
+      // Ensure that Certificate.verify (called on the re-instantiated Certificate)
+      // resolves successfully.
+      jest.spyOn(Certificate.prototype, 'verify').mockResolvedValue(false)
+
+      const fieldsToReveal = ['name']
+      const result = await identityClient.publiclyRevealAttributes(certificate, fieldsToReveal)
+      expect(result).toEqual('broadcastResult')
+
+      // Validate that proveCertificate was called with the proper arguments.
+      expect(walletMock.proveCertificate).toHaveBeenCalledWith({
+        certificate,
+        fieldsToReveal,
+        verifier: expect.any(String)
+      }, undefined)
+
+      // Validate that createAction was called.
+      expect(walletMock.createAction).toHaveBeenCalled()
+    })
+  })
+
+  describe('resolveByIdentityKey', () => {
+    it('should return parsed identities from discovered certificates', async () => {
+      const dummyCertificate = {
+        type: KNOWN_IDENTITY_TYPES.xCert,
+        subject: 'abcdef1234567890',
+        decryptedFields: {
+          userName: 'Alice',
+          profilePhoto: 'alicePhotoUrl'
+        },
+        certifierInfo: {
+          name: 'CertifierX',
+          iconUrl: 'certifierIconUrl'
+        }
+      }
+      // Mock discoverByIdentityKey to return a certificate list.
+      walletMock.discoverByIdentityKey = jest.fn().mockResolvedValue({ certificates: [dummyCertificate] })
+
+      const identities = await identityClient.resolveByIdentityKey({ identityKey: 'dummyKey' })
+      expect(walletMock.discoverByIdentityKey).toHaveBeenCalledWith({ identityKey: 'dummyKey' }, undefined)
+      expect(identities).toHaveLength(1)
+      expect(identities[0]).toEqual({
+        name: 'Alice',
+        avatarURL: 'alicePhotoUrl',
+        abbreviatedKey: 'abcdef1234...',
+        identityKey: 'abcdef1234567890',
+        badgeLabel: 'X account certified by CertifierX',
+        badgeIconURL: 'certifierIconUrl',
+        badgeClickURL: 'https://socialcert.net'
+      })
+    })
+
+    it('should prioritize contacts over discovered identities for same identity key', async () => {
+      const contact = {
+        name: 'Alice Smith (Personal Contact)',
+        identityKey: 'alice-identity-key',
+        avatarURL: 'alice-avatar.png',
+        abbreviatedKey: 'alice-i...',
+        badgeIconURL: '',
+        badgeLabel: '',
+        badgeClickURL: ''
+      }
+
+      const discoveredCertificate = {
+        type: KNOWN_IDENTITY_TYPES.xCert,
+        subject: 'alice-identity-key',
+        decryptedFields: {
+          userName: 'Alice Public',
+          profilePhoto: 'public-photo.png'
+        },
+        certifierInfo: {
+          name: 'CertifierX',
+          iconUrl: 'certifier-icon.png'
+        }
+      }
+
+      // Mock ContactsManager to return contact for the specific identity key
+      const mockContactsManager = identityClient['contactsManager']
+      mockContactsManager.getContacts = jest.fn().mockResolvedValue([contact])
+      walletMock.discoverByIdentityKey = jest.fn().mockResolvedValue({ certificates: [discoveredCertificate] })
+
+      const identities = await identityClient.resolveByIdentityKey({ identityKey: 'alice-identity-key' })
+
+      expect(identities).toHaveLength(1)
+      expect(identities[0].name).toBe('Alice Smith (Personal Contact)') // Contact should be returned, not discovered identity
+      // Wallet method should not be called when contact is found
+      expect(walletMock.discoverByIdentityKey).not.toHaveBeenCalled()
+    })
+  })
+
+  it('should throw if createAction returns no tx', async () => {
+    const certificate = {
+      fields: { name: 'Alice' },
+      verify: jest.fn().mockResolvedValue(true),
+      type: 'xCert',
+      serialNumber: '12345',
+      subject: 'abcdef1234567890',
+      certifier: 'CertifierX',
+      revocationOutpoint: 'outpoint1',
+      signature: 'signature1'
+    } as any as WalletCertificate
+
+    jest.spyOn(Certificate.prototype, 'verify').mockResolvedValue(false)
+
+    // Simulate createAction returning an object with tx = undefined
+    walletMock.createAction = jest.fn().mockResolvedValue({
+      tx: undefined,
+      signableTransaction: { tx: undefined, reference: 'ref' }
+    })
+
+    const fieldsToReveal = ['name']
+
+    await expect(
+      identityClient.publiclyRevealAttributes(certificate, fieldsToReveal)
+    ).rejects.toThrow('Public reveal failed: failed to create action!')
+  })
+
+  describe('resolveByAttributes', () => {
+    beforeEach(() => {
+      // Mock both getContacts and discoverByAttributes
+      walletMock.discoverByAttributes = jest.fn().mockResolvedValue({ certificates: [] })
+      identityClient.getContacts = jest.fn().mockResolvedValue([])
+    })
+
+    it('should return parsed identities from discovered certificates only', async () => {
+      const dummyCertificate = {
+        type: KNOWN_IDENTITY_TYPES.emailCert,
+        subject: 'alice-identity-key',
+        decryptedFields: {
+          identityKey: 'alice-identity-key',
+          email: 'alice@example.com'
+        },
+        certifierInfo: {
+          name: 'Email Certifier',
+          iconUrl: 'certifier-icon.png',
+          publicKey: 'certifier-public-key',
+          website: 'https://certifier.example.com'
+        }
+      }
+
+      walletMock.discoverByAttributes = jest.fn().mockResolvedValue({ certificates: [dummyCertificate] })
+
+      const identities = await identityClient.resolveByAttributes({ attributes: { email: 'alice@example.com' } })
+      expect(identities).toHaveLength(1)
+      expect(identities[0].name).toBe('alice@example.com')
+    })
+
+    it('should prioritize contacts over discovered identities for same identity key', async () => {
+      const contact = {
+        name: 'Alice Smith (Personal)',
+        identityKey: 'alice-identity-key',
+        avatarURL: 'alice-avatar.png',
+        abbreviatedKey: 'alice-i...',
+        badgeIconURL: '',
+        badgeLabel: '',
+        badgeClickURL: ''
+      }
+
+      const discoveredCertificate = {
+        type: KNOWN_IDENTITY_TYPES.emailCert,
+        subject: 'alice-identity-key',
+        decryptedFields: {
+          email: 'alice@example.com'
+        },
+        certifierInfo: {
+          name: 'Email Certifier',
+          iconUrl: 'certifier-icon.png',
+          publicKey: 'certifier-public-key',
+          website: 'https://certifier.example.com'
+        }
+      }
+
+      // Mock the ContactsManager's getContacts method instead of the IdentityClient method
+      const mockContactsManager = identityClient['contactsManager']
+      mockContactsManager.getContacts = jest.fn().mockResolvedValue([contact])
+      walletMock.discoverByAttributes = jest.fn().mockResolvedValue({ certificates: [discoveredCertificate] })
+
+      const identities = await identityClient.resolveByAttributes({ attributes: { name: 'Alice' } })
+
+      expect(identities).toHaveLength(1)
+      expect(identities[0].name).toBe('Alice Smith (Personal)') // Contact should be returned, not discovered identity
+    })
+
+    it('should return empty array for empty search terms', async () => {
+      const contacts = [
+        {
+          name: 'Alice Smith',
+          identityKey: 'alice-key',
+          avatarURL: '', abbreviatedKey: 'alice-i...', badgeIconURL: '', badgeLabel: '', badgeClickURL: ''
+        }
+      ]
+
+      const mockContactsManager = identityClient['contactsManager']
+      mockContactsManager.getContacts = jest.fn().mockResolvedValue(contacts)
+
+      const identities = await identityClient.resolveByAttributes({ attributes: { name: '', email: '   ' } })
+
+      expect(identities).toHaveLength(0)
+    })
+
+    it('should return only discovered identities when overrideWithContacts is false', async () => {
+      const contacts = [
+        {
+          name: 'Alice Smith (Personal)',
+          identityKey: 'alice-key',
+          avatarURL: '', abbreviatedKey: 'alice-i...', badgeIconURL: '', badgeLabel: '', badgeClickURL: ''
+        }
+      ]
+
+      const discoveredCertificate = {
+        type: KNOWN_IDENTITY_TYPES.emailCert,
+        subject: 'alice-key', // Same key as contact but should not be filtered out
+        decryptedFields: {
+          email: 'alice@example.com'
+        },
+        certifierInfo: {
+          name: 'Email Certifier',
+          iconUrl: 'certifier-icon.png',
+          publicKey: 'certifier-public-key',
+          website: 'https://certifier.example.com'
+        }
+      }
+
+      const mockContactsManager = identityClient['contactsManager']
+      mockContactsManager.getContacts = jest.fn().mockResolvedValue(contacts)
+      walletMock.discoverByAttributes = jest.fn().mockResolvedValue({ certificates: [discoveredCertificate] })
+
+      // With overrideWithContacts = false, should ignore contacts entirely
+      const identities = await identityClient.resolveByAttributes(
+        { attributes: { name: 'Alice' } },
+        false
+      )
+
+      expect(identities).toHaveLength(1)
+      expect(identities[0].name).toBe('alice@example.com') // Should be discovered identity, not contact
+      expect(mockContactsManager.getContacts).not.toHaveBeenCalled() // Should not fetch contacts
+    })
+  })
+
+  describe('parseIdentity', () => {
+    it('should correctly parse an xCert identity', () => {
+      const dummyCertificate = {
+        type: KNOWN_IDENTITY_TYPES.xCert,
+        subject: 'abcdef1234567890',
+        decryptedFields: {
+          userName: 'Alice',
+          profilePhoto: 'alicePhotoUrl'
+        },
+        certifierInfo: {
+          name: 'CertifierX',
+          iconUrl: 'certifierIconUrl'
+        }
+      }
+      const identity = IdentityClient.parseIdentity(dummyCertificate as unknown as any)
+      expect(identity).toEqual({
+        name: 'Alice',
+        avatarURL: 'alicePhotoUrl',
+        abbreviatedKey: 'abcdef1234...',
+        identityKey: 'abcdef1234567890',
+        badgeLabel: 'X account certified by CertifierX',
+        badgeIconURL: 'certifierIconUrl',
+        badgeClickURL: 'https://socialcert.net'
+      })
+    })
+
+    it('should return default identity for unknown type', () => {
+      const dummyCertificate = {
+        type: 'unknownType',
+        subject: '',
+        decryptedFields: {
+          profilePhoto: 'defaultPhoto'
+        },
+        certifierInfo: {}
+      }
+      const identity = IdentityClient.parseIdentity(dummyCertificate as any)
+      expect(identity).toEqual({
+        name: defaultIdentity.name,
+        avatarURL: 'defaultPhoto',
+        abbreviatedKey: '',
+        identityKey: '',
+        badgeLabel: defaultIdentity.badgeLabel,
+        badgeIconURL: defaultIdentity.badgeIconURL,
+        badgeClickURL: defaultIdentity.badgeClickURL
+      })
+    })
+  })
+
+  describe('ContactsManager Integration', () => {
+    const mockContact = {
+      name: 'Alice Smith',
+      identityKey: 'abcdef1234567890abcdef1234567890',
+      avatarURL: 'https://example.com/avatar.jpg',
+      abbreviatedKey: 'abcdef1234...',
+      badgeLabel: 'Verified User',
+      badgeIconURL: 'https://example.com/badge.png',
+      badgeClickURL: 'https://example.com/verify'
+    }
+
+    const mockContactWithMetadata = {
+      ...mockContact,
+      metadata: { notes: 'Met at conference' }
+    }
+
+    beforeEach(() => {
+      // Reset wallet mocks for each test
+      jest.clearAllMocks()
+    })
+
+    describe('saveContact', () => {
+      it('should save a contact without metadata', async () => {
+        // Mock empty contacts list (new contact)
+        ; (walletMock.listOutputs as jest.Mock).mockResolvedValue({
+          outputs: [],
+          BEEF: []
+        })
+
+        await identityClient.saveContact(mockContact)
+
+        // Verify HMAC was created for tagging
+        expect(walletMock.createHmac).toHaveBeenCalledWith({
+          protocolID: [2, 'contact'],
+          keyID: mockContact.identityKey,
+          counterparty: 'self',
+          data: expect.any(Uint8Array)
+        }, undefined)
+
+        // Verify contact data was encrypted
+        expect(walletMock.encrypt).toHaveBeenCalledWith({
+          plaintext: expect.any(Uint8Array),
+          protocolID: [2, 'contact'],
+          keyID: expect.any(String),
+          counterparty: 'self'
+        }, undefined)
+
+        // Verify new contact transaction was created
+        expect(walletMock.createAction).toHaveBeenCalledWith(
+          expect.objectContaining({
+            description: 'Add Contact',
+            outputs: expect.arrayContaining([
+              expect.objectContaining({
+                basket: 'contacts',
+                outputDescription: `Contact: ${mockContact.name}`
+              })
+            ])
+          }),
+          undefined
+        )
+
+        // Verify contact is now available from cache
+        const contacts = await identityClient.getContacts()
+        expect(contacts).toContainEqual(expect.objectContaining({
+          name: mockContact.name,
+          identityKey: mockContact.identityKey
+        }))
+      })
+
+      it('should save a contact with metadata', async () => {
+        ; (walletMock.listOutputs as jest.Mock).mockResolvedValue({
+          outputs: [],
+          BEEF: []
+        })
+
+        await identityClient.saveContact(mockContact, { notes: 'Met at conference' })
+
+        // Verify contact with metadata is available from cache
+        const contacts = await identityClient.getContacts()
+        expect(contacts).toContainEqual(expect.objectContaining({
+          name: mockContact.name,
+          identityKey: mockContact.identityKey,
+          metadata: { notes: 'Met at conference' }
+        }))
+      })
+
+      it('should update existing contact', async () => {
+        // First save a contact to establish it exists
+        ; (walletMock.listOutputs as jest.Mock).mockResolvedValueOnce({
+          outputs: [],
+          BEEF: []
+        })
+        await identityClient.saveContact(mockContact)
+
+        // Now mock finding the existing contact for update
+        const existingOutput = {
+          outpoint: 'txid.0',
+          customInstructions: JSON.stringify({ keyID: 'existingKeyID' })
+        }
+
+          ; (walletMock.listOutputs as jest.Mock).mockResolvedValueOnce({
+            outputs: [existingOutput],
+            BEEF: [1, 2, 3]
+          })
+
+          ; (walletMock.decrypt as jest.Mock).mockResolvedValue({
+            plaintext: new TextEncoder().encode(JSON.stringify(mockContact))
+          })
+
+        const updatedContact = { ...mockContact, name: 'Alice Updated' }
+        await identityClient.saveContact(updatedContact)
+
+        // Should create update action since contact exists
+        expect(walletMock.createAction).toHaveBeenLastCalledWith(
+          expect.objectContaining({
+            description: 'Update Contact',
+            inputBEEF: [1, 2, 3],
+            inputs: expect.arrayContaining([
+              expect.objectContaining({
+                outpoint: 'txid.0'
+              })
+            ])
+          }),
+          undefined
+        )
+      })
+    })
+
+    describe('getContacts', () => {
+      it('should return cached contacts when available', async () => {
+        // First save a contact to populate cache
+        ; (walletMock.listOutputs as jest.Mock).mockResolvedValue({
+          outputs: [],
+          BEEF: []
+        })
+        await identityClient.saveContact(mockContact)
+
+        // Clear mocks to verify cache is used
+        jest.clearAllMocks()
+
+        // Get contacts should use cache and not call wallet
+        const result = await identityClient.getContacts()
+
+        expect(result).toContainEqual(expect.objectContaining({
+          name: mockContact.name,
+          identityKey: mockContact.identityKey
+        }))
+        expect(walletMock.listOutputs).not.toHaveBeenCalled()
+      })
+
+      it('should load contacts from wallet basket when cache is empty', async () => {
+        const mockOutput = {
+          outpoint: 'txid.0',
+          customInstructions: JSON.stringify({ keyID: 'mockKeyID' }),
+          lockingScript: 'lockingScriptHex'
+        }
+
+          ; (walletMock.listOutputs as jest.Mock).mockResolvedValue({
+            outputs: [mockOutput],
+            BEEF: [1, 2, 3]
+          })
+
+          ; (walletMock.decrypt as jest.Mock).mockResolvedValue({
+            plaintext: new TextEncoder().encode(JSON.stringify(mockContact))
+          })
+
+        const result = await identityClient.getContacts()
+
+        expect(result).toEqual([mockContact])
+        expect(walletMock.listOutputs).toHaveBeenCalledWith({
+          basket: 'contacts',
+          include: 'locking scripts',
+          includeCustomInstructions: true,
+          tags: [],
+          limit: 1000
+        }, undefined)
+
+        // Verify subsequent call uses cache
+        jest.clearAllMocks()
+        const cachedResult = await identityClient.getContacts()
+        expect(cachedResult).toEqual([mockContact])
+        expect(walletMock.listOutputs).not.toHaveBeenCalled()
+      })
+
+      it('should force refresh when requested', async () => {
+        // First populate cache
+        ; (walletMock.listOutputs as jest.Mock).mockResolvedValue({
+          outputs: [],
+          BEEF: []
+        })
+        await identityClient.saveContact(mockContact)
+
+          // Mock empty result for force refresh
+          ; (walletMock.listOutputs as jest.Mock).mockResolvedValue({
+            outputs: [],
+            BEEF: []
+          })
+
+        const result = await identityClient.getContacts(undefined, true)
+
+        expect(result).toEqual([])
+        expect(walletMock.listOutputs).toHaveBeenCalled()
+      })
+
+      it('should filter by identity key when provided', async () => {
+        // Save two different contacts
+        ; (walletMock.listOutputs as jest.Mock).mockResolvedValue({
+          outputs: [],
+          BEEF: []
+        })
+        await identityClient.saveContact(mockContact)
+
+        const otherContact = { ...mockContact, identityKey: 'different-key', name: 'Bob' }
+        await identityClient.saveContact(otherContact)
+
+        // Filter by specific identity key
+        const result = await identityClient.getContacts(mockContact.identityKey)
+
+        expect(result).toEqual([expect.objectContaining({
+          name: mockContact.name,
+          identityKey: mockContact.identityKey
+        })])
+        expect(result).toHaveLength(1)
+      })
+
+      it('should throw error on listOutputs failure', async () => {
+        ; (walletMock.listOutputs as jest.Mock).mockRejectedValue(
+          new Error('List outputs error')
+        )
+
+        await expect(
+          identityClient.getContacts(undefined, true)
+        ).rejects.toThrow('List outputs error')
+      })
+    })
+
+    describe('removeContact', () => {
+      it('should remove contact from cache and spend UTXO', async () => {
+        // First save two contacts
+        ; (walletMock.listOutputs as jest.Mock).mockResolvedValue({
+          outputs: [],
+          BEEF: []
+        })
+        await identityClient.saveContact(mockContact)
+
+        const otherContact = { ...mockContact, identityKey: 'other-key', name: 'Bob' }
+        await identityClient.saveContact(otherContact)
+
+        // Mock finding the contact to remove
+        const mockOutput = {
+          outpoint: 'txid.0',
+          customInstructions: JSON.stringify({ keyID: 'mockKeyID' })
+        }
+
+          ; (walletMock.listOutputs as jest.Mock).mockResolvedValue({
+            outputs: [mockOutput],
+            BEEF: [1, 2, 3]
+          })
+
+          ; (walletMock.decrypt as jest.Mock).mockResolvedValue({
+            plaintext: new TextEncoder().encode(JSON.stringify(mockContact))
+          })
+
+        await identityClient.removeContact(mockContact.identityKey)
+
+        // Verify delete action was created
+        expect(walletMock.createAction).toHaveBeenLastCalledWith(
+          expect.objectContaining({
+            description: 'Delete Contact',
+            inputBEEF: [1, 2, 3],
+            inputs: expect.arrayContaining([
+              expect.objectContaining({
+                outpoint: 'txid.0'
+              })
+            ]),
+            outputs: [] // No outputs for deletion
+          }),
+          undefined
+        )
+
+        // Verify contact is removed from cache
+        const remainingContacts = await identityClient.getContacts()
+        expect(remainingContacts).not.toContainEqual(
+          expect.objectContaining({ identityKey: mockContact.identityKey })
+        )
+      })
+
+      it('should handle contact not found gracefully', async () => {
+        ; (walletMock.listOutputs as jest.Mock).mockResolvedValue({
+          outputs: [],
+          BEEF: []
+        })
+
+        // Should not throw when contact doesn't exist
+        await expect(
+          identityClient.removeContact('non-existent-key')
+        ).resolves.toBeUndefined()
+
+        // Should not call createAction since no contact found
+        expect(walletMock.createAction).not.toHaveBeenCalled()
+      })
+    })
+  })
+})