@bsv/sdk 1.3.11 → 1.3.13

package/mod.ts

@@ -1,15 +1,15 @@
-export * from "./src/primitives/index.js"
-export * from "./src/script/index.js"
-export * from "./src/script/templates/index.js"
-export * from "./src/transaction/index.js"
-export * from "./src/transaction/fee-models/index.js"
-export * from "./src/transaction/broadcasters/index.js"
-export * from "./src/transaction/chaintrackers/index.js"
-export * from "./src/transaction/http/index.js"
-export * from "./src/messages/index.js"
-export * from "./src/compat/index.js"
-export * from "./src/totp/index.js"
-export * from "./src/wallet/index.js"
-export * from "./src/wallet/substrates/index.js"
-export * from "./src/auth/index.js"
-export * from "./src/overlay-tools/index.js"
+export * from './src/primitives/index'
+export * from './src/script/index'
+export * from './src/script/templates/index'
+export * from './src/transaction/index'
+export * from './src/transaction/fee-models/index'
+export * from './src/transaction/broadcasters/index'
+export * from './src/transaction/chaintrackers/index'
+export * from './src/transaction/http/index'
+export * from './src/messages/index'
+export * from './src/compat/index'
+export * from './src/totp/index'
+export * from './src/wallet/index'
+export * from './src/wallet/substrates/index'
+export * from './src/auth/index'
+export * from './src/overlay-tools/index'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "1.3.11",
+  "version": "1.3.13",
   "type": "module",
   "description": "BSV Blockchain Software Development Kit",
   "main": "dist/cjs/mod.js",
@@ -192,6 +192,7 @@
     "test": "npm run build && jest",
     "test:watch": "npm run build && jest --watch",
     "test:coverage": "npm run build && jest --coverage",
+    "lint:ci": "ts-standard src/**/*.ts",
     "lint": "ts-standard --fix src/**/*.ts",
     "build": "npm run build:ts && npm run build:umd",
     "build:ts": "tsc -b && tsconfig-to-dual-package tsconfig.cjs.json",
@@ -224,10 +225,17 @@
     "ts-jest": "^29.1.1",
     "ts-loader": "^9.5.1",
     "ts-standard": "^12.0.2",
-    "ts2md": "^0.2.5",
+    "ts2md": "^0.2.8",
     "tsconfig-to-dual-package": "^1.2.0",
     "typescript": "^5.2.2",
     "webpack": "^5.95.0",
     "webpack-cli": "^5.1.4"
+  },
+  "ts-standard": {
+    "project": "tsconfig.eslint.json",
+    "ignore": [
+      "dist",
+      "src/**/*.ts"
+    ]
   }
 }

package/src/auth/Peer.ts

@@ -1,8 +1,18 @@
-import { SessionManager } from './SessionManager.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'
+import { SessionManager } from './SessionManager'
+import {
+  createNonce,
+  verifyNonce,
+  getVerifiableCertificates,
+  validateCertificates
+} from './utils/index'
+import {
+  AuthMessage,
+  PeerSession,
+  RequestedCertificateSet,
+  Transport
+} from './types'
+import { VerifiableCertificate } from './certificates/VerifiableCertificate'
+import { Random, Utils, WalletInterface } from '../../mod'
 
 const AUTH_VERSION = '0.1'
 
@@ -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,7 +76,10 @@ export class Peer {
   ) {
     this.wallet = wallet
     this.transport = transport
-    this.certificatesToRequest = certificatesToRequest ?? { certifiers: [], types: {} }
+    this.certificatesToRequest = certificatesToRequest ?? {
+      certifiers: [],
+      types: {}
+    }
     this.transport.onData(this.handleIncomingMessage.bind(this))
     this.sessionManager = sessionManager || new SessionManager()
     if (!autoPersistLastSession) {
@@ -66,11 +97,22 @@ 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 &&
+      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))
@@ -84,7 +126,8 @@ export class Peer {
     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,25 +137,34 @@ 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}: ${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))
@@ -126,7 +178,8 @@ export class Peer {
     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,
@@ -137,7 +190,9 @@ 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}`)
+      throw new Error(
+        `Failed to send certificate request message to peer ${peerSession.peerIdentityKey}: ${error.message}`
+      )
     }
   }
 
@@ -152,14 +207,22 @@ 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> {
+  async getAuthenticatedSession (
+    identityKey?: string,
+    maxWaitTime?: number
+  ): Promise<PeerSession> {
     if (!this.transport) {
       throw new Error('Peer transport is not connected!')
     }
 
-    let peerSession = identityKey ? this.sessionManager.getSession(identityKey) : undefined
+    let peerSession = identityKey
+      ? this.sessionManager.getSession(identityKey)
+      : undefined
     if (!peerSession || !peerSession.isAuthenticated) {
-      const sessionNonce = await this.initiateHandshake(identityKey, maxWaitTime)
+      const sessionNonce = await this.initiateHandshake(
+        identityKey,
+        maxWaitTime
+      )
       peerSession = this.sessionManager.getSession(identityKey || sessionNonce)
       if (!peerSession.isAuthenticated) {
         throw new Error('Unable to establish mutual authentication with peer!')
@@ -175,7 +238,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 +261,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 +284,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 +311,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 +325,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 +341,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 +370,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
+  ) {
     const callbackID = this.callbackIdCounter++
-    this.onInitialResponseReceivedCallbacks.set(callbackID, { callback, sessionNonce })
+    this.onInitialResponseReceivedCallbacks.set(callbackID, {
+      callback,
+      sessionNonce
+    })
     return callbackID
   }
 
@@ -312,7 +400,9 @@ export class Peer {
    */
   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}`)
+      console.error(
+        `Invalid message auth version! Received: ${message.version}, expected: ${AUTH_VERSION}`
+      )
       return
     }
 
@@ -333,7 +423,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 ${message.messageType} from ${message.identityKey}`
+        )
     }
   }
 
@@ -367,7 +459,11 @@ export class Peer {
         })
       } 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 +478,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,
@@ -409,7 +506,9 @@ export class Peer {
   private async processInitialResponse (message: AuthMessage) {
     const validNonce = await verifyNonce(message.yourNonce, 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)
@@ -419,14 +518,19 @@ export class Peer {
 
     // Validate message signature
     const { valid } = await this.wallet.verifySignature({
-      data: Utils.toArray(peerSession.sessionNonce + message.initialNonce, 'base64'),
+      data: Utils.toArray(
+        peerSession.sessionNonce + message.initialNonce,
+        'base64'
+      ),
       signature: message.signature,
       protocolID: [2, 'auth message signature'],
       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,8 +543,15 @@ 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)
+    if (
+      this.certificatesToRequest?.certifiers?.length &&
+      message.certificates?.length
+    ) {
+      await validateCertificates(
+        this.wallet,
+        message,
+        this.certificatesToRequest
+      )
 
       this.onCertificatesReceivedCallbacks.forEach(callback =>
         callback(message.identityKey, message.certificates)
@@ -449,7 +560,7 @@ export class Peer {
 
     this.lastInteractedWithPeer = message.identityKey
 
-    this.onInitialResponseReceivedCallbacks.forEach((entry) => {
+    this.onInitialResponseReceivedCallbacks.forEach(entry => {
       if (entry && entry.sessionNonce === peerSession.sessionNonce) {
         entry.callback(peerSession.sessionNonce)
       }
@@ -464,8 +575,15 @@ export class Peer {
         })
       } 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
+        )
       }
     }
   }
@@ -481,12 +599,17 @@ export class Peer {
   private async processCertificateRequest (message: AuthMessage) {
     const validNonce = await verifyNonce(message.yourNonce, 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 { valid } = await this.wallet.verifySignature({
-      data: Utils.toArray(JSON.stringify(message.requestedCertificates), 'utf8'),
+      data: Utils.toArray(
+        JSON.stringify(message.requestedCertificates),
+        'utf8'
+      ),
       signature: message.signature,
       protocolID: [2, 'auth message signature'],
       keyID: `${message.nonce} ${peerSession.sessionNonce}`,
@@ -494,7 +617,9 @@ export class Peer {
     })
 
     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}`
+      )
     }
 
     if (message.requestedCertificates?.certifiers?.length > 0) {
@@ -505,8 +630,15 @@ export class Peer {
         })
       } 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
+        )
       }
     }
   }
@@ -536,7 +668,8 @@ export class Peer {
     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,
@@ -547,7 +680,9 @@ 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}`)
+      throw new Error(
+        `Failed to send certificate response message to peer ${peerSession.peerIdentityKey}: ${error.message}`
+      )
     }
   }
 
@@ -559,12 +694,12 @@ export class Peer {
    * @returns {Promise<void>}
    * @throws Will throw an error if nonce verification or signature verification fails.
    */
-  private async processCertificateResponse (
-    message: AuthMessage
-  ) {
+  private async processCertificateResponse (message: AuthMessage) {
     const validNonce = await verifyNonce(message.yourNonce, 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)
 
@@ -578,11 +713,17 @@ export class Peer {
     })
 
     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)
@@ -600,7 +741,9 @@ export class Peer {
   private async processGeneralMessage (message: AuthMessage) {
     const validNonce = await verifyNonce(message.yourNonce, 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)
 
@@ -613,7 +756,9 @@ export class Peer {
     })
 
     if (!valid) {
-      throw new Error(`Invalid signature in generalMessage from ${peerSession.peerIdentityKey}`)
+      throw new Error(
+        `Invalid signature in generalMessage from ${peerSession.peerIdentityKey}`
+      )
     }
 
     this.lastInteractedWithPeer = message.identityKey

package/src/auth/SessionManager.ts

@@ -1,4 +1,4 @@
-import { PeerSession } from './types.js'
+import { PeerSession } from './types'
 
 /**
  * Manages sessions for peers, allowing sessions to be added, retrieved, updated, and removed
@@ -18,7 +18,9 @@ export class SessionManager {
    */
   addSession (session: PeerSession): void {
     if (!session.sessionNonce && !session.peerIdentityKey) {
-      throw new Error('Invalid session: at least one of sessionNonce or peerIdentityKey is required.')
+      throw new Error(
+        'Invalid session: at least one of sessionNonce or peerIdentityKey is required.'
+      )
     }
 
     if (session.sessionNonce) {
@@ -30,10 +32,10 @@ export class SessionManager {
   }
 
   /**
-  * Updates a session in the manager, ensuring that all identifiers are correctly associated.
-  *
-  * @param {PeerSession} session - The peer session to update.
-  */
+   * Updates a session in the manager, ensuring that all identifiers are correctly associated.
+   *
+   * @param {PeerSession} session - The peer session to update.
+   */
   updateSession (session: PeerSession): void {
     this.removeSession(session)
     this.addSession(session)