@bsv/sdk 1.3.12 → 1.3.14

package/src/auth/__tests/Peer.test.ts

@@ -1,13 +1,14 @@
-import { Peer } from "../../../dist/cjs/src/auth/Peer.js"
-import { AuthMessage, Transport } from "../../../dist/cjs/src/auth/types.js"
+import { Peer } from '../../auth/Peer.js'
+import { AuthMessage, Transport } from '../../auth/types.js'
 import { jest } from '@jest/globals'
-import { Wallet } from "../../../dist/cjs/src/wallet/Wallet.interfaces.js"
-import { ProtoWallet } from '../../../dist/cjs/src/wallet/index.js'
-import { Utils, PrivateKey, SymmetricKey } from '../../../dist/cjs/src/primitives/index.js'
-import { VerifiableCertificate, } from "../../../dist/cjs/src/auth/certificates/VerifiableCertificate.js"
-import { MasterCertificate } from '../../../dist/cjs/src/auth/certificates/MasterCertificate.js'
-import { getVerifiableCertificates } from '../../../dist/cjs/src/auth/utils/getVerifiableCertificates.js'
-jest.mock('../../../dist/cjs/src/auth/utils/getVerifiableCertificates.js')
+import { WalletInterface } from '../../wallet/Wallet.interfaces.js'
+import { Utils, PrivateKey } from '../../primitives/index.js'
+import { VerifiableCertificate } from '../../auth/certificates/VerifiableCertificate.js'
+import { MasterCertificate } from '../../auth/certificates/MasterCertificate.js'
+import { getVerifiableCertificates } from '../../auth/utils/getVerifiableCertificates.js'
+import { CompletedProtoWallet } from '../../../mod.js'
+
+jest.mock('../../auth/utils/getVerifiableCertificates')
 
 class LocalTransport implements Transport {
   private peerTransport?: LocalTransport
@@ -19,28 +20,35 @@ class LocalTransport implements Transport {
   }
 
   async send(message: AuthMessage): Promise<void> {
-    if (this.peerTransport && this.peerTransport.onDataCallback) {
+    if (
+      this.peerTransport?.onDataCallback !== undefined &&
+      this.peerTransport?.onDataCallback !== null
+    ) {
       // Simulate message delivery by calling the onData callback of the peer
       this.peerTransport.onDataCallback(message)
     } else {
-      throw new Error("Peer transport is not connected or not listening for data.")
+      throw new Error(
+        'Peer transport is not connected or not listening for data.'
+      )
     }
   }
 
-  async onData(callback: (message: AuthMessage) => Promise<void>): Promise<void> {
+  async onData(
+    callback: (message: AuthMessage) => void
+  ): Promise<void> {
     this.onDataCallback = callback
   }
 }
 
 describe('Peer class mutual authentication and certificate exchange', () => {
-  let walletA: Wallet, walletB: Wallet
+  let walletA: WalletInterface, walletB: WalletInterface
   let transportA: LocalTransport, transportB: LocalTransport
   let alice: Peer, bob: Peer
   let certificatesReceivedByAlice: VerifiableCertificate[] | undefined
   let certificatesReceivedByBob: VerifiableCertificate[] | undefined
 
   const certificateType = Utils.toBase64(new Array(32).fill(1))
-  const certificateSerialNumber = Utils.toBase64(new Array(32).fill(2))
+  // const certificateSerialNumber = Utils.toBase64(new Array(32).fill(2))
   const certifierPrivateKey = PrivateKey.fromRandom()
   const certifierPublicKey = certifierPrivateKey.toPublicKey().toString()
   const certificatesToRequest = {
@@ -48,24 +56,37 @@ describe('Peer class mutual authentication and certificate exchange', () => {
     types: { [certificateType]: ['name', 'email'] }
   }
 
-  const aliceFields = { name: 'Alice', email: 'alice@example.com', libraryCardNumber: 'A123456' }
-  const bobFields = { name: 'Bob', email: 'bob@example.com', libraryCardNumber: 'B654321' }
+  const aliceFields = {
+    name: 'Alice',
+    email: 'alice@example.com',
+    libraryCardNumber: 'A123456'
+  }
+  const bobFields = {
+    name: 'Bob',
+    email: 'bob@example.com',
+    libraryCardNumber: 'B654321'
+  }
 
-  async function createMasterCertificate(subjectWallet: Wallet, fields: Record<string, string>) {
-    const subjectPubKey = (await subjectWallet.getPublicKey({ identityKey: true })).publicKey
-    const certifierWallet = new ProtoWallet(certifierPrivateKey)
+  async function createMasterCertificate(
+    subjectWallet: WalletInterface,
+    fields: Record<string, string>
+  ): Promise<MasterCertificate> {
+    const subjectPubKey = (
+      await subjectWallet.getPublicKey({ identityKey: true })
+    ).publicKey
+    const certifierWallet = new CompletedProtoWallet(certifierPrivateKey)
 
     // Issue a new MasterCertificate for the subject (e.g. Alice/Bob)
-    const masterCertificate = await MasterCertificate.issueCertificateForSubject(
-      certifierWallet,
-      subjectPubKey,
-      fields,
-      certificateType,
-      async () => 'revocationOutpoint' // or any revocation outpoint logic you want
-    )
-
-    // For test consistency, override the automatically generated serialNumber 
-    // with the globally used 'certificateSerialNumber' and re-sign:
+    const masterCertificate =
+      await MasterCertificate.issueCertificateForSubject(
+        certifierWallet,
+        subjectPubKey,
+        fields,
+        certificateType,
+        async () => 'revocationOutpoint' // or any revocation outpoint logic you want
+      )
+
+    // For test consistency, you could override the auto-generated serialNumber:
     // masterCertificate.signature = undefined
     // masterCertificate.serialNumber = certificateSerialNumber
     // await masterCertificate.sign(certifierWallet)
@@ -75,11 +96,15 @@ describe('Peer class mutual authentication and certificate exchange', () => {
 
   async function createVerifiableCertificate(
     masterCertificate: MasterCertificate,
-    wallet: Wallet,
+    wallet: WalletInterface,
     verifierIdentityKey: string,
     fieldsToReveal: string[]
   ): Promise<VerifiableCertificate> {
-    const certifierWallet = new ProtoWallet(certifierPrivateKey)
+    const certifierWallet = new CompletedProtoWallet(certifierPrivateKey)
+
+    if (certifierWallet.keyDeriver === undefined) {
+      throw new Error('KeyDeriver must be defined for test!')
+    }
 
     const keyringForVerifier = await MasterCertificate.createKeyringForVerifier(
       wallet,
@@ -106,14 +131,25 @@ describe('Peer class mutual authentication and certificate exchange', () => {
     aliceRequests: boolean,
     bobRequests: boolean,
     options: {
-      aliceCertsToRequest?: typeof certificatesToRequest,
+      aliceCertsToRequest?: typeof certificatesToRequest
       bobCertsToRequest?: typeof certificatesToRequest
     } = {}
-  ) {
-    const { aliceCertsToRequest = certificatesToRequest, bobCertsToRequest = certificatesToRequest } = options
+  ): any {
+    const {
+      aliceCertsToRequest = certificatesToRequest,
+      bobCertsToRequest = certificatesToRequest
+    } = options
 
-    alice = new Peer(walletA, transportA, aliceRequests ? aliceCertsToRequest : undefined)
-    bob = new Peer(walletB, transportB, bobRequests ? bobCertsToRequest : undefined)
+    alice = new Peer(
+      walletA,
+      transportA,
+      aliceRequests ? aliceCertsToRequest : undefined
+    )
+    bob = new Peer(
+      walletB,
+      transportB,
+      bobRequests ? bobCertsToRequest : undefined
+    )
 
     const aliceReceivedCertificates = new Promise<void>((resolve) => {
       alice.listenForCertificatesReceived((senderPublicKey, certificates) => {
@@ -132,20 +168,26 @@ describe('Peer class mutual authentication and certificate exchange', () => {
     return { aliceReceivedCertificates, bobReceivedCertificates }
   }
 
-  function mockGetVerifiableCertificates(
+  async function mockGetVerifiableCertificates(
     aliceCertificate: VerifiableCertificate | undefined,
     bobCertificate: VerifiableCertificate | undefined,
     alicePubKey: string,
     bobPubKey: string
-  ) {
-    (getVerifiableCertificates as jest.Mock).mockImplementation((wallet, _, verifierIdentityKey) => {
-      if (wallet === walletA && verifierIdentityKey === bobPubKey) {
-        return aliceCertificate ? Promise.resolve([aliceCertificate]) : Promise.resolve([])
-      } else if (wallet === walletB && verifierIdentityKey === alicePubKey) {
-        return bobCertificate ? Promise.resolve([bobCertificate]) : Promise.resolve([])
+  ): Promise<any> {
+    ; (getVerifiableCertificates as jest.Mock).mockImplementation(
+      async (wallet, _, verifierIdentityKey) => {
+        if (wallet === walletA && verifierIdentityKey === bobPubKey) {
+          return aliceCertificate !== null && aliceCertificate !== undefined
+            ? await Promise.resolve([aliceCertificate])
+            : await Promise.resolve([])
+        } else if (wallet === walletB && verifierIdentityKey === alicePubKey) {
+          return bobCertificate !== null && bobCertificate !== undefined
+            ? await Promise.resolve([bobCertificate])
+            : await Promise.resolve([])
+        }
+        return await Promise.resolve([])
       }
-      return Promise.resolve([])
-    });
+    )
   }
 
   beforeEach(async () => {
@@ -156,22 +198,27 @@ describe('Peer class mutual authentication and certificate exchange', () => {
     certificatesReceivedByAlice = []
     certificatesReceivedByBob = []
 
-    walletA = new ProtoWallet(PrivateKey.fromRandom())
-    walletB = new ProtoWallet(PrivateKey.fromRandom())
+    walletA = new CompletedProtoWallet(PrivateKey.fromRandom())
+    walletB = new CompletedProtoWallet(PrivateKey.fromRandom())
   })
 
   it('Neither Alice nor Bob request certificates, mutual authentication completes successfully', async () => {
-    const { aliceReceivedCertificates, bobReceivedCertificates } = setupPeers(false, false)
+    setupPeers(
+      false,
+      false
+    )
 
     const bobReceivedGeneralMessage = new Promise<void>((resolve) => {
-      bob.listenForGeneralMessages(async (senderPublicKey, payload) => {
-        console.log('Bob received message:', Utils.toUTF8(payload))
-        await bob.toPeer(Utils.toArray('Hello Alice!'), senderPublicKey)
-        resolve()
+      bob.listenForGeneralMessages((senderPublicKey, payload) => {
+        (async () => {
+          console.log('Bob received message:', Utils.toUTF8(payload))
+          await bob.toPeer(Utils.toArray('Hello Alice!'), senderPublicKey)
+          resolve()
+        })().catch(e => console.log(e))
       })
     })
     const aliceReceivedGeneralMessage = new Promise<void>((resolve) => {
-      alice.listenForGeneralMessages(async (senderPublicKey, payload) => {
+      alice.listenForGeneralMessages((senderPublicKey, payload) => {
         console.log('Alice received message:', Utils.toUTF8(payload))
         resolve()
       })
@@ -186,10 +233,15 @@ describe('Peer class mutual authentication and certificate exchange', () => {
   }, 15000)
 
   it('Bob requests certificates from Alice, Alice does not request any from Bob', async () => {
-    const alicePubKey = (await walletA.getPublicKey({ identityKey: true })).publicKey
-    const bobPubKey = (await walletB.getPublicKey({ identityKey: true })).publicKey
+    const alicePubKey = (await walletA.getPublicKey({ identityKey: true }))
+      .publicKey
+    const bobPubKey = (await walletB.getPublicKey({ identityKey: true }))
+      .publicKey
 
-    const aliceMasterCertificate = await createMasterCertificate(walletA, aliceFields)
+    const aliceMasterCertificate = await createMasterCertificate(
+      walletA,
+      aliceFields
+    )
     const aliceVerifiableCertificate = await createVerifiableCertificate(
       aliceMasterCertificate,
       walletA,
@@ -198,22 +250,34 @@ describe('Peer class mutual authentication and certificate exchange', () => {
     )
 
     const { bobReceivedCertificates } = setupPeers(false, true)
-    mockGetVerifiableCertificates(aliceVerifiableCertificate, undefined, alicePubKey, bobPubKey)
+    await mockGetVerifiableCertificates(
+      aliceVerifiableCertificate,
+      undefined,
+      alicePubKey,
+      bobPubKey
+    )
 
     const bobReceivedGeneralMessage = new Promise<void>((resolve) => {
-      bob.listenForGeneralMessages(async (senderPublicKey, payload) => {
-        await bobReceivedCertificates
-        if (certificatesReceivedByBob?.length !== 0) {
-          certificatesReceivedByBob?.forEach(async cert => {
-            // Decrypt to ensure it has the correct fields
-            const decryptedFields = await cert.decryptFields(walletB)
-            if (cert.certifier !== 'bob') {
-              console.log('Bob accepted the message:', Utils.toUTF8(payload))
-              console.log('Decrypted fields:', decryptedFields)
+      bob.listenForGeneralMessages((senderPublicKey, payload) => {
+        // Wrap async logic in an IIFE so the callback remains synchronous.
+        (async () => {
+          await bobReceivedCertificates
+
+          if (certificatesReceivedByBob !== undefined && certificatesReceivedByBob.length > 0) {
+            // Use a for...of loop instead of forEach with an async callback.
+            for (const cert of certificatesReceivedByBob) {
+              // Decrypt to ensure it has the correct fields.
+              const decryptedFields = await cert.decryptFields(walletB)
+              if (cert.certifier !== 'bob') {
+                console.log('Bob accepted the message:', Utils.toUTF8(payload))
+                console.log('Decrypted fields:', decryptedFields)
+              }
             }
-          })
-        }
-        resolve()
+          }
+          resolve()
+        })().catch((e) => {
+          console.error(e)
+        })
       })
     })
 
@@ -225,11 +289,16 @@ describe('Peer class mutual authentication and certificate exchange', () => {
   }, 15000)
 
   it('Alice requests Bob to present his library card before lending him a book', async () => {
-    const alicePubKey = (await walletA.getPublicKey({ identityKey: true })).publicKey
-    const bobPubKey = (await walletB.getPublicKey({ identityKey: true })).publicKey
+    const alicePubKey = (await walletA.getPublicKey({ identityKey: true }))
+      .publicKey
+    const bobPubKey = (await walletB.getPublicKey({ identityKey: true }))
+      .publicKey
 
     // Bob's certificate includes his library card number
-    const bobMasterCertificate = await createMasterCertificate(walletB, bobFields)
+    const bobMasterCertificate = await createMasterCertificate(
+      walletB,
+      bobFields
+    )
     const bobVerifiableCertificate = await createVerifiableCertificate(
       bobMasterCertificate,
       walletB,
@@ -243,22 +312,36 @@ describe('Peer class mutual authentication and certificate exchange', () => {
       types: { [certificateType]: ['libraryCardNumber'] }
     }
 
-    const { aliceReceivedCertificates } = setupPeers(true, false, { aliceCertsToRequest: aliceCertificatesToRequest })
-    mockGetVerifiableCertificates(undefined, bobVerifiableCertificate, alicePubKey, bobPubKey)
+    const { aliceReceivedCertificates } = setupPeers(true, false, {
+      aliceCertsToRequest: aliceCertificatesToRequest
+    })
+    await mockGetVerifiableCertificates(
+      undefined,
+      bobVerifiableCertificate,
+      alicePubKey,
+      bobPubKey
+    )
 
     const aliceAcceptedLibraryCard = jest.fn()
 
-    alice.listenForCertificatesReceived(async (senderPublicKey, certificates) => {
-      for (const cert of certificates) {
-        // Decrypt Bob's certificate fields
-        const decryptedFields = await cert.decryptFields(walletA)
+    alice.listenForCertificatesReceived((senderPublicKey, certificates) => {
+      (async () => {
+        for (const cert of certificates) {
+          // Decrypt Bob's certificate fields
+          const decryptedFields = await cert.decryptFields(walletA)
 
-        // Check and use the decrypted fields
-        if (Object.keys(decryptedFields).length !== 0 && decryptedFields.libraryCardNumber) {
-          console.log(`Alice received Bob's library card number: ${decryptedFields.libraryCardNumber}`)
-          aliceAcceptedLibraryCard()
+          // Check and use the decrypted fields
+          if (
+            Object.keys(decryptedFields).length !== 0 &&
+            typeof decryptedFields.libraryCardNumber !== 'undefined'
+          ) {
+            console.log(
+              `Alice received Bob's library card number: ${decryptedFields.libraryCardNumber}`
+            )
+            aliceAcceptedLibraryCard()
+          }
         }
-      }
+      })().catch(e => { console.error(e) })
     })
 
     const bobReceivedGeneralMessage = new Promise<void>((resolve) => {
@@ -269,20 +352,26 @@ describe('Peer class mutual authentication and certificate exchange', () => {
     })
 
     // Alice sends a message to Bob requesting his library card before lending him a book
-    await alice.toPeer(Utils.toArray('Please present your library card to borrow a book.'))
+    await alice.toPeer(
+      Utils.toArray('Please present your library card to borrow a book.')
+    )
     await aliceReceivedCertificates
     await bobReceivedGeneralMessage
 
     expect(aliceAcceptedLibraryCard).toHaveBeenCalled()
     expect(certificatesReceivedByAlice).toEqual([bobVerifiableCertificate])
-    expect(certificatesReceivedByBob).toEqual([]) // Bob did not request any certificates
+    expect(certificatesReceivedByBob).toEqual([])
   }, 15000)
 
   it('Bob requests additional certificates from Alice after initial communication', async () => {
-    const alicePubKey = (await walletA.getPublicKey({ identityKey: true })).publicKey
-    const bobPubKey = (await walletB.getPublicKey({ identityKey: true })).publicKey
+    const alicePubKey = (await walletA.getPublicKey({ identityKey: true }))
+      .publicKey
+    const bobPubKey = (await walletB.getPublicKey({ identityKey: true }))
+      .publicKey
 
-    const aliceMasterCertificate = await createMasterCertificate(walletA, { name: 'Alice' })
+    const aliceMasterCertificate = await createMasterCertificate(walletA, {
+      name: 'Alice'
+    })
     const aliceVerifiableCertificate = await createVerifiableCertificate(
       aliceMasterCertificate,
       walletA,
@@ -291,16 +380,23 @@ describe('Peer class mutual authentication and certificate exchange', () => {
     )
 
     const { bobReceivedCertificates } = setupPeers(false, true)
-    mockGetVerifiableCertificates(aliceVerifiableCertificate, undefined, alicePubKey, bobPubKey)
+    await mockGetVerifiableCertificates(
+      aliceVerifiableCertificate,
+      undefined,
+      alicePubKey,
+      bobPubKey
+    )
 
     const bobReceivedGeneralMessage = new Promise<void>((resolve) => {
-      bob.listenForGeneralMessages(async (senderPublicKey, payload) => {
-        await bobReceivedCertificates
-        console.log('Bob received message:', Utils.toUTF8(payload))
+      bob.listenForGeneralMessages((senderPublicKey, payload) => {
+        (async () => {
+          await bobReceivedCertificates
+          console.log('Bob received message:', Utils.toUTF8(payload))
 
-        // Bob requests additional certificates after initial communication
-        await bob.requestCertificates(certificatesToRequest, senderPublicKey)
-        resolve()
+          // Bob requests additional certificates after initial communication
+          await bob.requestCertificates(certificatesToRequest, senderPublicKey)
+          resolve()
+        })().catch(e => { console.error(e) })
       })
     })
 
@@ -310,16 +406,23 @@ describe('Peer class mutual authentication and certificate exchange', () => {
 
     // Listen for certificates received from the additional request
     const bobReceivedAdditionalCertificates = new Promise<void>((resolve) => {
-      bob.listenForCertificatesReceived(async (senderPublicKey, certificates) => {
-        if (certificates.length > 0) {
-          // Decrypt to confirm
-          for (const cert of certificates) {
-            const decrypted = await cert.decryptFields(walletB)
-            console.log('Bob received additional certificates from Alice:', cert)
-            console.log('Decrypted fields:', decrypted)
+      bob.listenForCertificatesReceived((senderPublicKey, certificates) => {
+        (async () => {
+          if (certificates.length > 0) {
+            // Decrypt to confirm
+            for (const cert of certificates) {
+              const decrypted = await cert.decryptFields(walletB)
+              console.log(
+                'Bob received additional certificates from Alice:',
+                cert
+              )
+              console.log('Decrypted fields:', decrypted)
+            }
+            resolve()
           }
-          resolve()
-        }
+        })().catch((error) => {
+          console.error(error)
+        })
       })
     })
 
@@ -329,11 +432,16 @@ describe('Peer class mutual authentication and certificate exchange', () => {
   }, 15000)
 
   it('Bob requests Alice to provide her membership status before granting access to premium content', async () => {
-    const alicePubKey = (await walletA.getPublicKey({ identityKey: true })).publicKey
-    const bobPubKey = (await walletB.getPublicKey({ identityKey: true })).publicKey
+    const alicePubKey = (await walletA.getPublicKey({ identityKey: true }))
+      .publicKey
+    const bobPubKey = (await walletB.getPublicKey({ identityKey: true }))
+      .publicKey
 
     // Alice's certificate includes her membership status
-    const aliceMasterCertificate = await createMasterCertificate(walletA, { ...aliceFields, membershipStatus: 'Gold' })
+    const aliceMasterCertificate = await createMasterCertificate(walletA, {
+      ...aliceFields,
+      membershipStatus: 'Gold'
+    })
     const aliceVerifiableCertificate = await createVerifiableCertificate(
       aliceMasterCertificate,
       walletA,
@@ -347,23 +455,37 @@ describe('Peer class mutual authentication and certificate exchange', () => {
       types: { [certificateType]: ['membershipStatus'] }
     }
 
-    const { bobReceivedCertificates } = setupPeers(false, true, { bobCertsToRequest: bobCertificatesToRequest })
-    mockGetVerifiableCertificates(aliceVerifiableCertificate, undefined, alicePubKey, bobPubKey)
+    const { bobReceivedCertificates } = setupPeers(false, true, {
+      bobCertsToRequest: bobCertificatesToRequest
+    })
+    await mockGetVerifiableCertificates(
+      aliceVerifiableCertificate,
+      undefined,
+      alicePubKey,
+      bobPubKey
+    )
 
     const bobAcceptedMembershipStatus = jest.fn()
 
     const waitForCerts = new Promise<void>((resolve) => {
-      bob.listenForCertificatesReceived(async (senderPublicKey, certificates) => {
-        for (const cert of certificates) {
-          // Decrypt Alice's certificate fields
-          const decryptedFields = await cert.decryptFields(walletB)
-          if (decryptedFields.membershipStatus) {
-            console.log(`Bob received Alice's membership status: ${decryptedFields.membershipStatus}`)
-            bobAcceptedMembershipStatus()
-            resolve()
+      bob.listenForCertificatesReceived((senderPublicKey, certificates) => {
+        (async () => {
+          for (const cert of certificates) {
+            // Decrypt Alice's certificate fields
+            const decryptedFields = await cert.decryptFields(walletB)
+            if (typeof decryptedFields.membershipStatus !== 'undefined') {
+              console.log(
+                `Bob received Alice's membership status: ${decryptedFields.membershipStatus}`
+              )
+              bobAcceptedMembershipStatus()
+              resolve()
+            }
           }
-        }
-      })
+        })().catch((error) => {
+          console.error('Error processing certificates:', error)
+        })
+      }
+      )
     })
 
     const bobReceivedGeneralMessage = new Promise<void>((resolve) => {
@@ -374,22 +496,29 @@ describe('Peer class mutual authentication and certificate exchange', () => {
     })
 
     // Alice sends a message to Bob requesting access to premium content
-    await alice.toPeer(Utils.toArray('I would like to access the premium content.'))
+    await alice.toPeer(
+      Utils.toArray('I would like to access the premium content.')
+    )
     await bobReceivedCertificates
     await bobReceivedGeneralMessage
     await waitForCerts
 
     expect(bobAcceptedMembershipStatus).toHaveBeenCalled()
     expect(certificatesReceivedByBob).toEqual([aliceVerifiableCertificate])
-    expect(certificatesReceivedByAlice).toEqual([]) // Alice did not request any certificates
+    expect(certificatesReceivedByAlice).toEqual([])
   }, 15000)
 
-  it('Both peers require each other\'s driver\'s license before carpooling', async () => {
-    const alicePubKey = (await walletA.getPublicKey({ identityKey: true })).publicKey
-    const bobPubKey = (await walletB.getPublicKey({ identityKey: true })).publicKey
+  it("Both peers require each other's driver's license before carpooling", async () => {
+    const alicePubKey = (await walletA.getPublicKey({ identityKey: true }))
+      .publicKey
+    const bobPubKey = (await walletB.getPublicKey({ identityKey: true }))
+      .publicKey
 
     // Both Alice and Bob have driver's license certificates
-    const aliceMasterCertificate = await createMasterCertificate(walletA, { ...aliceFields, driversLicenseNumber: 'DLA123456' })
+    const aliceMasterCertificate = await createMasterCertificate(walletA, {
+      ...aliceFields,
+      driversLicenseNumber: 'DLA123456'
+    })
     const aliceVerifiableCertificate = await createVerifiableCertificate(
       aliceMasterCertificate,
       walletA,
@@ -397,7 +526,10 @@ describe('Peer class mutual authentication and certificate exchange', () => {
       ['driversLicenseNumber']
     )
 
-    const bobMasterCertificate = await createMasterCertificate(walletB, { ...bobFields, driversLicenseNumber: 'DLB654321' })
+    const bobMasterCertificate = await createMasterCertificate(walletB, {
+      ...bobFields,
+      driversLicenseNumber: 'DLB654321'
+    })
     const bobVerifiableCertificate = await createVerifiableCertificate(
       bobMasterCertificate,
       walletB,
@@ -411,46 +543,70 @@ describe('Peer class mutual authentication and certificate exchange', () => {
       types: { [certificateType]: ['driversLicenseNumber'] }
     }
 
-    const { aliceReceivedCertificates, bobReceivedCertificates } = setupPeers(true, true, {
-      aliceCertsToRequest: certificatesToRequestDriversLicense,
-      bobCertsToRequest: certificatesToRequestDriversLicense
-    })
-    mockGetVerifiableCertificates(aliceVerifiableCertificate, bobVerifiableCertificate, alicePubKey, bobPubKey)
+    const { aliceReceivedCertificates, bobReceivedCertificates } = setupPeers(
+      true,
+      true,
+      {
+        aliceCertsToRequest: certificatesToRequestDriversLicense,
+        bobCertsToRequest: certificatesToRequestDriversLicense
+      }
+    )
+    await mockGetVerifiableCertificates(
+      aliceVerifiableCertificate,
+      bobVerifiableCertificate,
+      alicePubKey,
+      bobPubKey
+    )
 
     const aliceAcceptedBobDL = jest.fn()
     const bobAcceptedAliceDL = jest.fn()
 
     const waitForAliceToAcceptBobDL = new Promise<void>((resolve) => {
-      alice.listenForCertificatesReceived(async (senderPublicKey, certificates) => {
-        for (const cert of certificates) {
-          const decryptedFields = await cert.decryptFields(walletA)
-          if (decryptedFields.driversLicenseNumber) {
-            console.log(`Alice received Bob's driver's license number: ${decryptedFields.driversLicenseNumber}`)
-            aliceAcceptedBobDL()
-            resolve()
+      alice.listenForCertificatesReceived((senderPublicKey, certificates) => {
+        (async () => {
+          for (const cert of certificates) {
+            const decryptedFields = await cert.decryptFields(walletA)
+            if (decryptedFields.driversLicenseNumber !== undefined) {
+              console.log(
+                `Alice received Bob's driver's license number: ${decryptedFields.driversLicenseNumber}`
+              )
+              aliceAcceptedBobDL()
+              resolve()
+            }
           }
-        }
-      })
+        })().catch(e => console.log(e))
+      }
+      )
     })
 
     const waitForBobToAcceptAliceDL = new Promise<void>((resolve) => {
-      bob.listenForCertificatesReceived(async (senderPublicKey, certificates) => {
-        for (const cert of certificates) {
-          const decryptedFields = await cert.decryptFields(walletB)
-          if (decryptedFields.driversLicenseNumber) {
-            console.log(`Bob received Alice's driver's license number: ${decryptedFields.driversLicenseNumber}`)
-            bobAcceptedAliceDL()
-            resolve()
+      bob.listenForCertificatesReceived((senderPublicKey, certificates) => {
+        (async () => {
+          for (const cert of certificates) {
+            const decryptedFields = await cert.decryptFields(walletB)
+            if (decryptedFields.driversLicenseNumber !== undefined) {
+              console.log(
+                `Bob received Alice's driver's license number: ${decryptedFields.driversLicenseNumber}`
+              )
+              bobAcceptedAliceDL()
+              resolve()
+            }
           }
-        }
-      })
+        })().catch(e => console.log(e))
+      }
+      )
     })
 
     const bobReceivedGeneralMessage = new Promise<void>((resolve) => {
-      bob.listenForGeneralMessages(async (senderPublicKey, payload) => {
-        console.log('Bob received message from Alice:', Utils.toUTF8(payload))
-        await bob.toPeer(Utils.toArray('Looking forward to carpooling!'), senderPublicKey)
-        resolve()
+      bob.listenForGeneralMessages((senderPublicKey, payload) => {
+        (async () => {
+          console.log('Bob received message from Alice:', Utils.toUTF8(payload))
+          await bob.toPeer(
+            Utils.toArray('Looking forward to carpooling!'),
+            senderPublicKey
+          )
+          resolve()
+        })().catch(e => console.log(e))
       })
     })
 
@@ -462,7 +618,9 @@ describe('Peer class mutual authentication and certificate exchange', () => {
     })
 
     // Alice initiates the conversation
-    await alice.toPeer(Utils.toArray('Please share your driver\'s license number for carpooling.'))
+    await alice.toPeer(
+      Utils.toArray("Please share your driver's license number for carpooling.")
+    )
     await aliceReceivedCertificates
     await bobReceivedCertificates
     await bobReceivedGeneralMessage
@@ -479,11 +637,16 @@ describe('Peer class mutual authentication and certificate exchange', () => {
   }, 20000)
 
   it('Peers accept partial certificates if at least one required field is present', async () => {
-    const alicePubKey = (await walletA.getPublicKey({ identityKey: true })).publicKey
-    const bobPubKey = (await walletB.getPublicKey({ identityKey: true })).publicKey
+    const alicePubKey = (await walletA.getPublicKey({ identityKey: true }))
+      .publicKey
+    const bobPubKey = (await walletB.getPublicKey({ identityKey: true }))
+      .publicKey
 
     // Alice's certificate contains 'name' and 'email'; Bob's contains only 'email'
-    const aliceMasterCertificate = await createMasterCertificate(walletA, { name: 'Alice', email: 'alice@example.com' })
+    const aliceMasterCertificate = await createMasterCertificate(walletA, {
+      name: 'Alice',
+      email: 'alice@example.com'
+    })
     const aliceVerifiableCertificate = await createVerifiableCertificate(
       aliceMasterCertificate,
       walletA,
@@ -491,7 +654,9 @@ describe('Peer class mutual authentication and certificate exchange', () => {
       ['name', 'email']
     )
 
-    const bobMasterCertificate = await createMasterCertificate(walletB, { email: 'bob@example.com' })
+    const bobMasterCertificate = await createMasterCertificate(walletB, {
+      email: 'bob@example.com'
+    })
     const bobVerifiableCertificate = await createVerifiableCertificate(
       bobMasterCertificate,
       walletB,
@@ -504,38 +669,55 @@ describe('Peer class mutual authentication and certificate exchange', () => {
       types: { [certificateType]: ['name', 'email'] }
     }
 
-    const { aliceReceivedCertificates, bobReceivedCertificates } = setupPeers(true, true, {
-      aliceCertsToRequest: partialCertificatesToRequest,
-      bobCertsToRequest: partialCertificatesToRequest
-    })
-    mockGetVerifiableCertificates(aliceVerifiableCertificate, bobVerifiableCertificate, alicePubKey, bobPubKey)
+    const { aliceReceivedCertificates, bobReceivedCertificates } = setupPeers(
+      true,
+      true,
+      {
+        aliceCertsToRequest: partialCertificatesToRequest,
+        bobCertsToRequest: partialCertificatesToRequest
+      }
+    )
+    await mockGetVerifiableCertificates(
+      aliceVerifiableCertificate,
+      bobVerifiableCertificate,
+      alicePubKey,
+      bobPubKey
+    )
 
     const aliceAcceptedPartialCert = jest.fn()
     const bobAcceptedPartialCert = jest.fn()
 
     const waitForAlicePartialCert = new Promise<void>((resolve) => {
-      alice.listenForCertificatesReceived(async (senderPublicKey, certificates) => {
-        for (const cert of certificates) {
-          const decryptedFields = await cert.decryptFields(walletA)
-          if (decryptedFields.email || decryptedFields.name) {
-            console.log(`Alice received Bob's certificate with fields: ${Object.keys(decryptedFields).join(', ')}`)
-            aliceAcceptedPartialCert()
-            resolve()
+      alice.listenForCertificatesReceived((senderPublicKey, certificates) => {
+        (async () => {
+          for (const cert of certificates) {
+            const decryptedFields = await cert.decryptFields(walletA)
+            if (decryptedFields.email !== undefined || decryptedFields.name !== undefined) {
+              console.log(
+                `Alice received Bob's certificate with fields: ${Object.keys(decryptedFields).join(', ')}`
+              )
+              aliceAcceptedPartialCert()
+              resolve()
+            }
           }
-        }
+        })().catch(e => console.log(e))
       })
     })
 
     const waitForBobPartialCert = new Promise<void>((resolve) => {
-      bob.listenForCertificatesReceived(async (senderPublicKey, certificates) => {
-        for (const cert of certificates) {
-          const decryptedFields = await cert.decryptFields(walletB)
-          if (decryptedFields.email || decryptedFields.name) {
-            console.log(`Bob received Alice's certificate with fields: ${Object.keys(decryptedFields).join(', ')}`)
-            bobAcceptedPartialCert()
-            resolve()
+      bob.listenForCertificatesReceived((senderPublicKey, certificates) => {
+        (async () => {
+          for (const cert of certificates) {
+            const decryptedFields = await cert.decryptFields(walletB)
+            if (decryptedFields.email !== undefined || decryptedFields.name !== undefined) {
+              console.log(
+                `Bob received Alice's certificate with fields: ${Object.keys(decryptedFields).join(', ')}`
+              )
+              bobAcceptedPartialCert()
+              resolve()
+            }
           }
-        }
+        })().catch(e => console.log(e))
       })
     })