@bsv/wallet-toolbox 1.7.15 → 1.7.17

package/mobile/node_modules/@bsv/sdk/dist/esm/src/auth/Peer.js

@@ -1,663 +0,0 @@
-import { SessionManager } from './SessionManager.js';
-import { createNonce, verifyNonce, getVerifiableCertificates, validateCertificates } from './utils/index.js';
-import Random from '../primitives/Random.js';
-import * as Utils from '../primitives/utils.js';
-const AUTH_VERSION = '0.1';
-const BufferCtor = typeof globalThis !== 'undefined' ? globalThis.Buffer : undefined;
-/**
- * Represents a peer capable of performing mutual authentication.
- * Manages sessions, handles authentication handshakes, certificate requests and responses,
- * and sending and receiving general messages over a transport layer.
- *
- * This version supports multiple concurrent sessions per peer identityKey.
- */
-export class Peer {
-    sessionManager;
-    transport;
-    wallet;
-    certificatesToRequest;
-    onGeneralMessageReceivedCallbacks = new Map();
-    onCertificatesReceivedCallbacks = new Map();
-    onCertificateRequestReceivedCallbacks = new Map();
-    onInitialResponseReceivedCallbacks = new Map();
-    // Single shared counter for all callback types
-    callbackIdCounter = 0;
-    // Whether to auto-persist the session with the last-interacted-with peer
-    autoPersistLastSession = true;
-    // Last-interacted-with peer identity key (if the user calls toPeer with no identityKey)
-    lastInteractedWithPeer;
-    originator;
-    identityPublicKey;
-    /**
-     * Creates a new Peer instance
-     *
-     * @param {WalletInterface} wallet - The wallet instance used for cryptographic operations.
-     * @param {Transport} transport - The transport mechanism used for sending and receiving messages.
-     * @param {RequestedCertificateSet} [certificatesToRequest] - Optional set of certificates to request from a peer during the initial handshake.
-     * @param {SessionManager} [sessionManager] - Optional SessionManager to be used for managing peer sessions.
-     * @param {boolean} [autoPersistLastSession] - Whether to auto-persist the session with the last-interacted-with peer. Defaults to true.
-     */
-    constructor(wallet, transport, certificatesToRequest, sessionManager, autoPersistLastSession, originator) {
-        this.wallet = wallet;
-        this.originator = originator;
-        this.transport = transport;
-        this.certificatesToRequest = certificatesToRequest ?? {
-            certifiers: [],
-            types: {}
-        };
-        this.transport.onData(this.handleIncomingMessage.bind(this)).catch(e => {
-            throw e;
-        });
-        this.sessionManager =
-            sessionManager != null ? sessionManager : new SessionManager();
-        if (autoPersistLastSession === false) {
-            this.autoPersistLastSession = false;
-        }
-        else {
-            this.autoPersistLastSession = true;
-        }
-    }
-    /**
-     * Sends a general message to a peer, and initiates a handshake if necessary.
-     *
-     * @param {number[]} message - The message payload to send.
-     * @param {string} [identityKey] - The identity public key of the peer. If not provided, uses lastInteractedWithPeer (if any).
-     * @param {number} [maxWaitTime] - optional max wait time in ms
-     * @returns {Promise<void>}
-     * @throws Will throw an error if the message fails to send.
-     */
-    async toPeer(message, identityKey, maxWaitTime) {
-        if (this.autoPersistLastSession &&
-            typeof this.lastInteractedWithPeer === 'string' &&
-            typeof identityKey !== 'string') {
-            identityKey = this.lastInteractedWithPeer;
-        }
-        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 ?? ''}`,
-            counterparty: peerSession.peerIdentityKey
-        }, this.originator);
-        const generalMessage = {
-            version: AUTH_VERSION,
-            messageType: 'general',
-            identityKey: await this.getIdentityPublicKey(),
-            nonce: requestNonce,
-            yourNonce: peerSession.peerNonce,
-            payload: message,
-            signature
-        };
-        peerSession.lastUpdate = Date.now();
-        this.sessionManager.updateSession(peerSession);
-        try {
-            await this.transport.send(generalMessage);
-        }
-        catch (error) {
-            this.propagateTransportError(peerSession.peerIdentityKey, error);
-        }
-    }
-    /**
-     * 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 or last 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, identityKey, maxWaitTime = 10000) {
-        if (this.autoPersistLastSession &&
-            typeof this.lastInteractedWithPeer === 'string' &&
-            typeof identityKey !== 'string') {
-            identityKey = this.lastInteractedWithPeer;
-        }
-        const peerSession = await this.getAuthenticatedSession(identityKey, maxWaitTime);
-        // Prepare the message
-        const requestNonce = Utils.toBase64(Random(32));
-        const { signature } = await this.wallet.createSignature({
-            data: Peer.utf8ToBytes(JSON.stringify(certificatesToRequest)),
-            protocolID: [2, 'auth message signature'],
-            keyID: `${requestNonce} ${peerSession.peerNonce ?? ''}`,
-            counterparty: peerSession.peerIdentityKey
-        }, this.originator);
-        const certRequestMessage = {
-            version: AUTH_VERSION,
-            messageType: 'certificateRequest',
-            identityKey: await this.getIdentityPublicKey(),
-            nonce: requestNonce,
-            initialNonce: peerSession.sessionNonce,
-            yourNonce: peerSession.peerNonce,
-            requestedCertificates: certificatesToRequest,
-            signature
-        };
-        // Update last-used timestamp
-        peerSession.lastUpdate = Date.now();
-        this.sessionManager.updateSession(peerSession);
-        try {
-            await this.transport.send(certRequestMessage);
-        }
-        catch (error) {
-            this.propagateTransportError(peerSession.peerIdentityKey, error);
-        }
-    }
-    /**
-     * Retrieves an authenticated session for a given peer identity. If no session exists
-     * or the session is not authenticated, initiates a handshake to create or authenticate the session.
-     *
-     * - If `identityKey` is provided, we look up any existing session for that identity key.
-     * - If none is found or not authenticated, we do a new handshake.
-     * - If `identityKey` is not provided, but we have a `lastInteractedWithPeer`, we try that key.
-     *
-     * @param {string} [identityKey] - The identity public key of the peer.
-     * @param {number} [maxWaitTime] - The maximum time in milliseconds to wait for the handshake.
-     * @returns {Promise<PeerSession>} - A promise that resolves with an authenticated `PeerSession`.
-     */
-    async getAuthenticatedSession(identityKey, maxWaitTime) {
-        if (this.transport === undefined) {
-            throw new Error('Peer transport is not connected!');
-        }
-        let peerSession;
-        if (typeof identityKey === 'string') {
-            peerSession = this.sessionManager.getSession(identityKey);
-        }
-        // If that session doesn't exist or isn't authenticated, initiate handshake
-        if ((peerSession == null) || !peerSession.isAuthenticated) {
-            // This will create a brand-new session
-            const sessionNonce = await this.initiateHandshake(identityKey, maxWaitTime);
-            // Now retrieve it by the sessionNonce
-            peerSession = this.sessionManager.getSession(sessionNonce);
-            if ((peerSession == null) || !peerSession.isAuthenticated) {
-                throw new Error('Unable to establish mutual authentication with peer!');
-            }
-        }
-        return peerSession;
-    }
-    /**
-     * Registers a callback to listen for general messages from peers.
-     *
-     * @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) {
-        const callbackID = this.callbackIdCounter++;
-        this.onGeneralMessageReceivedCallbacks.set(callbackID, callback);
-        return callbackID;
-    }
-    /**
-     * Removes a general message listener.
-     *
-     * @param {number} callbackID - The ID of the callback to remove.
-     */
-    stopListeningForGeneralMessages(callbackID) {
-        this.onGeneralMessageReceivedCallbacks.delete(callbackID);
-    }
-    /**
-     * Registers a callback to listen for certificates received from peers.
-     *
-     * @param {(senderPublicKey: string, certs: VerifiableCertificate[]) => void} callback - The function to call when certificates are received.
-     * @returns {number} The ID of the callback listener.
-     */
-    listenForCertificatesReceived(callback) {
-        const callbackID = this.callbackIdCounter++;
-        this.onCertificatesReceivedCallbacks.set(callbackID, callback);
-        return callbackID;
-    }
-    /**
-     * Cancels and unsubscribes a certificatesReceived listener.
-     *
-     * @param {number} callbackID - The ID of the certificates received callback to cancel.
-     */
-    stopListeningForCertificatesReceived(callbackID) {
-        this.onCertificatesReceivedCallbacks.delete(callbackID);
-    }
-    /**
-     * Registers a callback to listen for certificates requested from peers.
-     *
-     * @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) {
-        const callbackID = this.callbackIdCounter++;
-        this.onCertificateRequestReceivedCallbacks.set(callbackID, callback);
-        return callbackID;
-    }
-    /**
-     * Cancels and unsubscribes a certificatesRequested listener.
-     *
-     * @param {number} callbackID - The ID of the requested certificates callback to cancel.
-     */
-    stopListeningForCertificatesRequested(callbackID) {
-        this.onCertificateRequestReceivedCallbacks.delete(callbackID);
-    }
-    /**
-     * Initiates the mutual authentication handshake with a peer.
-     *
-     * @private
-     * @param {string} [identityKey] - The identity public key of the peer.
-     * @param {number} [maxWaitTime=10000] - how long to wait for handshake
-     * @returns {Promise<string>} A promise that resolves to the session nonce.
-     */
-    async initiateHandshake(identityKey, maxWaitTime = 10000) {
-        const sessionNonce = await createNonce(this.wallet, undefined, this.originator); // Initial request nonce
-        // Create the preliminary session (not yet authenticated)
-        const now = Date.now();
-        this.sessionManager.addSession({
-            isAuthenticated: false,
-            sessionNonce,
-            peerIdentityKey: identityKey,
-            lastUpdate: now
-        });
-        const initialRequest = {
-            version: AUTH_VERSION,
-            messageType: 'initialRequest',
-            identityKey: await this.getIdentityPublicKey(),
-            initialNonce: sessionNonce,
-            requestedCertificates: this.certificatesToRequest
-        };
-        await this.transport.send(initialRequest);
-        return await this.waitForInitialResponse(sessionNonce, maxWaitTime);
-    }
-    /**
-     * Waits for the initial response from the peer after sending an initial handshake request message.
-     *
-     * @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.
-     */
-    async waitForInitialResponse(sessionNonce, maxWaitTime = 10000) {
-        return await new Promise((resolve, reject) => {
-            const callbackID = this.listenForInitialResponse(sessionNonce, nonce => {
-                clearTimeout(timeoutHandle);
-                this.stopListeningForInitialResponses(callbackID);
-                resolve(nonce);
-            });
-            const timeoutHandle = setTimeout(() => {
-                this.stopListeningForInitialResponses(callbackID);
-                reject(new Error('Initial response timed out.'));
-            }, maxWaitTime);
-        });
-    }
-    /**
-     * Adds a listener for an initial response message matching a specific initial nonce.
-     *
-     * @private
-     * @param {string} sessionNonce - The session nonce to match.
-     * @param {(sessionNonce: string) => void} callback - The callback to invoke when the initial response is received.
-     * @returns {number} The ID of the callback listener.
-     */
-    listenForInitialResponse(sessionNonce, callback) {
-        const callbackID = this.callbackIdCounter++;
-        this.onInitialResponseReceivedCallbacks.set(callbackID, {
-            callback,
-            sessionNonce
-        });
-        return callbackID;
-    }
-    /**
-     * Removes a listener for initial responses.
-     *
-     * @private
-     * @param {number} callbackID - The ID of the callback to remove.
-     */
-    stopListeningForInitialResponses(callbackID) {
-        this.onInitialResponseReceivedCallbacks.delete(callbackID);
-    }
-    propagateTransportError(peerIdentityKey, error) {
-        if (error instanceof Error) {
-            if (peerIdentityKey != null) {
-                const existingDetails = error.details;
-                if (existingDetails != null && typeof existingDetails === 'object') {
-                    if (existingDetails.peerIdentityKey == null) {
-                        existingDetails.peerIdentityKey = peerIdentityKey;
-                    }
-                }
-                else {
-                    error.details = { peerIdentityKey };
-                }
-            }
-            throw error;
-        }
-        const message = `Failed to send message to peer ${peerIdentityKey ?? 'unknown'}: ${String(error)}`;
-        throw new Error(message);
-    }
-    /**
-     * Handles incoming messages from the transport.
-     *
-     * @param {AuthMessage} message - The incoming message to process.
-     * @returns {Promise<void>}
-     */
-    async handleIncomingMessage(message) {
-        if (typeof message.version !== 'string' || message.version !== AUTH_VERSION) {
-            throw new Error(`Invalid or unsupported message auth version! Received: ${message.version}, expected: ${AUTH_VERSION}`);
-        }
-        switch (message.messageType) {
-            case 'initialRequest':
-                await this.processInitialRequest(message);
-                break;
-            case 'initialResponse':
-                await this.processInitialResponse(message);
-                break;
-            case 'certificateRequest':
-                await this.processCertificateRequest(message);
-                break;
-            case 'certificateResponse':
-                await this.processCertificateResponse(message);
-                break;
-            case 'general':
-                await this.processGeneralMessage(message);
-                break;
-            default:
-                throw new Error(`Unknown message type of ${String(message.messageType)} from ${String(message.identityKey)}`);
-        }
-    }
-    /**
-     * Processes an initial request message from a peer.
-     *
-     * @param {AuthMessage} message - The incoming initial request message.
-     */
-    async processInitialRequest(message) {
-        if (typeof message.identityKey !== 'string' ||
-            typeof message.initialNonce !== 'string' ||
-            message.initialNonce === '') {
-            throw new Error('Missing required fields in initialRequest message.');
-        }
-        // Create a new sessionNonce for our side
-        const sessionNonce = await createNonce(this.wallet, undefined, this.originator);
-        const now = Date.now();
-        // We'll treat this as fully authenticated from *our* perspective (the responding side).
-        this.sessionManager.addSession({
-            isAuthenticated: true,
-            sessionNonce,
-            peerNonce: message.initialNonce,
-            peerIdentityKey: message.identityKey,
-            lastUpdate: now
-        });
-        // Possibly handle the peer's requested certs
-        let certificatesToInclude;
-        if ((message.requestedCertificates != null) &&
-            Array.isArray(message.requestedCertificates.certifiers) &&
-            message.requestedCertificates.certifiers.length > 0) {
-            if (this.onCertificateRequestReceivedCallbacks.size > 0) {
-                // Let the application handle it
-                this.onCertificateRequestReceivedCallbacks.forEach(cb => {
-                    cb(message.identityKey, message.requestedCertificates);
-                });
-            }
-            else {
-                // Attempt to find automatically
-                certificatesToInclude = await getVerifiableCertificates(this.wallet, message.requestedCertificates, message.identityKey, this.originator);
-            }
-        }
-        // Create signature
-        const { signature } = await this.wallet.createSignature({
-            data: Peer.base64ToBytes(message.initialNonce + sessionNonce),
-            protocolID: [2, 'auth message signature'],
-            keyID: `${message.initialNonce} ${sessionNonce}`,
-            counterparty: message.identityKey
-        }, this.originator);
-        const initialResponseMessage = {
-            version: AUTH_VERSION,
-            messageType: 'initialResponse',
-            identityKey: await this.getIdentityPublicKey(),
-            initialNonce: sessionNonce,
-            yourNonce: message.initialNonce,
-            certificates: certificatesToInclude,
-            requestedCertificates: this.certificatesToRequest,
-            signature
-        };
-        // If we haven't interacted with a peer yet, store this identity as "lastInteracted"
-        if (this.lastInteractedWithPeer === undefined) {
-            this.lastInteractedWithPeer = message.identityKey;
-        }
-        // Send the response
-        await this.transport.send(initialResponseMessage);
-    }
-    /**
-     * Processes an initial response message from a peer.
-     *
-     * @private
-     * @param {AuthMessage} message - The incoming initial response message.
-     * @throws Will throw an error if nonce or signature verification fails.
-     */
-    async processInitialResponse(message) {
-        const validNonce = await verifyNonce(message.yourNonce, this.wallet, undefined, this.originator);
-        if (!validNonce) {
-            throw new Error(`Initial response nonce verification failed from peer: ${message.identityKey}`);
-        }
-        // This is the session we previously created by calling initiateHandshake
-        const peerSession = this.sessionManager.getSession(message.yourNonce);
-        if (peerSession == null) {
-            throw new Error(`Peer session not found for peer: ${message.identityKey}`);
-        }
-        // Validate message signature
-        const dataToVerify = Peer.base64ToBytes((peerSession.sessionNonce ?? '') + (message.initialNonce ?? ''));
-        const { valid } = await this.wallet.verifySignature({
-            data: dataToVerify,
-            signature: message.signature,
-            protocolID: [2, 'auth message signature'],
-            keyID: `${peerSession.sessionNonce ?? ''} ${message.initialNonce ?? ''}`,
-            counterparty: message.identityKey
-        }, this.originator);
-        if (!valid) {
-            throw new Error(`Unable to verify initial response signature for peer: ${message.identityKey}`);
-        }
-        // Now mark the session as authenticated
-        peerSession.peerNonce = message.initialNonce;
-        peerSession.peerIdentityKey = message.identityKey;
-        peerSession.isAuthenticated = true;
-        peerSession.lastUpdate = Date.now();
-        this.sessionManager.updateSession(peerSession);
-        // If the handshake had requested certificates, validate them
-        if (this.certificatesToRequest?.certifiers?.length > 0 &&
-            message.certificates?.length > 0) {
-            await validateCertificates(this.wallet, message, this.certificatesToRequest, this.originator);
-            // Notify listeners
-            this.onCertificatesReceivedCallbacks.forEach(cb => cb(message.identityKey, message.certificates));
-        }
-        // Update lastInteractedWithPeer
-        this.lastInteractedWithPeer = message.identityKey;
-        // Let the handshake wait-latch know we got our response
-        this.onInitialResponseReceivedCallbacks.forEach(entry => {
-            if (entry.sessionNonce === peerSession.sessionNonce) {
-                entry.callback(peerSession.sessionNonce);
-            }
-        });
-        // The peer might also request certificates from us
-        if ((message.requestedCertificates != null) &&
-            Array.isArray(message.requestedCertificates.certifiers) &&
-            message.requestedCertificates.certifiers.length > 0) {
-            if (this.onCertificateRequestReceivedCallbacks.size > 0) {
-                // Let the application handle it
-                this.onCertificateRequestReceivedCallbacks.forEach(cb => {
-                    cb(message.identityKey, message.requestedCertificates);
-                });
-            }
-            else {
-                // Attempt auto
-                const verifiableCertificates = await getVerifiableCertificates(this.wallet, message.requestedCertificates, message.identityKey, this.originator);
-                await this.sendCertificateResponse(message.identityKey, verifiableCertificates);
-            }
-        }
-    }
-    /**
-     * Processes an incoming certificate request message from a peer.
-     * Verifies nonce/signature and then possibly sends a certificateResponse.
-     *
-     * @param {AuthMessage} message - The certificate request message received from the peer.
-     * @throws {Error} if nonce or signature is invalid.
-     */
-    async processCertificateRequest(message) {
-        const validNonce = await verifyNonce(message.yourNonce, this.wallet, undefined, this.originator);
-        if (!validNonce) {
-            throw new Error(`Unable to verify nonce for certificate request message from: ${message.identityKey}`);
-        }
-        const peerSession = this.sessionManager.getSession(message.yourNonce);
-        if (peerSession == null) {
-            throw new Error(`Session not found for nonce: ${message.yourNonce}`);
-        }
-        const { valid } = await this.wallet.verifySignature({
-            data: Peer.utf8ToBytes(JSON.stringify(message.requestedCertificates)),
-            signature: message.signature,
-            protocolID: [2, 'auth message signature'],
-            keyID: `${message.nonce ?? ''} ${peerSession.sessionNonce ?? ''}`,
-            counterparty: peerSession.peerIdentityKey
-        }, this.originator);
-        if (!valid) {
-            throw new Error(`Invalid signature in certificate request message from ${peerSession.peerIdentityKey}`);
-        }
-        // Update usage
-        peerSession.lastUpdate = Date.now();
-        this.sessionManager.updateSession(peerSession);
-        if ((message.requestedCertificates != null) &&
-            Array.isArray(message.requestedCertificates.certifiers) &&
-            message.requestedCertificates.certifiers.length > 0) {
-            if (this.onCertificateRequestReceivedCallbacks.size > 0) {
-                // Let the application handle it
-                this.onCertificateRequestReceivedCallbacks.forEach(cb => {
-                    cb(message.identityKey, message.requestedCertificates);
-                });
-            }
-            else {
-                // Attempt auto
-                const verifiableCertificates = await getVerifiableCertificates(this.wallet, message.requestedCertificates, message.identityKey, this.originator);
-                await this.sendCertificateResponse(message.identityKey, verifiableCertificates);
-            }
-        }
-    }
-    /**
-     * Sends a certificate response message containing the specified certificates to a peer.
-     *
-     * @param {string} verifierIdentityKey - The identity key of the peer requesting the certificates.
-     * @param {VerifiableCertificate[]} certificates - The list of certificates to include in the response.
-     * @throws Will throw an error if the transport fails to send the message.
-     */
-    async sendCertificateResponse(verifierIdentityKey, certificates) {
-        const peerSession = await this.getAuthenticatedSession(verifierIdentityKey);
-        const requestNonce = Utils.toBase64(Random(32));
-        const { signature } = await this.wallet.createSignature({
-            data: Peer.utf8ToBytes(JSON.stringify(certificates)),
-            protocolID: [2, 'auth message signature'],
-            keyID: `${requestNonce} ${peerSession.peerNonce ?? ''}`,
-            counterparty: peerSession.peerIdentityKey
-        }, this.originator);
-        const certificateResponse = {
-            version: AUTH_VERSION,
-            messageType: 'certificateResponse',
-            identityKey: await this.getIdentityPublicKey(),
-            nonce: requestNonce,
-            initialNonce: peerSession.sessionNonce,
-            yourNonce: peerSession.peerNonce,
-            certificates,
-            signature
-        };
-        // Update usage
-        peerSession.lastUpdate = Date.now();
-        this.sessionManager.updateSession(peerSession);
-        try {
-            await this.transport.send(certificateResponse);
-        }
-        catch (error) {
-            this.propagateTransportError(peerSession.peerIdentityKey, error);
-        }
-    }
-    /**
-     * Processes a certificate response message from a peer.
-     *
-     * @private
-     * @param {AuthMessage} message - The incoming certificate response message.
-     * @throws Will throw an error if nonce verification or signature verification fails.
-     */
-    async processCertificateResponse(message) {
-        const validNonce = await verifyNonce(message.yourNonce, this.wallet, undefined, this.originator);
-        if (!validNonce) {
-            throw new Error(`Unable to verify nonce for certificate response from: ${message.identityKey}`);
-        }
-        const peerSession = this.sessionManager.getSession(message.yourNonce);
-        if (peerSession == null) {
-            throw new Error(`Session not found for nonce: ${message.yourNonce}`);
-        }
-        // Validate message signature
-        const { valid } = await this.wallet.verifySignature({
-            data: Peer.utf8ToBytes(JSON.stringify(message.certificates)),
-            signature: message.signature,
-            protocolID: [2, 'auth message signature'],
-            keyID: `${message.nonce ?? ''} ${peerSession.sessionNonce ?? ''}`,
-            counterparty: message.identityKey
-        }, this.originator);
-        if (!valid) {
-            throw new Error(`Unable to verify certificate response signature for peer: ${message.identityKey}`);
-        }
-        // We also handle optional validation if there's a requestedCertificates field
-        await validateCertificates(this.wallet, message, message.requestedCertificates, this.originator);
-        // Notify any listeners
-        this.onCertificatesReceivedCallbacks.forEach(cb => {
-            cb(message.identityKey, message.certificates ?? []);
-        });
-        peerSession.lastUpdate = Date.now();
-        this.sessionManager.updateSession(peerSession);
-    }
-    /**
-     * Processes a general message from a peer.
-     *
-     * @private
-     * @param {AuthMessage} message - The incoming general message.
-     * @throws Will throw an error if nonce or signature verification fails.
-     */
-    async processGeneralMessage(message) {
-        const validNonce = await verifyNonce(message.yourNonce, this.wallet, undefined, this.originator);
-        if (!validNonce) {
-            throw new Error(`Unable to verify nonce for general message from: ${message.identityKey}`);
-        }
-        const peerSession = this.sessionManager.getSession(message.yourNonce);
-        if (peerSession == null) {
-            throw new Error(`Session not found for nonce: ${message.yourNonce}`);
-        }
-        const { valid } = await this.wallet.verifySignature({
-            data: message.payload,
-            signature: message.signature,
-            protocolID: [2, 'auth message signature'],
-            keyID: `${message.nonce ?? ''} ${peerSession.sessionNonce ?? ''}`,
-            counterparty: peerSession.peerIdentityKey
-        }, this.originator);
-        if (!valid) {
-            throw new Error(`Invalid signature in generalMessage from ${peerSession.peerIdentityKey}`);
-        }
-        // Mark last usage
-        peerSession.lastUpdate = Date.now();
-        this.sessionManager.updateSession(peerSession);
-        // Update lastInteractedWithPeer
-        this.lastInteractedWithPeer = message.identityKey;
-        // Dispatch callbacks
-        this.onGeneralMessageReceivedCallbacks.forEach(cb => {
-            cb(message.identityKey, message.payload ?? []);
-        });
-    }
-    async getIdentityPublicKey() {
-        if (this.identityPublicKey != null) {
-            return this.identityPublicKey;
-        }
-        const { publicKey } = await this.wallet.getPublicKey({ identityKey: true }, this.originator);
-        this.identityPublicKey = publicKey;
-        return publicKey;
-    }
-    static utf8ToBytes(data) {
-        if (BufferCtor != null) {
-            return Array.from(BufferCtor.from(data, 'utf8'));
-        }
-        if (typeof TextEncoder !== 'undefined') {
-            return Array.from(new TextEncoder().encode(data));
-        }
-        return Utils.toArray(data, 'utf8');
-    }
-    static base64ToBytes(data) {
-        if (BufferCtor != null) {
-            return Array.from(BufferCtor.from(data, 'base64'));
-        }
-        return Utils.toArray(data, 'base64');
-    }
-}
-//# sourceMappingURL=Peer.js.map