@bsv/sdk 1.3.13 → 1.3.14

package/src/auth/Peer.ts

@@ -1,18 +1,18 @@
-import { SessionManager } from './SessionManager'
+import { SessionManager } from './SessionManager.js'
 import {
   createNonce,
   verifyNonce,
   getVerifiableCertificates,
   validateCertificates
-} from './utils/index'
+} from './utils/index.js'
 import {
   AuthMessage,
   PeerSession,
   RequestedCertificateSet,
   Transport
-} from './types'
-import { VerifiableCertificate } from './certificates/VerifiableCertificate'
-import { Random, Utils, WalletInterface } from '../../mod'
+} from './types.js'
+import { VerifiableCertificate } from './certificates/VerifiableCertificate.js'
+import { Random, Utils, WalletInterface } from '../../mod.js'
 
 const AUTH_VERSION = '0.1'
 
@@ -80,9 +80,9 @@ export class Peer {
       certifiers: [],
       types: {}
     }
-    this.transport.onData(this.handleIncomingMessage.bind(this))
-    this.sessionManager = sessionManager || new SessionManager()
-    if (!autoPersistLastSession) {
+    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
@@ -104,7 +104,8 @@ export class Peer {
   ): Promise<void> {
     if (
       this.autoPersistLastSession &&
-      this.lastInteractedWithPeer &&
+      this.lastInteractedWithPeer !== undefined &&
+      this.lastInteractedWithPeer !== null &&
       typeof identityKey !== 'string'
     ) {
       identityKey = this.lastInteractedWithPeer
@@ -119,7 +120,7 @@ export class Peer {
     const { signature } = await this.wallet.createSignature({
       data: message,
       protocolID: [2, 'auth message signature'],
-      keyID: `${requestNonce} ${peerSession.peerNonce}`,
+      keyID: `${requestNonce} ${peerSession.peerNonce ?? ''}`,
       counterparty: peerSession.peerIdentityKey
     })
 
@@ -138,7 +139,7 @@ export class Peer {
       await this.transport.send(generalMessage)
     } catch (error) {
       const e = new Error(
-        `Failed to send message to peer ${peerSession.peerIdentityKey}: ${error.message}`
+        `Failed to send message to peer ${peerSession.peerIdentityKey ?? 'unknown'}: ${String(error.message)}`
       )
       e.stack = error.stack
       throw e
@@ -171,7 +172,7 @@ export class Peer {
     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
     })
 
@@ -189,9 +190,9 @@ export class Peer {
 
     try {
       await this.transport.send(certRequestMessage)
-    } catch (error) {
+    } catch (error: any) {
       throw new Error(
-        `Failed to send certificate request message to peer ${peerSession.peerIdentityKey}: ${error.message}`
+        `Failed to send certificate request message to peer ${peerSession.peerIdentityKey ?? 'unknown'}: ${String(error.message)}`
       )
     }
   }
@@ -211,20 +212,20 @@ export class Peer {
     identityKey?: string,
     maxWaitTime?: number
   ): Promise<PeerSession> {
-    if (!this.transport) {
+    if (this.transport === undefined) {
       throw new Error('Peer transport is not connected!')
     }
 
-    let peerSession = identityKey
+    let peerSession = identityKey !== undefined && identityKey !== ''
       ? this.sessionManager.getSession(identityKey)
       : undefined
-    if (!peerSession || !peerSession.isAuthenticated) {
+    if (peerSession === undefined || !peerSession?.isAuthenticated) {
       const sessionNonce = await this.initiateHandshake(
         identityKey,
         maxWaitTime
       )
-      peerSession = this.sessionManager.getSession(identityKey || sessionNonce)
-      if (!peerSession.isAuthenticated) {
+      peerSession = this.sessionManager.getSession(identityKey !== undefined && identityKey !== '' ? identityKey : sessionNonce)
+      if (peerSession === undefined || !peerSession.isAuthenticated) {
         throw new Error('Unable to establish mutual authentication with peer!')
       }
     }
@@ -373,7 +374,7 @@ export class Peer {
   private listenForInitialResponse (
     sessionNonce: string,
     callback: (sessionNonce: string) => void
-  ) {
+  ): number {
     const callbackID = this.callbackIdCounter++
     this.onInitialResponseReceivedCallbacks.set(callbackID, {
       callback,
@@ -388,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)
   }
 
@@ -399,7 +400,7 @@ export class Peer {
    * @returns {Promise<void>}
    */
   private async handleIncomingMessage (message: AuthMessage): Promise<void> {
-    if (!message.version || message.version !== AUTH_VERSION) {
+    if (message.version === undefined || message.version === '' || message.version !== AUTH_VERSION) {
       console.error(
         `Invalid message auth version! Received: ${message.version}, expected: ${AUTH_VERSION}`
       )
@@ -424,7 +425,7 @@ export class Peer {
         break
       default:
         console.error(
-          `Unknown message type of ${message.messageType} from ${message.identityKey}`
+          `Unknown message type of ${String(message.messageType)} from ${String(message.identityKey)}`
         )
     }
   }
@@ -435,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.')
     }
 
@@ -451,11 +452,11 @@ 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
@@ -488,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
     }
 
@@ -503,28 +504,28 @@ 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}`
       )
     }
 
-    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,
+        (peerSession.sessionNonce ?? '') + (message.initialNonce ?? ''),
         'base64'
       ),
-      signature: message.signature,
+      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) {
@@ -544,8 +545,8 @@ export class Peer {
 
     // Process certificates received
     if (
-      this.certificatesToRequest?.certifiers?.length &&
-      message.certificates?.length
+      (this.certificatesToRequest?.certifiers?.length ?? 0) > 0 &&
+      (message.certificates !== null && message.certificates !== undefined && message.certificates.length > 0)
     ) {
       await validateCertificates(
         this.wallet,
@@ -553,25 +554,28 @@ export class Peer {
         this.certificatesToRequest
       )
 
-      this.onCertificatesReceivedCallbacks.forEach(callback =>
-        callback(message.identityKey, message.certificates)
-      )
+      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) {
+      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
@@ -596,37 +600,37 @@ 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}`
       )
     }
-    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,
+      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}`
+        `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
@@ -655,13 +659,13 @@ 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
     })
 
@@ -679,9 +683,10 @@ export class Peer {
 
     try {
       await this.transport.send(certificateResponse)
-    } catch (error) {
+    } 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}: ${error.message}`
+        `Failed to send certificate response message to peer ${peerSession.peerIdentityKey ?? 'unknown'}: ${errorMessage}`
       )
     }
   }
@@ -694,21 +699,21 @@ 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}!`
       )
     }
-    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
     })
 
@@ -726,7 +731,7 @@ export class Peer {
     )
 
     this.onCertificatesReceivedCallbacks.forEach(callback => {
-      callback(message.identityKey, message.certificates)
+      callback(message.identityKey, message.certificates as VerifiableCertificate[])
     })
   }
 
@@ -738,33 +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}`
       )
     }
-    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}`
+        `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[])
     })
   }
 }

package/src/auth/SessionManager.ts

@@ -1,4 +1,4 @@
-import { PeerSession } from './types'
+import { PeerSession } from './types.js'
 
 /**
  * Manages sessions for peers, allowing sessions to be added, retrieved, updated, and removed
@@ -17,16 +17,17 @@ export class SessionManager {
    * @param {PeerSession} session - The peer session to add.
    */
   addSession (session: PeerSession): void {
-    if (!session.sessionNonce && !session.peerIdentityKey) {
+    if ((session.sessionNonce === null || session.sessionNonce === undefined || session.sessionNonce === '') &&
+      (session.peerIdentityKey === null || session.peerIdentityKey === undefined || session.peerIdentityKey === '')) {
       throw new Error(
         'Invalid session: at least one of sessionNonce or peerIdentityKey is required.'
       )
     }
 
-    if (session.sessionNonce) {
+    if (session.sessionNonce !== null && session.sessionNonce !== undefined && session.sessionNonce !== '') {
       this.identifierToSession.set(session.sessionNonce, session)
     }
-    if (session.peerIdentityKey) {
+    if (session.peerIdentityKey !== null && session.peerIdentityKey !== undefined && session.peerIdentityKey !== '') {
       this.identifierToSession.set(session.peerIdentityKey, session)
     }
   }
@@ -57,8 +58,12 @@ export class SessionManager {
    * @param {PeerSession} session - The peer session to remove.
    */
   removeSession (session: PeerSession): void {
-    this.identifierToSession.delete(session.sessionNonce)
-    this.identifierToSession.delete(session.peerIdentityKey)
+    if (session.sessionNonce !== null && session.sessionNonce !== undefined && session.sessionNonce !== '') {
+      this.identifierToSession.delete(session.sessionNonce)
+    }
+    if (session.peerIdentityKey !== null && session.peerIdentityKey !== undefined && session.peerIdentityKey !== '') {
+      this.identifierToSession.delete(session.peerIdentityKey)
+    }
   }
 
   /**