@bsv/sdk 1.3.12 → 1.3.14

package/src/auth/Peer.ts

@@ -1,6 +1,16 @@
 import { SessionManager } from './SessionManager.js'
-import { createNonce, verifyNonce, getVerifiableCertificates, validateCertificates } from './utils/index.js'
-import { AuthMessage, PeerSession, RequestedCertificateSet, Transport } from './types.js'
+import {
+  createNonce,
+  verifyNonce,
+  getVerifiableCertificates,
+  validateCertificates
+} from './utils/index.js'
+import {
+  AuthMessage,
+  PeerSession,
+  RequestedCertificateSet,
+  Transport
+} from './types.js'
 import { VerifiableCertificate } from './certificates/VerifiableCertificate.js'
 import { Random, Utils, WalletInterface } from '../../mod.js'
 
@@ -16,10 +26,28 @@ export class Peer {
   private readonly transport: Transport
   private readonly wallet: WalletInterface
   certificatesToRequest: RequestedCertificateSet
-  private readonly onGeneralMessageReceivedCallbacks: Map<number, (senderPublicKey: string, payload: number[]) => void> = new Map()
-  private readonly onCertificatesReceivedCallbacks: Map<number, (senderPublicKey: string, certs: VerifiableCertificate[]) => void> = new Map()
-  private readonly onCertificateRequestReceivedCallbacks: Map<number, (senderPublicKey: string, requestedCertificates: RequestedCertificateSet) => void> = new Map()
-  private readonly onInitialResponseReceivedCallbacks: Map<number, ({ callback: (sessionNonce: string) => void, sessionNonce: string })> = new Map()
+  private readonly onGeneralMessageReceivedCallbacks: Map<
+  number,
+  (senderPublicKey: string, payload: number[]) => void
+  > = new Map()
+
+  private readonly onCertificatesReceivedCallbacks: Map<
+  number,
+  (senderPublicKey: string, certs: VerifiableCertificate[]) => void
+  > = new Map()
+
+  private readonly onCertificateRequestReceivedCallbacks: Map<
+  number,
+  (
+    senderPublicKey: string,
+    requestedCertificates: RequestedCertificateSet
+  ) => void
+  > = new Map()
+
+  private readonly onInitialResponseReceivedCallbacks: Map<
+  number,
+  { callback: (sessionNonce: string) => void, sessionNonce: string }
+  > = new Map()
 
   // Single shared counter for all callback types
   private callbackIdCounter: number = 0
@@ -48,10 +76,13 @@ export class Peer {
   ) {
     this.wallet = wallet
     this.transport = transport
-    this.certificatesToRequest = certificatesToRequest ?? { certifiers: [], types: {} }
-    this.transport.onData(this.handleIncomingMessage.bind(this))
-    this.sessionManager = sessionManager || new SessionManager()
-    if (!autoPersistLastSession) {
+    this.certificatesToRequest = certificatesToRequest ?? {
+      certifiers: [],
+      types: {}
+    }
+    this.transport.onData(this.handleIncomingMessage.bind(this)).catch(console.error)
+    this.sessionManager = sessionManager != null ? sessionManager : new SessionManager()
+    if (autoPersistLastSession === false) {
       this.autoPersistLastSession = false
     } else {
       this.autoPersistLastSession = true
@@ -66,25 +97,38 @@ export class Peer {
    * @returns {Promise<void>}
    * @throws Will throw an error if the message fails to send.
    */
-  async toPeer (message: number[], identityKey?: string, maxWaitTime?: number): Promise<void> {
-    if (this.autoPersistLastSession && this.lastInteractedWithPeer && typeof identityKey !== 'string') {
+  async toPeer (
+    message: number[],
+    identityKey?: string,
+    maxWaitTime?: number
+  ): Promise<void> {
+    if (
+      this.autoPersistLastSession &&
+      this.lastInteractedWithPeer !== undefined &&
+      this.lastInteractedWithPeer !== null &&
+      typeof identityKey !== 'string'
+    ) {
       identityKey = this.lastInteractedWithPeer
     }
-    const peerSession = await this.getAuthenticatedSession(identityKey, maxWaitTime)
+    const peerSession = await this.getAuthenticatedSession(
+      identityKey,
+      maxWaitTime
+    )
 
     // Prepare the general message
     const requestNonce = Utils.toBase64(Random(32))
     const { signature } = await this.wallet.createSignature({
       data: message,
       protocolID: [2, 'auth message signature'],
-      keyID: `${requestNonce} ${peerSession.peerNonce}`,
+      keyID: `${requestNonce} ${peerSession.peerNonce ?? ''}`,
       counterparty: peerSession.peerIdentityKey
     })
 
     const generalMessage: AuthMessage = {
       version: AUTH_VERSION,
       messageType: 'general',
-      identityKey: (await this.wallet.getPublicKey({ identityKey: true })).publicKey,
+      identityKey: (await this.wallet.getPublicKey({ identityKey: true }))
+        .publicKey,
       nonce: requestNonce,
       yourNonce: peerSession.peerNonce,
       payload: message,
@@ -94,39 +138,49 @@ export class Peer {
     try {
       await this.transport.send(generalMessage)
     } catch (error) {
-      const e = new Error(`Failed to send message to peer ${peerSession.peerIdentityKey}: ${error.message}`)
+      const e = new Error(
+        `Failed to send message to peer ${peerSession.peerIdentityKey ?? 'unknown'}: ${String(error.message)}`
+      )
       e.stack = error.stack
       throw e
     }
   }
 
   /**
-  * Sends a request for certificates to a peer.
-  * This method allows a peer to dynamically request specific certificates after
-  * an initial handshake or message has been exchanged.
-  *
-  * @param {RequestedCertificateSet} certificatesToRequest - Specifies the certifiers and types of certificates required from the peer.
-  * @param {string} [identityKey] - The identity public key of the peer. If not provided, the current session identity is used.
-  * @param {number} [maxWaitTime=10000] - Maximum time in milliseconds to wait for the peer session to be authenticated.
-  * @returns {Promise<void>} Resolves if the certificate request message is successfully sent.
-  * @throws Will throw an error if the peer session is not authenticated or if sending the request fails.
-  */
-  async requestCertificates (certificatesToRequest: RequestedCertificateSet, identityKey?: string, maxWaitTime = 10000): Promise<void> {
-    const peerSession = await this.getAuthenticatedSession(identityKey, maxWaitTime)
+   * Sends a request for certificates to a peer.
+   * This method allows a peer to dynamically request specific certificates after
+   * an initial handshake or message has been exchanged.
+   *
+   * @param {RequestedCertificateSet} certificatesToRequest - Specifies the certifiers and types of certificates required from the peer.
+   * @param {string} [identityKey] - The identity public key of the peer. If not provided, the current session identity is used.
+   * @param {number} [maxWaitTime=10000] - Maximum time in milliseconds to wait for the peer session to be authenticated.
+   * @returns {Promise<void>} Resolves if the certificate request message is successfully sent.
+   * @throws Will throw an error if the peer session is not authenticated or if sending the request fails.
+   */
+  async requestCertificates (
+    certificatesToRequest: RequestedCertificateSet,
+    identityKey?: string,
+    maxWaitTime = 10000
+  ): Promise<void> {
+    const peerSession = await this.getAuthenticatedSession(
+      identityKey,
+      maxWaitTime
+    )
 
     // Prepare the general message
     const requestNonce = Utils.toBase64(Random(32))
     const { signature } = await this.wallet.createSignature({
       data: Utils.toArray(JSON.stringify(certificatesToRequest), 'utf8'),
       protocolID: [2, 'auth message signature'],
-      keyID: `${requestNonce} ${peerSession.peerNonce}`,
+      keyID: `${requestNonce} ${peerSession.peerNonce ?? ''}`,
       counterparty: peerSession.peerIdentityKey
     })
 
     const certRequestMessage: AuthMessage = {
       version: AUTH_VERSION,
       messageType: 'certificateRequest',
-      identityKey: (await this.wallet.getPublicKey({ identityKey: true })).publicKey,
+      identityKey: (await this.wallet.getPublicKey({ identityKey: true }))
+        .publicKey,
       nonce: requestNonce,
       initialNonce: peerSession.sessionNonce,
       yourNonce: peerSession.peerNonce,
@@ -136,8 +190,10 @@ export class Peer {
 
     try {
       await this.transport.send(certRequestMessage)
-    } catch (error) {
-      throw new Error(`Failed to send certificate request message to peer ${peerSession.peerIdentityKey}: ${error.message}`)
+    } catch (error: any) {
+      throw new Error(
+        `Failed to send certificate request message to peer ${peerSession.peerIdentityKey ?? 'unknown'}: ${String(error.message)}`
+      )
     }
   }
 
@@ -152,16 +208,24 @@ export class Peer {
    * @returns {Promise<PeerSession>} - A promise that resolves with an authenticated `PeerSession`.
    * @throws {Error} - Throws an error if the transport is not connected or if the handshake fails.
    */
-  async getAuthenticatedSession (identityKey?: string, maxWaitTime?: number): Promise<PeerSession> {
-    if (!this.transport) {
+  async getAuthenticatedSession (
+    identityKey?: string,
+    maxWaitTime?: number
+  ): Promise<PeerSession> {
+    if (this.transport === undefined) {
       throw new Error('Peer transport is not connected!')
     }
 
-    let peerSession = identityKey ? this.sessionManager.getSession(identityKey) : undefined
-    if (!peerSession || !peerSession.isAuthenticated) {
-      const sessionNonce = await this.initiateHandshake(identityKey, maxWaitTime)
-      peerSession = this.sessionManager.getSession(identityKey || sessionNonce)
-      if (!peerSession.isAuthenticated) {
+    let peerSession = identityKey !== undefined && identityKey !== ''
+      ? this.sessionManager.getSession(identityKey)
+      : undefined
+    if (peerSession === undefined || !peerSession?.isAuthenticated) {
+      const sessionNonce = await this.initiateHandshake(
+        identityKey,
+        maxWaitTime
+      )
+      peerSession = this.sessionManager.getSession(identityKey !== undefined && identityKey !== '' ? identityKey : sessionNonce)
+      if (peerSession === undefined || !peerSession.isAuthenticated) {
         throw new Error('Unable to establish mutual authentication with peer!')
       }
     }
@@ -175,7 +239,9 @@ export class Peer {
    * @param {(senderPublicKey: string, payload: number[]) => void} callback - The function to call when a general message is received.
    * @returns {number} The ID of the callback listener.
    */
-  listenForGeneralMessages (callback: (senderPublicKey: string, payload: number[]) => void): number {
+  listenForGeneralMessages (
+    callback: (senderPublicKey: string, payload: number[]) => void
+  ): number {
     const callbackID = this.callbackIdCounter++
     this.onGeneralMessageReceivedCallbacks.set(callbackID, callback)
     return callbackID
@@ -196,7 +262,9 @@ export class Peer {
    * @param {(certs: VerifiableCertificate[]) => void} callback - The function to call when certificates are received.
    * @returns {number} The ID of the callback listener.
    */
-  listenForCertificatesReceived (callback: (senderPublicKey: string, certs: VerifiableCertificate[]) => void): number {
+  listenForCertificatesReceived (
+    callback: (senderPublicKey: string, certs: VerifiableCertificate[]) => void
+  ): number {
     const callbackID = this.callbackIdCounter++
     this.onCertificatesReceivedCallbacks.set(callbackID, callback)
     return callbackID
@@ -217,7 +285,12 @@ export class Peer {
    * @param {(requestedCertificates: RequestedCertificateSet) => void} callback - The function to call when a certificate request is received
    * @returns {number} The ID of the callback listener.
    */
-  listenForCertificatesRequested (callback: (senderPublicKey: string, requestedCertificates: RequestedCertificateSet) => void): number {
+  listenForCertificatesRequested (
+    callback: (
+      senderPublicKey: string,
+      requestedCertificates: RequestedCertificateSet
+    ) => void
+  ): number {
     const callbackID = this.callbackIdCounter++
     this.onCertificateRequestReceivedCallbacks.set(callbackID, callback)
     return callbackID
@@ -239,7 +312,10 @@ export class Peer {
    * @param {string} [identityKey] - The identity public key of the peer.
    * @returns {Promise<string>} A promise that resolves to the session nonce.
    */
-  private async initiateHandshake (identityKey?: string, maxWaitTime = 10000): Promise<string> {
+  private async initiateHandshake (
+    identityKey?: string,
+    maxWaitTime = 10000
+  ): Promise<string> {
     const sessionNonce = await createNonce(this.wallet) // Initial request nonce
     this.sessionManager.addSession({
       isAuthenticated: false,
@@ -250,7 +326,8 @@ export class Peer {
     const initialRequest: AuthMessage = {
       version: AUTH_VERSION,
       messageType: 'initialRequest',
-      identityKey: (await this.wallet.getPublicKey({ identityKey: true })).publicKey,
+      identityKey: (await this.wallet.getPublicKey({ identityKey: true }))
+        .publicKey,
       initialNonce: sessionNonce,
       requestedCertificates: this.certificatesToRequest
     }
@@ -265,13 +342,19 @@ export class Peer {
    * @param {string} sessionNonce - The session nonce created in the initial request.
    * @returns {Promise<string>} A promise that resolves with the session nonce when the initial response is received.
    */
-  private async waitForInitialResponse (sessionNonce: string, maxWaitTime = 10000): Promise<string> {
+  private async waitForInitialResponse (
+    sessionNonce: string,
+    maxWaitTime = 10000
+  ): Promise<string> {
     return await new Promise((resolve, reject) => {
-      const callbackID = this.listenForInitialResponse(sessionNonce, (sessionNonce) => {
-        clearTimeout(timeoutHandle)
-        this.stopListeningForInitialResponses(callbackID)
-        resolve(sessionNonce)
-      })
+      const callbackID = this.listenForInitialResponse(
+        sessionNonce,
+        sessionNonce => {
+          clearTimeout(timeoutHandle)
+          this.stopListeningForInitialResponses(callbackID)
+          resolve(sessionNonce)
+        }
+      )
 
       const timeoutHandle = setTimeout(() => {
         this.stopListeningForInitialResponses(callbackID)
@@ -288,9 +371,15 @@ export class Peer {
    * @param {(sessionNonce: string) => void} callback - The callback to invoke when the initial response is received.
    * @returns {number} The ID of the callback listener.
    */
-  private listenForInitialResponse (sessionNonce: string, callback: (sessionNonce: string) => void) {
+  private listenForInitialResponse (
+    sessionNonce: string,
+    callback: (sessionNonce: string) => void
+  ): number {
     const callbackID = this.callbackIdCounter++
-    this.onInitialResponseReceivedCallbacks.set(callbackID, { callback, sessionNonce })
+    this.onInitialResponseReceivedCallbacks.set(callbackID, {
+      callback,
+      sessionNonce
+    })
     return callbackID
   }
 
@@ -300,7 +389,7 @@ export class Peer {
    * @private
    * @param {number} callbackID - The ID of the callback to remove.
    */
-  private stopListeningForInitialResponses (callbackID: number) {
+  private stopListeningForInitialResponses (callbackID: number): void {
     this.onInitialResponseReceivedCallbacks.delete(callbackID)
   }
 
@@ -311,8 +400,10 @@ export class Peer {
    * @returns {Promise<void>}
    */
   private async handleIncomingMessage (message: AuthMessage): Promise<void> {
-    if (!message.version || message.version !== AUTH_VERSION) {
-      console.error(`Invalid message auth version! Received: ${message.version}, expected: ${AUTH_VERSION}`)
+    if (message.version === undefined || message.version === '' || message.version !== AUTH_VERSION) {
+      console.error(
+        `Invalid message auth version! Received: ${message.version}, expected: ${AUTH_VERSION}`
+      )
       return
     }
 
@@ -333,7 +424,9 @@ export class Peer {
         await this.processGeneralMessage(message)
         break
       default:
-        console.error(`Unknown message type of ${message.messageType} from ${message.identityKey}`)
+        console.error(
+          `Unknown message type of ${String(message.messageType)} from ${String(message.identityKey)}`
+        )
     }
   }
 
@@ -343,8 +436,8 @@ export class Peer {
    * @param {AuthMessage} message - The incoming initial request message.
    * @returns {Promise<void>}
    */
-  async processInitialRequest (message: AuthMessage) {
-    if (!message.identityKey || !message.initialNonce) {
+  async processInitialRequest (message: AuthMessage): Promise<void> {
+    if (message.identityKey === undefined || message.identityKey === '' || message.initialNonce === undefined || message.initialNonce === '') {
       throw new Error('Missing required fields in initialResponse message.')
     }
 
@@ -359,15 +452,19 @@ export class Peer {
 
     // Handle initial certificate requests
     let certificatesToInclude
-    if (message.requestedCertificates?.certifiers?.length > 0) {
+    if (message.requestedCertificates !== undefined && Array.isArray(message.requestedCertificates?.certifiers) && message.requestedCertificates?.certifiers?.length > 0) {
       if (this.onCertificateRequestReceivedCallbacks.size > 0) {
         // The application wants to handle certificate requests
         this.onCertificateRequestReceivedCallbacks.forEach(callback => {
-          callback(message.identityKey, message.requestedCertificates)
+          callback(message.identityKey, message.requestedCertificates as RequestedCertificateSet)
         })
       } else {
         // Attempt to find exact matching certificates to return automatically to save round trips
-        certificatesToInclude = await getVerifiableCertificates(this.wallet, message.requestedCertificates, message.identityKey)
+        certificatesToInclude = await getVerifiableCertificates(
+          this.wallet,
+          message.requestedCertificates,
+          message.identityKey
+        )
       }
     }
 
@@ -382,7 +479,8 @@ export class Peer {
     const initialResponseMessage: AuthMessage = {
       version: AUTH_VERSION,
       messageType: 'initialResponse',
-      identityKey: (await this.wallet.getPublicKey({ identityKey: true })).publicKey,
+      identityKey: (await this.wallet.getPublicKey({ identityKey: true }))
+        .publicKey,
       initialNonce: sessionNonce,
       yourNonce: message.initialNonce,
       certificates: certificatesToInclude,
@@ -391,7 +489,7 @@ export class Peer {
     }
 
     // For security, only set the last-interacted-with peer here if this is the first peer we've interacted with.
-    if (!this.lastInteractedWithPeer) {
+    if (this.lastInteractedWithPeer === undefined || this.lastInteractedWithPeer === null) {
       this.lastInteractedWithPeer = message.identityKey
     }
 
@@ -406,27 +504,34 @@ export class Peer {
    * @returns {Promise<void>}
    * @throws Will throw an error if nonce verification or signature verification fails.
    */
-  private async processInitialResponse (message: AuthMessage) {
-    const validNonce = await verifyNonce(message.yourNonce, this.wallet)
+  private async processInitialResponse (message: AuthMessage): Promise<void> {
+    const validNonce = await verifyNonce(message.yourNonce as string, this.wallet)
     if (!validNonce) {
-      throw new Error(`Initial response nonce verification failed from peer: ${message.identityKey}`)
+      throw new Error(
+        `Initial response nonce verification failed from peer: ${message.identityKey}`
+      )
     }
 
-    const peerSession = this.sessionManager.getSession(message.yourNonce)
-    if (!peerSession) {
+    const peerSession = this.sessionManager.getSession(message.yourNonce as string)
+    if (peerSession === null || peerSession === undefined) {
       throw new Error(`Peer session not found for peer: ${message.identityKey}`)
     }
 
     // Validate message signature
     const { valid } = await this.wallet.verifySignature({
-      data: Utils.toArray(peerSession.sessionNonce + message.initialNonce, 'base64'),
-      signature: message.signature,
+      data: Utils.toArray(
+        (peerSession.sessionNonce ?? '') + (message.initialNonce ?? ''),
+        'base64'
+      ),
+      signature: message.signature as number[],
       protocolID: [2, 'auth message signature'],
-      keyID: `${peerSession.sessionNonce} ${message.initialNonce}`,
+      keyID: `${peerSession.sessionNonce ?? ''} ${message.initialNonce ?? ''}`,
       counterparty: message.identityKey
     })
     if (!valid) {
-      throw new Error(`Unable to verify initial response signature for peer: ${message.identityKey}`)
+      throw new Error(
+        `Unable to verify initial response signature for peer: ${message.identityKey}`
+      )
     }
 
     // After signature and nonce verification is complete, the peer is considered authenticated
@@ -439,33 +544,50 @@ export class Peer {
     this.sessionManager.updateSession(peerSession)
 
     // Process certificates received
-    if (this.certificatesToRequest?.certifiers?.length && message.certificates?.length) {
-      await validateCertificates(this.wallet, message, this.certificatesToRequest)
-
-      this.onCertificatesReceivedCallbacks.forEach(callback =>
-        callback(message.identityKey, message.certificates)
+    if (
+      (this.certificatesToRequest?.certifiers?.length ?? 0) > 0 &&
+      (message.certificates !== null && message.certificates !== undefined && message.certificates.length > 0)
+    ) {
+      await validateCertificates(
+        this.wallet,
+        message,
+        this.certificatesToRequest
       )
+
+      const messageCertificates = message.certificates
+      if (message.certificates !== undefined) {
+        this.onCertificatesReceivedCallbacks.forEach(callback =>
+          callback(message.identityKey, messageCertificates)
+        )
+      }
     }
 
     this.lastInteractedWithPeer = message.identityKey
 
-    this.onInitialResponseReceivedCallbacks.forEach((entry) => {
-      if (entry && entry.sessionNonce === peerSession.sessionNonce) {
+    this.onInitialResponseReceivedCallbacks.forEach(entry => {
+      if (entry?.sessionNonce === peerSession.sessionNonce) {
         entry.callback(peerSession.sessionNonce)
       }
     })
 
     // Check if the peer requested certificates from us
-    if (message.requestedCertificates?.certifiers?.length > 0) {
+    if (message.requestedCertificates !== undefined && Array.isArray(message.requestedCertificates?.certifiers) && message.requestedCertificates?.certifiers?.length > 0) {
       if (this.onCertificateRequestReceivedCallbacks.size > 0) {
         // Application wants to handle certificate requests
         this.onCertificateRequestReceivedCallbacks.forEach(callback => {
-          callback(message.identityKey, message.requestedCertificates)
+          callback(message.identityKey, message.requestedCertificates as RequestedCertificateSet)
         })
       } else {
         // Attempt to find exact matching certificates to respond automatically and save round trips
-        const verifiableCertificates = await getVerifiableCertificates(this.wallet, message.requestedCertificates, message.identityKey)
-        await this.sendCertificateResponse(message.identityKey, verifiableCertificates)
+        const verifiableCertificates = await getVerifiableCertificates(
+          this.wallet,
+          message.requestedCertificates,
+          message.identityKey
+        )
+        await this.sendCertificateResponse(
+          message.identityKey,
+          verifiableCertificates
+        )
       }
     }
   }
@@ -478,35 +600,49 @@ export class Peer {
    * @param {AuthMessage} message - The certificate request message received from the peer.
    * @throws {Error} Throws an error if nonce verification fails, or the message signature is invalid.
    */
-  private async processCertificateRequest (message: AuthMessage) {
-    const validNonce = await verifyNonce(message.yourNonce, this.wallet)
+  private async processCertificateRequest (message: AuthMessage): Promise<void> {
+    const validNonce = await verifyNonce(message.yourNonce as string, this.wallet)
     if (!validNonce) {
-      throw new Error(`Unable to verify nonce for certificate request message from: ${message.identityKey}`)
+      throw new Error(
+        `Unable to verify nonce for certificate request message from: ${message.identityKey}`
+      )
     }
-    const peerSession = this.sessionManager.getSession(message.yourNonce)
+    const peerSession = this.sessionManager.getSession(message.yourNonce as string)
 
     const { valid } = await this.wallet.verifySignature({
-      data: Utils.toArray(JSON.stringify(message.requestedCertificates), 'utf8'),
-      signature: message.signature,
+      data: Utils.toArray(
+        JSON.stringify(message.requestedCertificates),
+        'utf8'
+      ),
+      signature: message.signature as number[],
       protocolID: [2, 'auth message signature'],
-      keyID: `${message.nonce} ${peerSession.sessionNonce}`,
-      counterparty: peerSession.peerIdentityKey
+      keyID: `${message.nonce ?? ''} ${peerSession?.sessionNonce ?? ''}`,
+      counterparty: peerSession?.peerIdentityKey
     })
 
     if (!valid) {
-      throw new Error(`Invalid signature in certificate request message from ${peerSession.peerIdentityKey}`)
+      throw new Error(
+        `Invalid signature in certificate request message from ${peerSession?.peerIdentityKey ?? 'unknown'}`
+      )
     }
 
-    if (message.requestedCertificates?.certifiers?.length > 0) {
+    if (message.requestedCertificates !== undefined && Array.isArray(message.requestedCertificates?.certifiers) && message.requestedCertificates?.certifiers?.length > 0) {
       if (this.onCertificateRequestReceivedCallbacks.size > 0) {
         // Application wants to handle certificate requests
         this.onCertificateRequestReceivedCallbacks.forEach(callback => {
-          callback(message.identityKey, message.requestedCertificates)
+          callback(message.identityKey, message.requestedCertificates as RequestedCertificateSet)
         })
       } else {
         // Attempt to find exact matching certificates to respond automatically and save round trips
-        const verifiableCertificates = await getVerifiableCertificates(this.wallet, message.requestedCertificates, message.identityKey)
-        await this.sendCertificateResponse(message.identityKey, verifiableCertificates)
+        const verifiableCertificates = await getVerifiableCertificates(
+          this.wallet,
+          message.requestedCertificates,
+          message.identityKey
+        )
+        await this.sendCertificateResponse(
+          message.identityKey,
+          verifiableCertificates
+        )
       }
     }
   }
@@ -523,20 +659,21 @@ export class Peer {
   async sendCertificateResponse (
     verifierIdentityKey: string,
     certificates: VerifiableCertificate[]
-  ) {
+  ): Promise<void> {
     const peerSession = await this.getAuthenticatedSession(verifierIdentityKey)
     const requestNonce = Utils.toBase64(Random(32))
     const { signature } = await this.wallet.createSignature({
       data: Utils.toArray(JSON.stringify(certificates), 'utf8'),
       protocolID: [2, 'auth message signature'],
-      keyID: `${requestNonce} ${peerSession.peerNonce}`,
+      keyID: `${requestNonce} ${peerSession.peerNonce ?? ''}`,
       counterparty: peerSession.peerIdentityKey
     })
 
     const certificateResponse: AuthMessage = {
       version: AUTH_VERSION,
       messageType: 'certificateResponse',
-      identityKey: (await this.wallet.getPublicKey({ identityKey: true })).publicKey,
+      identityKey: (await this.wallet.getPublicKey({ identityKey: true }))
+        .publicKey,
       nonce: requestNonce,
       initialNonce: peerSession.sessionNonce,
       yourNonce: peerSession.peerNonce,
@@ -546,8 +683,11 @@ export class Peer {
 
     try {
       await this.transport.send(certificateResponse)
-    } catch (error) {
-      throw new Error(`Failed to send certificate response message to peer ${peerSession.peerIdentityKey}: ${error.message}`)
+    } catch (error: any) {
+      const errorMessage = error instanceof Error ? error.message : String(error)
+      throw new Error(
+        `Failed to send certificate response message to peer ${peerSession.peerIdentityKey ?? 'unknown'}: ${errorMessage}`
+      )
     }
   }
 
@@ -559,33 +699,39 @@ export class Peer {
    * @returns {Promise<void>}
    * @throws Will throw an error if nonce verification or signature verification fails.
    */
-  private async processCertificateResponse (
-    message: AuthMessage
-  ) {
-    const validNonce = await verifyNonce(message.yourNonce, this.wallet)
+  private async processCertificateResponse (message: AuthMessage): Promise<void> {
+    const validNonce = await verifyNonce(message.yourNonce as string, this.wallet)
     if (!validNonce) {
-      throw new Error(`Unable to verify nonce for certificate response from: ${message.identityKey}!`)
+      throw new Error(
+        `Unable to verify nonce for certificate response from: ${message.identityKey}!`
+      )
     }
-    const peerSession = this.sessionManager.getSession(message.yourNonce)
+    const peerSession = this.sessionManager.getSession(message.yourNonce as string)
 
     // Validate message signature
     const { valid } = await this.wallet.verifySignature({
       data: Utils.toArray(JSON.stringify(message.certificates), 'utf8'),
-      signature: message.signature,
+      signature: message.signature as number[],
       protocolID: [2, 'auth message signature'],
-      keyID: `${message.nonce} ${peerSession.sessionNonce}`,
+      keyID: `${message.nonce ?? ''} ${peerSession?.sessionNonce ?? ''}`,
       counterparty: message.identityKey
     })
 
     if (!valid) {
-      throw new Error(`Unable to verify certificate response signature for peer: ${message.identityKey}`)
+      throw new Error(
+        `Unable to verify certificate response signature for peer: ${message.identityKey}`
+      )
     }
 
     // Process and verify any certificates received
-    await validateCertificates(this.wallet, message, message.requestedCertificates)
+    await validateCertificates(
+      this.wallet,
+      message,
+      message.requestedCertificates
+    )
 
     this.onCertificatesReceivedCallbacks.forEach(callback => {
-      callback(message.identityKey, message.certificates)
+      callback(message.identityKey, message.certificates as VerifiableCertificate[])
     })
   }
 
@@ -597,29 +743,33 @@ export class Peer {
    * @returns {Promise<void>}
    * @throws Will throw an error if nonce verification or signature verification fails.
    */
-  private async processGeneralMessage (message: AuthMessage) {
-    const validNonce = await verifyNonce(message.yourNonce, this.wallet)
+  private async processGeneralMessage (message: AuthMessage): Promise<void> {
+    const validNonce = await verifyNonce(message.yourNonce as string, this.wallet)
     if (!validNonce) {
-      throw new Error(`Unable to verify nonce for general message from: ${message.identityKey}`)
+      throw new Error(
+        `Unable to verify nonce for general message from: ${message.identityKey}`
+      )
     }
-    const peerSession = this.sessionManager.getSession(message.yourNonce)
+    const peerSession = this.sessionManager.getSession(message.yourNonce as string)
 
     const { valid } = await this.wallet.verifySignature({
       data: message.payload,
-      signature: message.signature,
+      signature: message.signature as number[],
       protocolID: [2, 'auth message signature'],
-      keyID: `${message.nonce} ${peerSession.sessionNonce}`,
-      counterparty: peerSession.peerIdentityKey
+      keyID: `${message.nonce ?? ''} ${peerSession?.sessionNonce ?? ''}`,
+      counterparty: peerSession?.peerIdentityKey
     })
 
     if (!valid) {
-      throw new Error(`Invalid signature in generalMessage from ${peerSession.peerIdentityKey}`)
+      throw new Error(
+        `Invalid signature in generalMessage from ${peerSession?.peerIdentityKey ?? 'unknown'}`
+      )
     }
 
     this.lastInteractedWithPeer = message.identityKey
 
     this.onGeneralMessageReceivedCallbacks.forEach(callback => {
-      callback(message.identityKey, message.payload)
+      callback(message.identityKey, message.payload as number[])
     })
   }
 }