@aztec/wallet-sdk 0.0.1-commit.f295ac2 → 0.0.1-commit.fc805bf

package/dest/extension/handlers/background_connection_handler.js

@@ -0,0 +1,258 @@
+import { decrypt, deriveSessionKeys, encrypt, exportPublicKey, generateKeyPair, importPublicKey } from '../../crypto.js';
+import { WalletMessageType } from '../../types.js';
+import { InternalMessageType, MessageOrigin } from './internal_message_types.js';
+/**
+ * Handles wallet session flow in the extension background script.
+ *
+ * This class manages:
+ * - Pending discovery requests (before user approval)
+ * - Active sessions (after key exchange)
+ * - Per-session ECDH key exchange
+ * - Message encryption/decryption
+ *
+ * @example
+ * ```typescript
+ * const handler = new BackgroundConnectionHandler(
+ *   {
+ *     walletId: 'my-wallet',
+ *     walletName: 'My Wallet',
+ *     walletVersion: '1.0.0',
+ *   },
+ *   {
+ *     sendToTab: (tabId, message) => browser.tabs.sendMessage(tabId, message),
+ *     addContentListener: (handler) => browser.runtime.onMessage.addListener(handler),
+ *   },
+ *   {
+ *     onPendingDiscovery: (discovery) => updateBadge(),
+ *     onSessionEstablished: (session) => console.log('Connected:', session.sessionId),
+ *     onWalletMessage: (session, message) => nativePort.postMessage(message),
+ *   }
+ * );
+ *
+ * handler.initialize();
+ * ```
+ */ export class BackgroundConnectionHandler {
+    config;
+    transport;
+    callbacks;
+    pendingDiscoveries;
+    activeSessions;
+    constructor(config, transport, callbacks = {}){
+        this.config = config;
+        this.transport = transport;
+        this.callbacks = callbacks;
+        this.pendingDiscoveries = new Map();
+        this.activeSessions = new Map();
+        this.handleMessage = (message, sender)=>{
+            const msg = message;
+            if (msg.origin !== MessageOrigin.CONTENT_SCRIPT) {
+                return;
+            }
+            const tabId = sender.tab?.id;
+            const tabOrigin = sender.tab?.url ? new URL(sender.tab.url).origin : 'unknown';
+            if (!tabId) {
+                return;
+            }
+            const { type, sessionId, content } = msg;
+            switch(type){
+                case InternalMessageType.DISCOVERY_REQUEST:
+                    this.handleDiscoveryRequest(content, tabId, tabOrigin);
+                    break;
+                case InternalMessageType.KEY_EXCHANGE_REQUEST:
+                    if (sessionId) {
+                        this.handleKeyExchangeRequest(sessionId, content).catch(()=>{
+                        // Key exchange failed - session won't be established
+                        });
+                    }
+                    break;
+                case InternalMessageType.DISCONNECT_REQUEST:
+                    if (sessionId) {
+                        this.terminateSession(sessionId);
+                    }
+                    break;
+                case InternalMessageType.SECURE_MESSAGE:
+                    if (sessionId) {
+                        void this.handleEncryptedMessage(sessionId, content);
+                    }
+                    break;
+            }
+        };
+    }
+    initialize() {
+        this.transport.addContentListener(this.handleMessage);
+    }
+    handleMessage;
+    getWalletInfo() {
+        return {
+            id: this.config.walletId,
+            name: this.config.walletName,
+            version: this.config.walletVersion,
+            icon: this.config.walletIcon
+        };
+    }
+    handleDiscoveryRequest(request, tabId, origin) {
+        const discovery = {
+            requestId: request.requestId,
+            appId: request.appId,
+            origin,
+            chainInfo: request.chainInfo,
+            tabId,
+            timestamp: Date.now(),
+            status: 'pending'
+        };
+        this.pendingDiscoveries.set(request.requestId, discovery);
+        this.callbacks.onPendingDiscovery?.(discovery);
+    }
+    approveDiscovery(requestId) {
+        const discovery = this.pendingDiscoveries.get(requestId);
+        if (!discovery || discovery.status !== 'pending') {
+            return false;
+        }
+        // The discovery requestId becomes our sessionId
+        // This is what will be used internally to correlate
+        // content<->background messages
+        const sessionId = requestId;
+        discovery.status = 'approved';
+        this.transport.sendToTab(discovery.tabId, {
+            origin: MessageOrigin.BACKGROUND,
+            type: InternalMessageType.DISCOVERY_APPROVED,
+            sessionId,
+            content: this.getWalletInfo()
+        });
+        return true;
+    }
+    rejectDiscovery(requestId) {
+        const discovery = this.pendingDiscoveries.get(requestId);
+        if (!discovery || discovery.status !== 'pending') {
+            return false;
+        }
+        discovery.status = 'rejected';
+        this.pendingDiscoveries.delete(requestId);
+        return true;
+    }
+    async handleKeyExchangeRequest(sessionId, request) {
+        const discovery = this.pendingDiscoveries.get(sessionId);
+        if (!discovery || discovery.status !== 'approved') {
+            return;
+        }
+        try {
+            const keyPair = await generateKeyPair();
+            const publicKey = await exportPublicKey(keyPair.publicKey);
+            const appPublicKey = await importPublicKey(request.publicKey);
+            const sessionKeys = await deriveSessionKeys(keyPair, appPublicKey, false);
+            const session = {
+                sessionId,
+                sharedKey: sessionKeys.encryptionKey,
+                verificationHash: sessionKeys.verificationHash,
+                tabId: discovery.tabId,
+                origin: discovery.origin,
+                appId: discovery.appId,
+                connectedAt: Date.now(),
+                chainInfo: discovery.chainInfo
+            };
+            this.activeSessions.set(sessionId, session);
+            this.pendingDiscoveries.delete(sessionId);
+            const response = {
+                type: WalletMessageType.KEY_EXCHANGE_RESPONSE,
+                requestId: sessionId,
+                publicKey
+            };
+            this.transport.sendToTab(discovery.tabId, {
+                origin: MessageOrigin.BACKGROUND,
+                type: InternalMessageType.KEY_EXCHANGE_RESPONSE,
+                sessionId,
+                content: response
+            });
+            this.callbacks.onSessionEstablished?.(session);
+        } catch  {
+        // Key exchange failed silently - session won't be established
+        }
+    }
+    async handleEncryptedMessage(sessionId, encrypted) {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        try {
+            const message = await decrypt(session.sharedKey, encrypted);
+            this.callbacks.onWalletMessage?.(session, message);
+        } catch  {
+        // Decryption failed - ignore malformed message
+        }
+    }
+    async sendResponse(sessionId, response) {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        try {
+            const encrypted = await encrypt(session.sharedKey, JSON.stringify(response));
+            this.transport.sendToTab(session.tabId, {
+                origin: MessageOrigin.BACKGROUND,
+                type: InternalMessageType.SECURE_RESPONSE,
+                sessionId,
+                content: encrypted
+            });
+        } catch  {
+        // Encryption failed - response won't be sent
+        }
+    }
+    terminateSession(sessionId) {
+        const session = this.activeSessions.get(sessionId);
+        if (session) {
+            // Notify the content script (and ultimately the dApp) that the session is disconnected
+            this.transport.sendToTab(session.tabId, {
+                origin: MessageOrigin.BACKGROUND,
+                type: InternalMessageType.SESSION_DISCONNECTED,
+                sessionId
+            });
+            this.activeSessions.delete(sessionId);
+            this.callbacks.onSessionTerminated?.(sessionId);
+            // Restore discovery to approved state so user can retry key exchange
+            const discovery = {
+                requestId: sessionId,
+                appId: session.appId,
+                origin: session.origin,
+                chainInfo: session.chainInfo,
+                tabId: session.tabId,
+                timestamp: Date.now(),
+                status: 'approved'
+            };
+            this.pendingDiscoveries.set(sessionId, discovery);
+        }
+    }
+    terminateForTab(tabId) {
+        for (const [sessionId, session] of this.activeSessions){
+            if (session.tabId === tabId) {
+                this.terminateSession(sessionId);
+            }
+        }
+        for (const [requestId, discovery] of this.pendingDiscoveries){
+            if (discovery.tabId === tabId) {
+                this.pendingDiscoveries.delete(requestId);
+            }
+        }
+    }
+    clearAll() {
+        for (const sessionId of this.activeSessions.keys()){
+            this.callbacks.onSessionTerminated?.(sessionId);
+        }
+        this.activeSessions.clear();
+        this.pendingDiscoveries.clear();
+    }
+    getPendingDiscoveries() {
+        return Array.from(this.pendingDiscoveries.values()).filter((d)=>d.status === 'pending');
+    }
+    getPendingDiscoveryCount() {
+        return this.getPendingDiscoveries().length;
+    }
+    getActiveSessions() {
+        return Array.from(this.activeSessions.values());
+    }
+    getSession(sessionId) {
+        return this.activeSessions.get(sessionId);
+    }
+    getPendingDiscovery(requestId) {
+        return this.pendingDiscoveries.get(requestId);
+    }
+}

package/dest/extension/handlers/content_script_connection_handler.d.ts

@@ -0,0 +1,56 @@
+import { type BackgroundMessage, type ContentScriptMessage } from './internal_message_types.js';
+/**
+ * Transport interface for content script communication.
+ */
+export interface ContentScriptTransport {
+    /**
+     * Send a message to the background script.
+     * Typically `browser.runtime.sendMessage`.
+     */
+    sendToBackground: (message: ContentScriptMessage) => void;
+    /**
+     * Register a listener for messages from the background script.
+     * Typically `browser.runtime.onMessage.addListener`.
+     */
+    addBackgroundListener: (handler: (message: BackgroundMessage) => void) => void;
+}
+/**
+ * Handles wallet connection flow in the extension content script.
+ *
+ * This class manages:
+ * - Listening for discovery requests from the page
+ * - Creating MessageChannels after discovery approval
+ * - Relaying key exchange messages between page and background
+ * - Relaying encrypted messages between page and background
+ *
+ * The content script acts as a pure relay - it never has access to
+ * private keys or shared secrets.
+ *
+ * @example
+ * ```typescript
+ * const handler = new ContentScriptConnectionHandler({
+ *   sendToBackground: (message) => browser.runtime.sendMessage(message),
+ *   addBackgroundListener: (handler) => browser.runtime.onMessage.addListener(handler),
+ * });
+ *
+ * handler.start();
+ * ```
+ */
+export declare class ContentScriptConnectionHandler {
+    private transport;
+    private ports;
+    private listening;
+    private pageMessageHandler;
+    constructor(transport: ContentScriptTransport);
+    start(): void;
+    private handleBackgroundMessage;
+    private handleDiscoveryRequest;
+    private handleDiscoveryApproved;
+    private handleKeyExchangeResponse;
+    private handleSecureResponse;
+    private handleSessionDisconnected;
+    closeConnection(sessionId: string): void;
+    closeAllConnections(): void;
+    getConnectionCount(): number;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29udGVudF9zY3JpcHRfY29ubmVjdGlvbl9oYW5kbGVyLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZXh0ZW5zaW9uL2hhbmRsZXJzL2NvbnRlbnRfc2NyaXB0X2Nvbm5lY3Rpb25faGFuZGxlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQ0wsS0FBSyxpQkFBaUIsRUFDdEIsS0FBSyxvQkFBb0IsRUFHMUIsTUFBTSw2QkFBNkIsQ0FBQztBQW9DckM7O0dBRUc7QUFDSCxNQUFNLFdBQVcsc0JBQXNCO0lBQ3JDOzs7T0FHRztJQUNILGdCQUFnQixFQUFFLENBQUMsT0FBTyxFQUFFLG9CQUFvQixLQUFLLElBQUksQ0FBQztJQUUxRDs7O09BR0c7SUFDSCxxQkFBcUIsRUFBRSxDQUFDLE9BQU8sRUFBRSxDQUFDLE9BQU8sRUFBRSxpQkFBaUIsS0FBSyxJQUFJLEtBQUssSUFBSSxDQUFDO0NBQ2hGO0FBRUQ7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQXFCRztBQUNILHFCQUFhLDhCQUE4QjtJQUs3QixPQUFPLENBQUMsU0FBUztJQUo3QixPQUFPLENBQUMsS0FBSyxDQUFxQztJQUNsRCxPQUFPLENBQUMsU0FBUyxDQUFTO0lBQzFCLE9BQU8sQ0FBQyxrQkFBa0IsQ0FBZ0Q7SUFFMUUsWUFBb0IsU0FBUyxFQUFFLHNCQUFzQixFQUFJO0lBRXpELEtBQUssSUFBSSxJQUFJLENBOEJaO0lBRUQsT0FBTyxDQUFDLHVCQUF1QixDQXFCN0I7SUFFRixPQUFPLENBQUMsc0JBQXNCO0lBUTlCLE9BQU8sQ0FBQyx1QkFBdUI7SUFpRC9CLE9BQU8sQ0FBQyx5QkFBeUI7SUFRakMsT0FBTyxDQUFDLG9CQUFvQjtJQVE1QixPQUFPLENBQUMseUJBQXlCO0lBVWpDLGVBQWUsQ0FBQyxTQUFTLEVBQUUsTUFBTSxHQUFHLElBQUksQ0FNdkM7SUFFRCxtQkFBbUIsSUFBSSxJQUFJLENBSzFCO0lBRUQsa0JBQWtCLElBQUksTUFBTSxDQUUzQjtDQUNGIn0=

package/dest/extension/handlers/content_script_connection_handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content_script_connection_handler.d.ts","sourceRoot":"","sources":["../../../src/extension/handlers/content_script_connection_handler.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EAG1B,MAAM,6BAA6B,CAAC;AAoCrC;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,gBAAgB,EAAE,CAAC,OAAO,EAAE,oBAAoB,KAAK,IAAI,CAAC;IAE1D;;;OAGG;IACH,qBAAqB,EAAE,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,IAAI,KAAK,IAAI,CAAC;CAChF;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,8BAA8B;IAK7B,OAAO,CAAC,SAAS;IAJ7B,OAAO,CAAC,KAAK,CAAqC;IAClD,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,kBAAkB,CAAgD;IAE1E,YAAoB,SAAS,EAAE,sBAAsB,EAAI;IAEzD,KAAK,IAAI,IAAI,CA8BZ;IAED,OAAO,CAAC,uBAAuB,CAqB7B;IAEF,OAAO,CAAC,sBAAsB;IAQ9B,OAAO,CAAC,uBAAuB;IAiD/B,OAAO,CAAC,yBAAyB;IAQjC,OAAO,CAAC,oBAAoB;IAQ5B,OAAO,CAAC,yBAAyB;IAUjC,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAMvC;IAED,mBAAmB,IAAI,IAAI,CAK1B;IAED,kBAAkB,IAAI,MAAM,CAE3B;CACF"}

package/dest/extension/handlers/content_script_connection_handler.js

@@ -0,0 +1,174 @@
+import { WalletMessageType } from '../../types.js';
+import { InternalMessageType, MessageOrigin } from './internal_message_types.js';
+/**
+ * Handles wallet connection flow in the extension content script.
+ *
+ * This class manages:
+ * - Listening for discovery requests from the page
+ * - Creating MessageChannels after discovery approval
+ * - Relaying key exchange messages between page and background
+ * - Relaying encrypted messages between page and background
+ *
+ * The content script acts as a pure relay - it never has access to
+ * private keys or shared secrets.
+ *
+ * @example
+ * ```typescript
+ * const handler = new ContentScriptConnectionHandler({
+ *   sendToBackground: (message) => browser.runtime.sendMessage(message),
+ *   addBackgroundListener: (handler) => browser.runtime.onMessage.addListener(handler),
+ * });
+ *
+ * handler.start();
+ * ```
+ */ export class ContentScriptConnectionHandler {
+    transport;
+    ports;
+    listening;
+    pageMessageHandler;
+    constructor(transport){
+        this.transport = transport;
+        this.ports = new Map();
+        this.listening = false;
+        this.pageMessageHandler = null;
+        this.handleBackgroundMessage = (message)=>{
+            if (message.origin !== MessageOrigin.BACKGROUND) {
+                return;
+            }
+            const { type, sessionId, content } = message;
+            switch(type){
+                case InternalMessageType.DISCOVERY_APPROVED:
+                    this.handleDiscoveryApproved(sessionId, content);
+                    break;
+                case InternalMessageType.KEY_EXCHANGE_RESPONSE:
+                    this.handleKeyExchangeResponse(sessionId, content);
+                    break;
+                case InternalMessageType.SECURE_RESPONSE:
+                    this.handleSecureResponse(sessionId, content);
+                    break;
+                case InternalMessageType.SESSION_DISCONNECTED:
+                    this.handleSessionDisconnected(sessionId);
+                    break;
+            }
+        };
+    }
+    start() {
+        if (this.listening) {
+            return;
+        }
+        this.transport.addBackgroundListener(this.handleBackgroundMessage);
+        this.pageMessageHandler = (event)=>{
+            if (event.source !== window) {
+                return;
+            }
+            let data;
+            try {
+                data = JSON.parse(event.data);
+            } catch  {
+                return;
+            }
+            if (!data?.type) {
+                return;
+            }
+            if (data.type === WalletMessageType.DISCOVERY) {
+                this.handleDiscoveryRequest(data);
+            }
+        };
+        window.addEventListener('message', this.pageMessageHandler);
+        this.listening = true;
+    }
+    handleBackgroundMessage;
+    handleDiscoveryRequest(request) {
+        this.transport.sendToBackground({
+            origin: MessageOrigin.CONTENT_SCRIPT,
+            type: InternalMessageType.DISCOVERY_REQUEST,
+            content: request
+        });
+    }
+    handleDiscoveryApproved(sessionId, walletInfo) {
+        const channel = new MessageChannel();
+        this.ports.set(sessionId, {
+            port: channel.port1,
+            sessionId
+        });
+        channel.port1.onmessage = (event)=>{
+            const data = event.data;
+            switch(data?.type){
+                case WalletMessageType.KEY_EXCHANGE_REQUEST:
+                    this.transport.sendToBackground({
+                        origin: MessageOrigin.CONTENT_SCRIPT,
+                        type: InternalMessageType.KEY_EXCHANGE_REQUEST,
+                        sessionId,
+                        content: data
+                    });
+                    break;
+                case WalletMessageType.DISCONNECT:
+                    this.transport.sendToBackground({
+                        origin: MessageOrigin.CONTENT_SCRIPT,
+                        type: InternalMessageType.DISCONNECT_REQUEST,
+                        sessionId,
+                        content: data
+                    });
+                    break;
+                default:
+                    this.transport.sendToBackground({
+                        origin: MessageOrigin.CONTENT_SCRIPT,
+                        type: InternalMessageType.SECURE_MESSAGE,
+                        sessionId,
+                        content: data
+                    });
+                    break;
+            }
+        };
+        channel.port1.start();
+        const response = {
+            type: WalletMessageType.DISCOVERY_RESPONSE,
+            requestId: sessionId,
+            walletInfo
+        };
+        window.postMessage(JSON.stringify(response), '*', [
+            channel.port2
+        ]);
+    }
+    handleKeyExchangeResponse(sessionId, response) {
+        const connection = this.ports.get(sessionId);
+        if (!connection) {
+            return;
+        }
+        connection.port.postMessage(response);
+    }
+    handleSecureResponse(sessionId, content) {
+        const connection = this.ports.get(sessionId);
+        if (!connection) {
+            return;
+        }
+        connection.port.postMessage(content);
+    }
+    handleSessionDisconnected(sessionId) {
+        const connection = this.ports.get(sessionId);
+        if (!connection) {
+            return;
+        }
+        connection.port.postMessage({
+            type: WalletMessageType.DISCONNECT
+        });
+        connection.port.close();
+        this.ports.delete(sessionId);
+    }
+    closeConnection(sessionId) {
+        const connection = this.ports.get(sessionId);
+        if (connection) {
+            connection.port.close();
+            this.ports.delete(sessionId);
+        }
+    }
+    closeAllConnections() {
+        for (const [sessionId, connection] of this.ports){
+            connection.port.close();
+            this.ports.delete(sessionId);
+        }
+    }
+    getConnectionCount() {
+        return this.ports.size;
+    }
+}

package/dest/extension/handlers/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Browser-safe exports for extension background and content scripts.
+ *
+ * This module contains ONLY handlers that work in service worker/content script
+ * environments without Node.js polyfills.
+ *
+ * @packageDocumentation
+ */
+export { BackgroundConnectionHandler, type PendingDiscovery, type ActiveSession, type DiscoveryStatus, type BackgroundConnectionCallbacks, type BackgroundConnectionConfig, type BackgroundTransport, } from './background_connection_handler.js';
+export { ContentScriptConnectionHandler, type ContentScriptTransport } from './content_script_connection_handler.js';
+export { type ContentScriptMessage, type BackgroundMessage, type MessageSender, type MessageOriginType, MessageOrigin, } from './internal_message_types.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9leHRlbnNpb24vaGFuZGxlcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7R0FPRztBQUNILE9BQU8sRUFDTCwyQkFBMkIsRUFDM0IsS0FBSyxnQkFBZ0IsRUFDckIsS0FBSyxhQUFhLEVBQ2xCLEtBQUssZUFBZSxFQUNwQixLQUFLLDZCQUE2QixFQUNsQyxLQUFLLDBCQUEwQixFQUMvQixLQUFLLG1CQUFtQixHQUN6QixNQUFNLG9DQUFvQyxDQUFDO0FBQzVDLE9BQU8sRUFBRSw4QkFBOEIsRUFBRSxLQUFLLHNCQUFzQixFQUFFLE1BQU0sd0NBQXdDLENBQUM7QUFDckgsT0FBTyxFQUNMLEtBQUssb0JBQW9CLEVBQ3pCLEtBQUssaUJBQWlCLEVBQ3RCLEtBQUssYUFBYSxFQUNsQixLQUFLLGlCQUFpQixFQUN0QixhQUFhLEdBQ2QsTUFBTSw2QkFBNkIsQ0FBQyJ9

package/dest/extension/handlers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extension/handlers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EACL,2BAA2B,EAC3B,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,6BAA6B,EAClC,KAAK,0BAA0B,EAC/B,KAAK,mBAAmB,GACzB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,8BAA8B,EAAE,KAAK,sBAAsB,EAAE,MAAM,wCAAwC,CAAC;AACrH,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,aAAa,GACd,MAAM,6BAA6B,CAAC"}

package/dest/extension/handlers/index.js

@@ -0,0 +1,10 @@
+/**
+ * Browser-safe exports for extension background and content scripts.
+ *
+ * This module contains ONLY handlers that work in service worker/content script
+ * environments without Node.js polyfills.
+ *
+ * @packageDocumentation
+ */ export { BackgroundConnectionHandler } from './background_connection_handler.js';
+export { ContentScriptConnectionHandler } from './content_script_connection_handler.js';
+export { MessageOrigin } from './internal_message_types.js';

package/dest/extension/handlers/internal_message_types.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Internal message types for content script ↔ background communication.
+ * These are NOT part of the public wallet protocol - they are implementation
+ * details for coordinating between extension components.
+ */
+export declare const InternalMessageType: {
+    readonly DISCOVERY_REQUEST: "discovery-request";
+    readonly KEY_EXCHANGE_REQUEST: "key-exchange-request";
+    readonly SECURE_MESSAGE: "secure-message";
+    readonly DISCONNECT_REQUEST: "disconnect-request";
+    readonly DISCOVERY_APPROVED: "discovery-approved";
+    readonly KEY_EXCHANGE_RESPONSE: "key-exchange-response";
+    readonly SECURE_RESPONSE: "secure-response";
+    readonly SESSION_DISCONNECTED: "session-disconnected";
+};
+/**
+ * Message origins for internal extension communication.
+ */
+export declare const MessageOrigin: {
+    readonly BACKGROUND: "background";
+    readonly CONTENT_SCRIPT: "content-script";
+};
+/** Union type of message origins. */
+export type MessageOriginType = (typeof MessageOrigin)[keyof typeof MessageOrigin];
+/**
+ * Message sent from content script to background.
+ */
+export interface ContentScriptMessage {
+    /** Message source identifier. */
+    origin: typeof MessageOrigin.CONTENT_SCRIPT;
+    /** Message type. */
+    type: string;
+    /** Optional session identifier. */
+    sessionId?: string;
+    /** Optional message payload. */
+    content?: unknown;
+}
+/**
+ * Message sent from background to content script.
+ */
+export interface BackgroundMessage {
+    /** Message source identifier. */
+    origin: typeof MessageOrigin.BACKGROUND;
+    /** Message type. */
+    type: string;
+    /** Session identifier. */
+    sessionId: string;
+    /** Optional message payload. */
+    content?: unknown;
+}
+/**
+ * Sender information for messages from browser runtime.
+ */
+export interface MessageSender {
+    /** Tab information if available. */
+    tab?: {
+        /** Tab identifier. */
+        id?: number;
+        /** Tab URL. */
+        url?: string;
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJuYWxfbWVzc2FnZV90eXBlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2V4dGVuc2lvbi9oYW5kbGVycy9pbnRlcm5hbF9tZXNzYWdlX3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFDSCxlQUFPLE1BQU0sbUJBQW1COzs7Ozs7Ozs7Q0FXdEIsQ0FBQztBQUVYOztHQUVHO0FBQ0gsZUFBTyxNQUFNLGFBQWE7OztDQUdoQixDQUFDO0FBRVgscUNBQXFDO0FBQ3JDLE1BQU0sTUFBTSxpQkFBaUIsR0FBRyxDQUFDLE9BQU8sYUFBYSxDQUFDLENBQUMsTUFBTSxPQUFPLGFBQWEsQ0FBQyxDQUFDO0FBRW5GOztHQUVHO0FBQ0gsTUFBTSxXQUFXLG9CQUFvQjtJQUNuQyxpQ0FBaUM7SUFDakMsTUFBTSxFQUFFLE9BQU8sYUFBYSxDQUFDLGNBQWMsQ0FBQztJQUM1QyxvQkFBb0I7SUFDcEIsSUFBSSxFQUFFLE1BQU0sQ0FBQztJQUNiLG1DQUFtQztJQUNuQyxTQUFTLENBQUMsRUFBRSxNQUFNLENBQUM7SUFDbkIsZ0NBQWdDO0lBQ2hDLE9BQU8sQ0FBQyxFQUFFLE9BQU8sQ0FBQztDQUNuQjtBQUVEOztHQUVHO0FBQ0gsTUFBTSxXQUFXLGlCQUFpQjtJQUNoQyxpQ0FBaUM7SUFDakMsTUFBTSxFQUFFLE9BQU8sYUFBYSxDQUFDLFVBQVUsQ0FBQztJQUN4QyxvQkFBb0I7SUFDcEIsSUFBSSxFQUFFLE1BQU0sQ0FBQztJQUNiLDBCQUEwQjtJQUMxQixTQUFTLEVBQUUsTUFBTSxDQUFDO0lBQ2xCLGdDQUFnQztJQUNoQyxPQUFPLENBQUMsRUFBRSxPQUFPLENBQUM7Q0FDbkI7QUFFRDs7R0FFRztBQUNILE1BQU0sV0FBVyxhQUFhO0lBQzVCLG9DQUFvQztJQUNwQyxHQUFHLENBQUMsRUFBRTtRQUNKLHNCQUFzQjtRQUN0QixFQUFFLENBQUMsRUFBRSxNQUFNLENBQUM7UUFDWixlQUFlO1FBQ2YsR0FBRyxDQUFDLEVBQUUsTUFBTSxDQUFDO0tBQ2QsQ0FBQztDQUNIIn0=

package/dest/extension/handlers/internal_message_types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal_message_types.d.ts","sourceRoot":"","sources":["../../../src/extension/handlers/internal_message_types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;CAWtB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,aAAa;;;CAGhB,CAAC;AAEX,qCAAqC;AACrC,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAEnF;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,iCAAiC;IACjC,MAAM,EAAE,OAAO,aAAa,CAAC,cAAc,CAAC;IAC5C,oBAAoB;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gCAAgC;IAChC,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,iCAAiC;IACjC,MAAM,EAAE,OAAO,aAAa,CAAC,UAAU,CAAC;IACxC,oBAAoB;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,0BAA0B;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,gCAAgC;IAChC,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,oCAAoC;IACpC,GAAG,CAAC,EAAE;QACJ,sBAAsB;QACtB,EAAE,CAAC,EAAE,MAAM,CAAC;QACZ,eAAe;QACf,GAAG,CAAC,EAAE,MAAM,CAAC;KACd,CAAC;CACH"}

package/dest/extension/handlers/internal_message_types.js

@@ -0,0 +1,22 @@
+/**
+ * Internal message types for content script ↔ background communication.
+ * These are NOT part of the public wallet protocol - they are implementation
+ * details for coordinating between extension components.
+ */ export const InternalMessageType = {
+    // Content script → Background
+    DISCOVERY_REQUEST: 'discovery-request',
+    KEY_EXCHANGE_REQUEST: 'key-exchange-request',
+    SECURE_MESSAGE: 'secure-message',
+    DISCONNECT_REQUEST: 'disconnect-request',
+    // Background → Content script
+    DISCOVERY_APPROVED: 'discovery-approved',
+    KEY_EXCHANGE_RESPONSE: 'key-exchange-response',
+    SECURE_RESPONSE: 'secure-response',
+    SESSION_DISCONNECTED: 'session-disconnected'
+};
+/**
+ * Message origins for internal extension communication.
+ */ export const MessageOrigin = {
+    BACKGROUND: 'background',
+    CONTENT_SCRIPT: 'content-script'
+};