@bsv/wallet-toolbox 1.7.16 → 1.7.18

package/mobile/node_modules/@bsv/sdk/src/auth/__tests/Peer.test.ts

@@ -1,1059 +0,0 @@
-import { Peer } from '../../auth/Peer.js'
-import { AuthMessage, Transport } from '../../auth/types.js'
-import { jest } from '@jest/globals'
-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 '../certificates/__tests/CompletedProtoWallet.js'
-import { SimplifiedFetchTransport } from '../../auth/transports/SimplifiedFetchTransport.js'
-
-const certifierPrivKey = new PrivateKey(21)
-const alicePrivKey = new PrivateKey(22)
-const bobPrivKey = new PrivateKey(23)
-const DUMMY_REVOCATION_OUTPOINT_HEX = '00'.repeat(36)
-
-jest.mock('../../auth/utils/getVerifiableCertificates')
-
-class LocalTransport implements Transport {
-  private peerTransport?: LocalTransport
-  private onDataCallback?: (message: AuthMessage) => void
-
-  connect(peerTransport: LocalTransport): void {
-    this.peerTransport = peerTransport
-    peerTransport.peerTransport = this
-  }
-
-  async send(message: AuthMessage): Promise<void> {
-    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.'
-      )
-    }
-  }
-
-  async onData(
-    callback: (message: AuthMessage) => void
-  ): Promise<void> {
-    this.onDataCallback = callback
-  }
-}
-
-function waitForNextGeneralMessage (
-  peer: Peer,
-  handler?: (senderPublicKey: string, payload: number[]) => void
-): Promise<void> {
-  return new Promise(resolve => {
-    const listenerId = peer.listenForGeneralMessages((senderPublicKey, payload) => {
-      peer.stopListeningForGeneralMessages(listenerId)
-      if (handler !== undefined) handler(senderPublicKey, payload)
-      resolve()
-    })
-  })
-}
-
-describe('Peer class mutual authentication and certificate exchange', () => {
-  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 certifierPrivateKey = certifierPrivKey
-  const certifierPublicKey = certifierPrivateKey.toPublicKey().toString()
-  const certificatesToRequest = {
-    certifiers: [certifierPublicKey],
-    types: { [certificateType]: ['name', 'email'] }
-  }
-
-  const aliceFields = {
-    name: 'Alice',
-    email: 'alice@example.com',
-    libraryCardNumber: 'A123456'
-  }
-  const bobFields = {
-    name: 'Bob',
-    email: 'bob@example.com',
-    libraryCardNumber: 'B654321'
-  }
-
-  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 () => DUMMY_REVOCATION_OUTPOINT_HEX
-      )
-
-    // For test consistency, you could override the auto-generated serialNumber:
-    // masterCertificate.signature = undefined
-    // masterCertificate.serialNumber = certificateSerialNumber
-    // await masterCertificate.sign(certifierWallet)
-
-    return masterCertificate
-  }
-
-  async function createVerifiableCertificate(
-    masterCertificate: MasterCertificate,
-    wallet: WalletInterface,
-    verifierIdentityKey: string,
-    fieldsToReveal: string[]
-  ): Promise<VerifiableCertificate> {
-    const certifierWallet = new CompletedProtoWallet(certifierPrivateKey)
-
-    if (certifierWallet.keyDeriver === undefined) {
-      throw new Error('KeyDeriver must be defined for test!')
-    }
-
-    const keyringForVerifier = await MasterCertificate.createKeyringForVerifier(
-      wallet,
-      certifierWallet.keyDeriver.identityKey,
-      verifierIdentityKey,
-      masterCertificate.fields,
-      fieldsToReveal,
-      masterCertificate.masterKeyring,
-      masterCertificate.serialNumber
-    )
-    return new VerifiableCertificate(
-      masterCertificate.type,
-      masterCertificate.serialNumber,
-      masterCertificate.subject,
-      masterCertificate.certifier,
-      masterCertificate.revocationOutpoint,
-      masterCertificate.fields,
-      keyringForVerifier,
-      masterCertificate.signature
-    )
-  }
-
-  function setupPeers(
-    aliceRequests: boolean,
-    bobRequests: boolean,
-    options: {
-      aliceCertsToRequest?: typeof certificatesToRequest
-      bobCertsToRequest?: typeof certificatesToRequest
-    } = {}
-  ): any {
-    const {
-      aliceCertsToRequest = certificatesToRequest,
-      bobCertsToRequest = certificatesToRequest
-    } = options
-
-    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) => {
-        certificatesReceivedByAlice = certificates
-        resolve()
-      })
-    })
-
-    const bobReceivedCertificates = new Promise<void>((resolve) => {
-      bob.listenForCertificatesReceived((senderPublicKey, certificates) => {
-        certificatesReceivedByBob = certificates
-        resolve()
-      })
-    })
-
-    return { aliceReceivedCertificates, bobReceivedCertificates }
-  }
-
-  async function mockGetVerifiableCertificates(
-    aliceCertificate: VerifiableCertificate | undefined,
-    bobCertificate: VerifiableCertificate | undefined,
-    alicePubKey: string,
-    bobPubKey: string
-  ): 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([])
-      }
-    )
-  }
-
-  beforeEach(async () => {
-    transportA = new LocalTransport()
-    transportB = new LocalTransport()
-    transportA.connect(transportB)
-
-    certificatesReceivedByAlice = []
-    certificatesReceivedByBob = []
-
-    walletA = new CompletedProtoWallet(alicePrivKey)
-    walletB = new CompletedProtoWallet(bobPrivKey)
-  })
-
-  it('Neither Alice nor Bob request certificates, mutual authentication completes successfully', async () => {
-    setupPeers(
-      false,
-      false
-    )
-
-    const bobReceivedGeneralMessage = new Promise<void>((resolve) => {
-      bob.listenForGeneralMessages((senderPublicKey, payload) => {
-        (async () => {
-          await bob.toPeer(Utils.toArray('Hello Alice!'), senderPublicKey)
-          resolve()
-        })().catch(e => { })
-      })
-    })
-    const aliceReceivedGeneralMessage = new Promise<void>((resolve) => {
-      alice.listenForGeneralMessages((senderPublicKey, payload) => {
-        resolve()
-      })
-    })
-
-    await alice.toPeer(Utils.toArray('Hello Bob!'))
-    await bobReceivedGeneralMessage
-    await aliceReceivedGeneralMessage
-
-    expect(certificatesReceivedByAlice).toEqual([])
-    expect(certificatesReceivedByBob).toEqual([])
-  }, 15000)
-
-  it('Alice talks to Bob across two devices, Bob can respond across both sessions', async () => {
-    const transportA1 = new LocalTransport()
-    const transportA2 = new LocalTransport()
-    const transportB = new LocalTransport()
-    transportA1.connect(transportB)
-    const aliceKey = alicePrivKey
-    const walletA1 = new CompletedProtoWallet(aliceKey)
-    const walletA2 = new CompletedProtoWallet(aliceKey)
-    const walletB = new CompletedProtoWallet(alicePrivKey)
-    const aliceFirstDevice = new Peer(
-      walletA1,
-      transportA1
-    )
-    const aliceOtherDevice = new Peer(
-      walletA2,
-      transportA2
-    )
-    const bob = new Peer(
-      walletB,
-      transportB
-    )
-    const alice1MessageHandler = jest.fn()
-    const alice2MessageHandler = jest.fn()
-    const bobMessageHandler = jest.fn()
-
-    const bobReceivedGeneralMessage = new Promise<void>((resolve) => {
-      bob.listenForGeneralMessages((senderPublicKey, payload) => {
-        (async () => {
-          await bob.toPeer(Utils.toArray('Hello Alice!'), senderPublicKey)
-          resolve()
-          bobMessageHandler(senderPublicKey, payload)
-        })().catch(e => { })
-      })
-    })
-    const aliceReceivedGeneralMessageOnFirstDevice = waitForNextGeneralMessage(
-      aliceFirstDevice,
-      alice1MessageHandler
-    )
-    const aliceReceivedGeneralMessageOnOtherDevice = waitForNextGeneralMessage(
-      aliceOtherDevice,
-      alice2MessageHandler
-    )
-
-    await aliceFirstDevice.toPeer(Utils.toArray('Hello Bob!'))
-    await bobReceivedGeneralMessage
-    await aliceReceivedGeneralMessageOnFirstDevice
-    transportA2.connect(transportB)
-    await aliceOtherDevice.toPeer(Utils.toArray('Hello Bob from my other device!'))
-    await aliceReceivedGeneralMessageOnOtherDevice
-    transportA1.connect(transportB)
-    const waitForSecondMessage = waitForNextGeneralMessage(
-      aliceFirstDevice,
-      alice1MessageHandler
-    )
-    await aliceFirstDevice.toPeer(
-      Utils.toArray('Back on my first device now, Bob! Can you still hear me?')
-    )
-    await waitForSecondMessage
-    expect(alice1MessageHandler.mock.calls.length).toEqual(2)
-  }, 30000)
-
-  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 aliceMasterCertificate = await createMasterCertificate(
-      walletA,
-      aliceFields
-    )
-    const aliceVerifiableCertificate = await createVerifiableCertificate(
-      aliceMasterCertificate,
-      walletA,
-      bobPubKey,
-      certificatesToRequest.types[certificateType]
-    )
-
-    const { bobReceivedCertificates } = setupPeers(false, true)
-    await mockGetVerifiableCertificates(
-      aliceVerifiableCertificate,
-      undefined,
-      alicePubKey,
-      bobPubKey
-    )
-
-    const bobReceivedGeneralMessage = new Promise<void>((resolve) => {
-      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()
-        })().catch((e) => {
-          // console.error(e)
-        })
-      })
-  })
-
-    await alice.toPeer(Utils.toArray('Hello Bob!'))
-    await bobReceivedGeneralMessage
-
-    expect(certificatesReceivedByAlice).toEqual([])
-    expect(certificatesReceivedByBob).toEqual([aliceVerifiableCertificate])
-  }, 15000)
-
-  describe('propagateTransportError', () => {
-    const createPeerInstance = (): Peer => {
-      const transport: Transport = {
-        send: jest.fn(async (_message: AuthMessage) => {}),
-        onData: async () => {}
-      }
-      return new Peer({} as WalletInterface, transport)
-    }
-
-    it('adds peer identity details to existing errors', () => {
-      const peer = createPeerInstance()
-      const originalError = new Error('send failed')
-
-      let thrown: Error | undefined
-      try {
-        (peer as any).propagateTransportError('peer-public-key', originalError)
-      } catch (error) {
-        thrown = error as Error
-      }
-
-      expect(thrown).toBe(originalError)
-      expect((thrown as any).details).toEqual({ peerIdentityKey: 'peer-public-key' })
-    })
-
-    it('preserves existing details when appending peer identity', () => {
-      const peer = createPeerInstance()
-      const originalError = new Error('existing details')
-      ;(originalError as any).details = { status: 503 }
-
-      let thrown: Error | undefined
-      try {
-        (peer as any).propagateTransportError('peer-public-key', originalError)
-      } catch (error) {
-        thrown = error as Error
-      }
-
-      expect(thrown).toBe(originalError)
-      expect((thrown as any).details).toEqual({
-        status: 503,
-        peerIdentityKey: 'peer-public-key'
-      })
-    })
-
-    it('wraps non-error values with a helpful message', () => {
-      const peer = createPeerInstance()
-      expect(() => (peer as any).propagateTransportError(undefined, 'timeout')).toThrow(
-        'Failed to send message to peer unknown: timeout'
-      )
-    })
-  })
-
-  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
-
-    // Bob's certificate includes his library card number
-    const bobMasterCertificate = await createMasterCertificate(
-      walletB,
-      bobFields
-    )
-    const bobVerifiableCertificate = await createVerifiableCertificate(
-      bobMasterCertificate,
-      walletB,
-      alicePubKey,
-      ['libraryCardNumber']
-    )
-
-    // Alice requires Bob to present his library card number
-    const aliceCertificatesToRequest = {
-      certifiers: [certifierPublicKey],
-      types: { [certificateType]: ['libraryCardNumber'] }
-    }
-
-    const { aliceReceivedCertificates } = setupPeers(true, false, {
-      aliceCertsToRequest: aliceCertificatesToRequest
-    })
-    await mockGetVerifiableCertificates(
-      undefined,
-      bobVerifiableCertificate,
-      alicePubKey,
-      bobPubKey
-    )
-
-    const aliceAcceptedLibraryCard = jest.fn()
-
-    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 &&
-            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) => {
-      bob.listenForGeneralMessages((senderPublicKey, payload) => {
-        // console.log('Bob received message from Alice:', Utils.toUTF8(payload))
-        resolve()
-      })
-    })
-
-    // 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 aliceReceivedCertificates
-    await bobReceivedGeneralMessage
-
-    expect(aliceAcceptedLibraryCard).toHaveBeenCalled()
-    expect(certificatesReceivedByAlice).toEqual([bobVerifiableCertificate])
-    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 aliceMasterCertificate = await createMasterCertificate(walletA, {
-      name: 'Alice'
-    })
-    const aliceVerifiableCertificate = await createVerifiableCertificate(
-      aliceMasterCertificate,
-      walletA,
-      bobPubKey,
-      ['name']
-    )
-
-    const { bobReceivedCertificates } = setupPeers(false, true)
-    await mockGetVerifiableCertificates(
-      aliceVerifiableCertificate,
-      undefined,
-      alicePubKey,
-      bobPubKey
-    )
-
-    const bobReceivedGeneralMessage = new Promise<void>((resolve) => {
-      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()
-        })().catch(e => { console.error(e) })
-      })
-    })
-
-    // Initial communication from Alice
-    await alice.toPeer(Utils.toArray('Hello Bob!'))
-    await bobReceivedGeneralMessage
-
-    // Listen for certificates received from the additional request
-    const bobReceivedAdditionalCertificates = new Promise<void>((resolve) => {
-      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()
-          }
-        })().catch((error) => {
-          console.error(error)
-        })
-      })
-    })
-
-    await bobReceivedAdditionalCertificates
-
-    expect(certificatesReceivedByBob).toEqual([aliceVerifiableCertificate])
-  }, 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
-
-    // Alice's certificate includes her membership status
-    const aliceMasterCertificate = await createMasterCertificate(walletA, {
-      ...aliceFields,
-      membershipStatus: 'Gold'
-    })
-    const aliceVerifiableCertificate = await createVerifiableCertificate(
-      aliceMasterCertificate,
-      walletA,
-      bobPubKey,
-      ['membershipStatus']
-    )
-
-    // Bob requires Alice to present her membership status
-    const bobCertificatesToRequest = {
-      certifiers: [certifierPublicKey],
-      types: { [certificateType]: ['membershipStatus'] }
-    }
-
-    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((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) => {
-      bob.listenForGeneralMessages((senderPublicKey, payload) => {
-        // console.log('Bob received message from Alice:', Utils.toUTF8(payload))
-        resolve()
-      })
-    })
-
-    // 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 bobReceivedCertificates
-    await bobReceivedGeneralMessage
-    await waitForCerts
-
-    expect(bobAcceptedMembershipStatus).toHaveBeenCalled()
-    expect(certificatesReceivedByBob).toEqual([aliceVerifiableCertificate])
-    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
-
-    // Both Alice and Bob have driver's license certificates
-    const aliceMasterCertificate = await createMasterCertificate(walletA, {
-      ...aliceFields,
-      driversLicenseNumber: 'DLA123456'
-    })
-    const aliceVerifiableCertificate = await createVerifiableCertificate(
-      aliceMasterCertificate,
-      walletA,
-      bobPubKey,
-      ['driversLicenseNumber']
-    )
-
-    const bobMasterCertificate = await createMasterCertificate(walletB, {
-      ...bobFields,
-      driversLicenseNumber: 'DLB654321'
-    })
-    const bobVerifiableCertificate = await createVerifiableCertificate(
-      bobMasterCertificate,
-      walletB,
-      alicePubKey,
-      ['driversLicenseNumber']
-    )
-
-    // Both peers require the driver's license number
-    const certificatesToRequestDriversLicense = {
-      certifiers: [certifierPublicKey],
-      types: { [certificateType]: ['driversLicenseNumber'] }
-    }
-
-    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((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 => { })
-      }
-      )
-    })
-
-    const waitForBobToAcceptAliceDL = new Promise<void>((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 => { })
-      }
-      )
-    })
-
-    const bobReceivedGeneralMessage = new Promise<void>((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 => { })
-      })
-    })
-
-    const aliceReceivedGeneralMessage = new Promise<void>((resolve) => {
-      alice.listenForGeneralMessages((senderPublicKey, payload) => {
-        // console.log('Alice received message from Bob:', Utils.toUTF8(payload))
-        resolve()
-      })
-    })
-
-    // Alice initiates the conversation
-    await alice.toPeer(
-      Utils.toArray("Please share your driver's license number for carpooling.")
-    )
-    await aliceReceivedCertificates
-    await bobReceivedCertificates
-    await bobReceivedGeneralMessage
-    await aliceReceivedGeneralMessage
-
-    // Wait for both sides to fully accept each other's certificate
-    await waitForAliceToAcceptBobDL
-    await waitForBobToAcceptAliceDL
-
-    expect(aliceAcceptedBobDL).toHaveBeenCalled()
-    expect(bobAcceptedAliceDL).toHaveBeenCalled()
-    expect(certificatesReceivedByAlice).toEqual([bobVerifiableCertificate])
-    expect(certificatesReceivedByBob).toEqual([aliceVerifiableCertificate])
-  }, 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
-
-    // Alice's certificate contains 'name' and 'email'; Bob's contains only 'email'
-    const aliceMasterCertificate = await createMasterCertificate(walletA, {
-      name: 'Alice',
-      email: 'alice@example.com'
-    })
-    const aliceVerifiableCertificate = await createVerifiableCertificate(
-      aliceMasterCertificate,
-      walletA,
-      bobPubKey,
-      ['name', 'email']
-    )
-
-    const bobMasterCertificate = await createMasterCertificate(walletB, {
-      email: 'bob@example.com'
-    })
-    const bobVerifiableCertificate = await createVerifiableCertificate(
-      bobMasterCertificate,
-      walletB,
-      alicePubKey,
-      ['email']
-    )
-
-    const partialCertificatesToRequest = {
-      certifiers: [certifierPublicKey],
-      types: { [certificateType]: ['name', 'email'] }
-    }
-
-    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((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 => { })
-      })
-    })
-
-    const waitForBobPartialCert = new Promise<void>((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 => { })
-      })
-    })
-
-    const bobReceivedGeneralMessage = new Promise<void>((resolve) => {
-      bob.listenForGeneralMessages((senderPublicKey, payload) => {
-        // console.log('Bob received message:', Utils.toUTF8(payload))
-        resolve()
-      })
-    })
-
-    await alice.toPeer(Utils.toArray('Hello Bob!'))
-    await aliceReceivedCertificates
-    await bobReceivedCertificates
-    await bobReceivedGeneralMessage
-
-    // Wait for both sides to fully accept the partial cert
-    await waitForAlicePartialCert
-    await waitForBobPartialCert
-
-    expect(aliceAcceptedPartialCert).toHaveBeenCalled()
-    expect(bobAcceptedPartialCert).toHaveBeenCalled()
-    expect(certificatesReceivedByAlice).toEqual([bobVerifiableCertificate])
-    expect(certificatesReceivedByBob).toEqual([aliceVerifiableCertificate])
-  }, 20000)
-
-  describe('Transport Error Handling', () => {
-    const privKey = PrivateKey.fromRandom()
-
-    test('Should trigger "Failed to send message to peer" error with network failure', async () => {
-      // Create a mock fetch that always fails
-      const failingFetch = (jest.fn() as any).mockRejectedValue(new Error('Network connection failed'))
-      
-      // Create a transport that will fail
-      const transport = new SimplifiedFetchTransport('http://localhost:9999', failingFetch)
-      
-      // Create a peer with the failing transport
-      const wallet = new CompletedProtoWallet(privKey)
-      const peer = new Peer(wallet, transport)
-      
-      // Register a dummy onData callback (required before sending)
-      await transport.onData(async (message) => {
-        // This won't be called due to network failure
-      })
-
-      // Try to send a message to peer - this should fail and trigger the error
-      try {
-        await peer.toPeer([1, 2, 3, 4], '03abc123def456')
-        fail('Expected error to be thrown')
-      } catch (error: any) {
-        expect(error.message).toContain('Network error while sending authenticated request')
-        expect(error.message).toContain('Network connection failed')
-      }
-    }, 15000)
-
-    test('Should trigger error with connection timeout', async () => {
-      // Create a fetch that times out
-      const timeoutFetch = (jest.fn() as any).mockImplementation(() => {
-        return new Promise((_, reject) => {
-          setTimeout(() => {
-            reject(new Error('Request timeout'))
-          }, 100)
-        })
-      })
-      
-      const transport = new SimplifiedFetchTransport('http://localhost:9999', timeoutFetch)
-      const wallet = new CompletedProtoWallet(privKey)
-      const peer = new Peer(wallet, transport)
-      
-      await transport.onData(async (message) => {})
-
-      try {
-        await peer.toPeer([5, 6, 7, 8], '03def789abc123')
-        fail('Expected error to be thrown')
-      } catch (error: any) {
-        expect(error.message).toContain('Network error while sending authenticated request')
-        expect(error.message).toContain('Request timeout')
-      }
-    }, 15000)
-
-    test('Should trigger error with DNS resolution failure', async () => {
-      // Create a fetch that fails with DNS error
-      const dnsFetch = (jest.fn() as any).mockRejectedValue({
-        code: 'ENOTFOUND',
-        errno: -3008,
-        message: 'getaddrinfo ENOTFOUND nonexistent.domain'
-      })
-      
-      const transport = new SimplifiedFetchTransport('http://nonexistent.domain:3000', dnsFetch)
-      const wallet = new CompletedProtoWallet(privKey)
-      const peer = new Peer(wallet, transport)
-      
-      await transport.onData(async (message) => {})
-
-      try {
-        await peer.toPeer([9, 10, 11, 12], '03xyz987fed654')
-        fail('Expected error to be thrown')
-      } catch (error: any) {
-        expect(error.message).toContain('Network error while sending authenticated request')
-        expect(error.message).toContain('[object Object]')
-      }
-    }, 15000)
-
-    test('Should trigger error during certificate request send', async () => {
-      // Create a failing fetch
-      const failingFetch = (jest.fn() as any).mockRejectedValue(new Error('Connection reset by peer'))
-      
-      const transport = new SimplifiedFetchTransport('http://localhost:9999', failingFetch)
-      const wallet = new CompletedProtoWallet(privKey)
-      const peer = new Peer(wallet, transport)
-      
-      await transport.onData(async (message) => {})
-
-      try {
-        // Try to send a certificate request - this should also trigger the error
-        await peer.requestCertificates({
-          certifiers: ['03certifier123'],
-          types: { 'type1': ['field1'] }
-        }, '03abc123def456')
-        fail('Expected error to be thrown')
-      } catch (error: any) {
-        expect(error.message).toContain('Network error while sending authenticated request')
-        expect(error.message).toContain('Connection reset by peer')
-      }
-    }, 15000)
-
-    test('Should trigger error during certificate response send', async () => {
-      // Create a failing fetch
-      const failingFetch = (jest.fn() as any).mockRejectedValue(new Error('Socket hang up'))
-      
-      const transport = new SimplifiedFetchTransport('http://localhost:9999', failingFetch)
-      const wallet = new CompletedProtoWallet(privKey)
-      const peer = new Peer(wallet, transport)
-      
-      await transport.onData(async (message) => {})
-
-      try {
-        // Try to send a certificate response - this should also trigger the error
-        await peer.sendCertificateResponse('03verifier123', [])
-        fail('Expected error to be thrown')
-      } catch (error: any) {
-        expect(error.message).toContain('Network error while sending authenticated request')
-        expect(error.message).toContain('Socket hang up')
-      }
-    }, 15000)
-
-    test('Should propagate network errors with proper details', async () => {
-      // Create a fetch that throws a custom error
-      const customError = new Error('Custom transport error')
-      customError.stack = 'Custom stack trace'
-      const failingFetch = (jest.fn() as any).mockRejectedValue(customError)
-      
-      const transport = new SimplifiedFetchTransport('http://localhost:9999', failingFetch)
-      const wallet = new CompletedProtoWallet(privKey)
-      const peer = new Peer(wallet, transport)
-      
-      await transport.onData(async (message) => {})
-
-      try {
-        await peer.toPeer([13, 14, 15, 16], '03peer123456')
-        fail('Expected error to be thrown')
-      } catch (error: any) {
-        // Should create a network error wrapping the original error
-        expect(error.message).toContain('Network error while sending authenticated request')
-        expect(error.message).toContain('Custom transport error')
-        expect(error.cause).toBeDefined()
-        expect(error.cause.message).toBe('Custom transport error')
-      }
-    }, 15000)
-
-    test('Should handle non-Error transport failures', async () => {
-      // Create a fetch that throws a non-Error object
-      const failingFetch = (jest.fn() as any).mockRejectedValue('String error message')
-      
-      const transport = new SimplifiedFetchTransport('http://localhost:9999', failingFetch)
-      const wallet = new CompletedProtoWallet(privKey)
-      const peer = new Peer(wallet, transport)
-      
-      await transport.onData(async (message) => {})
-
-      try {
-        await peer.toPeer([17, 18, 19, 20], '03peer789abc')
-        fail('Expected error to be thrown')
-      } catch (error: any) {
-        // Should create network error for non-Error objects
-        expect(error.message).toContain('Network error while sending authenticated request')
-        expect(error.message).toContain('String error message')
-      }
-    }, 15000)
-
-    test('Should handle undefined peer identity gracefully', async () => {
-      // Create a failing fetch
-      const failingFetch = (jest.fn() as any).mockRejectedValue('Network failure')
-      
-      const transport = new SimplifiedFetchTransport('http://localhost:9999', failingFetch)
-      const wallet = new CompletedProtoWallet(privKey)
-      const peer = new Peer(wallet, transport)
-      
-      await transport.onData(async (message) => {})
-
-      try {
-        // Try to send to an undefined peer (this might happen in some edge cases)
-        await peer.toPeer([21, 22, 23, 24], undefined as any)
-        fail('Expected error to be thrown')
-      } catch (error: any) {
-        expect(error.message).toContain('Network error while sending authenticated request')
-        expect(error.message).toContain('Network failure')
-      }
-    }, 15000)
-  })
-})