@keyringnetwork/keyring-connect-sdk 3.1.0 → 4.1.0-alpha.1

package/dist/core/htppClient.js

@@ -0,0 +1,160 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const environment_1 = require("../utils/environment");
+const logger_1 = require("../utils/logger");
+const platformUtils_1 = require("../utils/platformUtils");
+const errors_1 = require("./errors");
+class HttpClient {
+    constructor(apiKey) {
+        this.logger = logger_1.KeyringLogger.init("HttpClient");
+        this.httpClient = axios_1.default.create({
+            baseURL: environment_1.Environment.getConfig().apiUrl,
+            timeout: environment_1.Environment.getConfig().timeout,
+            headers: {
+                "Content-Type": "application/json",
+                "X-API-KEY": apiKey,
+            },
+        });
+        this.setupAxiosInterceptors();
+        this.logger.debug({ apiUrl: environment_1.Environment.getConfig().apiUrl }, "HTTP client initialized");
+        HttpClient.instance = this;
+    }
+    setupAxiosInterceptors() {
+        this.httpClient.interceptors.request.use((config) => {
+            var _a;
+            this.logger.debug({ method: (_a = config.method) === null || _a === void 0 ? void 0 : _a.toUpperCase(), url: config.url }, "HTTP Request");
+            return config;
+        }, (error) => {
+            this.logger.error("HTTP Request failed", error);
+            return Promise.reject(errors_1.KeyringError.fromUnknown(error));
+        });
+        this.httpClient.interceptors.response.use((response) => {
+            this.logger.debug({ status: response.status, url: response.config.url }, "HTTP Response");
+            return response;
+        }, (error) => {
+            var _a, _b, _c;
+            this.logger.error({
+                status: (_a = error.response) === null || _a === void 0 ? void 0 : _a.status,
+                url: (_b = error.config) === null || _b === void 0 ? void 0 : _b.url,
+                message: error.message || ((_c = error.response) === null || _c === void 0 ? void 0 : _c.data),
+            }, "HTTP Response error");
+            return Promise.reject(errors_1.KeyringError.fromUnknown(error));
+        });
+    }
+    static initializeHttpClient(apiKey) {
+        if (!this.instance) {
+            this.instance = new HttpClient(apiKey);
+        }
+        return this.instance;
+    }
+    createSession(sessionConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.debug("Creating session on backend");
+            const response = yield this.httpClient.post("/api/v1/connect/sessions/create", {
+                config: sessionConfig,
+                origin_url: platformUtils_1.PlatformUtils.isBrowser() ? window.location.href : "server",
+            });
+            this.logger.debug({ sessionId: response.data.session_id, expiresAt: response.data.expires_at }, "Session creation response received");
+            return response.data;
+        });
+    }
+    closeSession(sessionId, sessionToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.httpClient.delete(`/api/v1/connect/sessions/${sessionId}`, {
+                headers: {
+                    "X-SESSION-TOKEN": sessionToken,
+                },
+            });
+        });
+    }
+    getSession(sessionId, sessionToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            this.logger.debug({ sessionId }, "Getting session from backend");
+            try {
+                const response = yield this.httpClient.get(`/api/v1/connect/sessions/${sessionId}`, {
+                    headers: {
+                        "x-session-token": sessionToken,
+                    },
+                });
+                // Handle 204 No Content (session deleted/expired)
+                if (response.status === 204 || !response.data) {
+                    this.logger.debug({ sessionId }, "Session not found (204 or empty response)");
+                    return null;
+                }
+                this.logger.debug({ sessionId: response.data.session_id, status: response.data.status }, "Session retrieved");
+                return response.data;
+            }
+            catch (error) {
+                // Return null for 404 or 401 (session not found or expired)
+                if (((_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === 404 || ((_b = error.response) === null || _b === void 0 ? void 0 : _b.status) === 401) {
+                    this.logger.debug({ sessionId, status: (_c = error.response) === null || _c === void 0 ? void 0 : _c.status }, "Session not found");
+                    return null;
+                }
+                // Re-throw other errors
+                throw error;
+            }
+        });
+    }
+    /**
+     * Start polling for session updates
+     * Returns a function to stop polling
+     */
+    startPolling(sessionId, sessionToken, onUpdate, onError, interval = 2000) {
+        this.logger.debug({ sessionId, interval }, "Starting session polling");
+        let isPolling = true;
+        let timeoutId = null;
+        const poll = () => __awaiter(this, void 0, void 0, function* () {
+            if (!isPolling)
+                return;
+            try {
+                const session = yield this.getSession(sessionId, sessionToken);
+                // Stop polling if session not found (expired or deleted)
+                if (!session) {
+                    this.logger.debug({ sessionId }, "Session not found, stopping polling");
+                    isPolling = false;
+                    onError(new Error("Session not found or expired"));
+                    return;
+                }
+                onUpdate(session);
+                // Continue polling if still active
+                if (isPolling) {
+                    timeoutId = setTimeout(poll, interval);
+                }
+            }
+            catch (error) {
+                this.logger.error(error, "Polling error");
+                onError(error);
+                // Continue polling despite errors (network might be temporarily down)
+                if (isPolling) {
+                    timeoutId = setTimeout(poll, interval);
+                }
+            }
+        });
+        // Start polling
+        poll();
+        // Return stop function
+        return () => {
+            this.logger.debug({ sessionId }, "Stopping session polling");
+            isPolling = false;
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+        };
+    }
+}
+exports.HttpClient = HttpClient;

package/dist/{main.d.ts → core/keyringConnectExtension.d.ts}

@@ -1,17 +1,23 @@
-import { ExtensionSDKConfig, ExtensionState } from "./types";
+import { CredentialData, ExtensionState, SessionConfig } from "../types";
 /**
  * Class for interacting with the Keyring Connect browser extension
  */
-export declare class KeyringConnect {
+export declare class KeyringConnectExtension {
     private static readonly EXTENSION_TIMEOUT;
     private static readonly EXTENSION_ID;
     private static keyringConnectUrl;
+    private static resultPromise?;
+    private static resolveResult?;
+    private static rejectResult?;
     /**
      * Tries to launch the Keyring Connect Extension with the provided configuration.
      * If the extension is not installed, it will redirect to the Keyring Connect page.
+     * @throws If the extension is not installed and running in a non-browser environment,
+     * if required configuration fields are missing, if Chrome runtime is not available,
+     * if extension communication times out, or if the extension returns an error.
      * @param data - The configuration for the extension
      */
-    static launchExtension(data: ExtensionSDKConfig): Promise<void>;
+    static launchExtension(data: SessionConfig): Promise<CredentialData | null>;
     /**
      * Check if Keyring Connect Extension is installed and ready to use
      * @returns Promise that resolves with true if extension is installed and ready to use, false otherwise
@@ -33,11 +39,7 @@ export declare class KeyringConnect {
     static subscribeToExtensionState(callback: (state: ExtensionState | null) => void): () => void;
     private static validateClientConfig;
     private static validateCredentialConfig;
-    private static validateProofConfig;
     private static validateConfigData;
     private static convertToLaunchConfig;
-    private static isChromeRuntimeAvailable;
     private static sendChromeMessage;
-    private static launchExtensionViaChromeAPI;
-    private static getExtensionStateViaChromeAPI;
 }

package/dist/{main.js → core/keyringConnectExtension.js}

@@ -9,15 +9,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KeyringConnect = void 0;
-const types_1 = require("./types");
+exports.KeyringConnectExtension = void 0;
+const types_1 = require("../types");
+const platformUtils_1 = require("../utils/platformUtils");
 /**
  * Class for interacting with the Keyring Connect browser extension
  */
-class KeyringConnect {
+class KeyringConnectExtension {
     /**
      * Tries to launch the Keyring Connect Extension with the provided configuration.
      * If the extension is not installed, it will redirect to the Keyring Connect page.
+     * @throws If the extension is not installed and running in a non-browser environment,
+     * if required configuration fields are missing, if Chrome runtime is not available,
+     * if extension communication times out, or if the extension returns an error.
      * @param data - The configuration for the extension
      */
     static launchExtension(data) {
@@ -32,11 +36,36 @@ class KeyringConnect {
                 else {
                     throw new Error("Keyring Connect is not installed");
                 }
-                return;
+                return null;
             }
+            // Create result promise that will be resolved when verification completes
+            this.resultPromise = new Promise((resolve, reject) => {
+                this.resolveResult = resolve;
+                this.rejectResult = reject;
+            });
             const validatedConfig = this.validateConfigData(data);
             const launchConfig = this.convertToLaunchConfig(validatedConfig);
-            yield this.launchExtensionViaChromeAPI(launchConfig);
+            yield this.sendChromeMessage({
+                type: types_1.EVENT_ACTIONS.LAUNCH_KEYRING_CONNECT,
+                data: launchConfig,
+            });
+            const unsubscribe = this.subscribeToExtensionState((state) => {
+                var _a, _b, _c;
+                if ((state === null || state === void 0 ? void 0 : state.status) === "credential_success") {
+                    if (!state.credentialData) {
+                        (_a = this.rejectResult) === null || _a === void 0 ? void 0 : _a.call(this, new Error("No credential data found"));
+                    }
+                    else {
+                        (_b = this.resolveResult) === null || _b === void 0 ? void 0 : _b.call(this, state.credentialData);
+                    }
+                    unsubscribe();
+                }
+                else if (state === null || state === void 0 ? void 0 : state.error) {
+                    (_c = this.rejectResult) === null || _c === void 0 ? void 0 : _c.call(this, new Error(state.error));
+                    unsubscribe();
+                }
+            });
+            return this.resultPromise;
         });
     }
     /**
@@ -59,9 +88,21 @@ class KeyringConnect {
             const timeout = new Promise((resolve) => {
                 setTimeout(() => resolve(null), this.EXTENSION_TIMEOUT);
             });
+            // Check if Chrome is available first
+            if (!platformUtils_1.PlatformUtils.isChromeRuntimeAvailable()) {
+                return null;
+            }
             let extensionResponse;
-            extensionResponse = this.getExtensionStateViaChromeAPI();
-            return Promise.race([timeout, extensionResponse]);
+            extensionResponse = this.sendChromeMessage({
+                type: types_1.EVENT_ACTIONS.GET_STATUS,
+            });
+            try {
+                return yield Promise.race([timeout, extensionResponse]);
+            }
+            catch (error) {
+                // If there's an error (like Chrome runtime not available), return null
+                return null;
+            }
         });
     }
     /**
@@ -129,32 +170,18 @@ class KeyringConnect {
         }
         return config;
     }
-    static validateProofConfig(config) {
-        var _a;
-        if ((_a = config.proof_config) === null || _a === void 0 ? void 0 : _a.datasource) {
-            if (config.proof_config.datasource.proof_sources.length === 0) {
-                throw new Error("At least one proof source is required");
-            }
-            if (!config.proof_config.datasource.proof_sources.some((source) => source.claims.length > 0)) {
-                throw new Error("At least one claim is required per proof source");
-            }
-        }
-    }
     static validateConfigData(config) {
         this.validateClientConfig(config);
-        this.validateProofConfig(config);
         this.validateCredentialConfig(config);
         return config;
     }
     static convertToLaunchConfig(config) {
-        var _a;
         const launchConfig = {
             client: {
                 client_name: config.name,
                 client_app_url: config.app_url,
                 client_logo_url: config.logo_url,
                 client_policy_id: config.policy_id,
-                client_entity_id: (_a = config.krn_config) === null || _a === void 0 ? void 0 : _a.entity_id,
                 credential_config: config.credential_config,
             },
             krn_config: config.krn_config
@@ -166,18 +193,13 @@ class KeyringConnect {
                     websocketProxyUrl: config.krn_config.websocketProxyUrl,
                 }
                 : undefined,
-            proof_config: config.proof_config,
         };
         return launchConfig;
     }
-    static isChromeRuntimeAvailable() {
-        var _a;
-        return typeof ((_a = chrome === null || chrome === void 0 ? void 0 : chrome.runtime) === null || _a === void 0 ? void 0 : _a.sendMessage) === "function";
-    }
     static sendChromeMessage(message) {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise((resolve, reject) => {
-                if (!this.isChromeRuntimeAvailable()) {
+                if (!platformUtils_1.PlatformUtils.isChromeRuntimeAvailable()) {
                     reject(new Error("Chrome runtime not available"));
                     return;
                 }
@@ -212,23 +234,8 @@ class KeyringConnect {
             });
         });
     }
-    static launchExtensionViaChromeAPI(launchConfig) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.sendChromeMessage({
-                type: types_1.EVENT_ACTIONS.LAUNCH_KEYRING_CONNECT,
-                data: launchConfig,
-            });
-        });
-    }
-    static getExtensionStateViaChromeAPI() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.sendChromeMessage({
-                type: types_1.EVENT_ACTIONS.GET_STATUS,
-            });
-        });
-    }
 }
-exports.KeyringConnect = KeyringConnect;
-KeyringConnect.EXTENSION_TIMEOUT = 2000;
-KeyringConnect.EXTENSION_ID = "jgogeidclfccfoedhfjjaclnaojcllpi";
-KeyringConnect.keyringConnectUrl = "https://app.keyring.network/connect";
+exports.KeyringConnectExtension = KeyringConnectExtension;
+KeyringConnectExtension.EXTENSION_TIMEOUT = 2000;
+KeyringConnectExtension.EXTENSION_ID = "jgogeidclfccfoedhfjjaclnaojcllpi";
+KeyringConnectExtension.keyringConnectUrl = "https://app.keyring.network/connect";

package/dist/core/websocketClient.d.ts

@@ -0,0 +1,23 @@
+import { SDKCallbacks, WebSocketMessage } from "../types";
+export declare class KeyringWebSocketClient {
+    private logger;
+    private socket;
+    private sessionId;
+    private sessionToken;
+    private wsUrl;
+    private callbacks;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private heartbeatInterval;
+    private isConnected;
+    constructor(sessionId: string, sessionToken: string, callbacks: SDKCallbacks);
+    connect(): Promise<void>;
+    private handleMessage;
+    sendMessage(message: Partial<WebSocketMessage>): void;
+    private startHeartbeat;
+    private scheduleReconnect;
+    private cleanup;
+    disconnect(): void;
+    getConnectionState(): string;
+    private createError;
+}

package/dist/core/websocketClient.js

@@ -0,0 +1,220 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyringWebSocketClient = void 0;
+const environment_1 = require("../utils/environment");
+const logger_1 = require("../utils/logger");
+class KeyringWebSocketClient {
+    constructor(sessionId, sessionToken, callbacks) {
+        this.socket = null;
+        this.wsUrl = environment_1.Environment.getConfig().apiUrl;
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 5;
+        this.heartbeatInterval = null;
+        this.isConnected = false;
+        this.sessionId = sessionId;
+        this.sessionToken = sessionToken;
+        this.callbacks = callbacks;
+        this.logger = logger_1.KeyringLogger.init("KeyringWebSocketClient").child({
+            sessionId,
+            wsUrl: this.wsUrl,
+        });
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                try {
+                    // Convert HTTP/HTTPS URL to WS/WSS for native WebSocket
+                    const wsUrl = this.wsUrl.replace("http://", "ws://").replace("https://", "wss://");
+                    // Build WebSocket URL with sessionId and sessionToken
+                    const url = `${wsUrl}/ws/connect/session?sessionId=${encodeURIComponent(this.sessionId)}&sessionToken=${encodeURIComponent(this.sessionToken)}`;
+                    this.logger.debug({
+                        wsUrl,
+                        sessionId: this.sessionId,
+                        hasSessionToken: !!this.sessionToken,
+                    }, "Connecting to WebSocket");
+                    this.socket = new WebSocket(url);
+                    this.socket.onopen = () => {
+                        var _a, _b;
+                        this.logger.info("WebSocket connected successfully");
+                        this.isConnected = true;
+                        this.reconnectAttempts = 0;
+                        this.startHeartbeat();
+                        (_b = (_a = this.callbacks).onConnectionStatusChanged) === null || _b === void 0 ? void 0 : _b.call(_a, true);
+                        resolve();
+                    };
+                    this.socket.onmessage = (event) => {
+                        try {
+                            const message = JSON.parse(event.data);
+                            this.handleMessage(message);
+                        }
+                        catch (error) {
+                            this.logger.error({ error, data: event.data }, "Failed to parse WebSocket message");
+                        }
+                    };
+                    this.socket.onclose = (event) => {
+                        var _a, _b;
+                        if (!this.isConnected)
+                            return;
+                        this.logger.info({ code: event.code, reason: event.reason }, "WebSocket disconnected");
+                        this.isConnected = false;
+                        this.cleanup();
+                        if (event.code !== 1000) {
+                            if (this.reconnectAttempts < this.maxReconnectAttempts) {
+                                this.scheduleReconnect();
+                            }
+                        }
+                        else {
+                            (_b = (_a = this.callbacks).onConnectionStatusChanged) === null || _b === void 0 ? void 0 : _b.call(_a, false);
+                        }
+                    };
+                    this.socket.onerror = (error) => {
+                        var _a, _b;
+                        this.logger.error({ error, sessionId: this.sessionId }, "WebSocket error");
+                        (_b = (_a = this.callbacks).onConnectionStatusChanged) === null || _b === void 0 ? void 0 : _b.call(_a, false);
+                        reject(error);
+                    };
+                    // Set connection timeout
+                    setTimeout(() => {
+                        if (this.socket && !this.isConnected) {
+                            this.socket.close();
+                            reject(new Error("WebSocket connection timeout"));
+                        }
+                    }, 10000); // 10 second timeout
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+    }
+    handleMessage(message) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        try {
+            this.logger.debug({ message }, "Received message");
+            switch (message.type) {
+                case "connected":
+                    this.logger.info("Connection confirmed by server");
+                    break;
+                case "mobile_connected":
+                    (_b = (_a = this.callbacks).onMobileConnected) === null || _b === void 0 ? void 0 : _b.call(_a, message.data);
+                    break;
+                case "processing_started":
+                    (_d = (_c = this.callbacks).onProcessingStarted) === null || _d === void 0 ? void 0 : _d.call(_c, message.data);
+                    break;
+                case "processing_completed":
+                    (_f = (_e = this.callbacks).onProcessingCompleted) === null || _f === void 0 ? void 0 : _f.call(_e, message.data);
+                    break;
+                case "processing_failed":
+                    (_h = (_g = this.callbacks).onProcessingFailed) === null || _h === void 0 ? void 0 : _h.call(_g, message.data);
+                    break;
+                case "session_expired":
+                    (_k = (_j = this.callbacks).onSessionExpired) === null || _k === void 0 ? void 0 : _k.call(_j, message.data);
+                    this.disconnect();
+                    break;
+                case "error":
+                    (_m = (_l = this.callbacks).onError) === null || _m === void 0 ? void 0 : _m.call(_l, this.createError("MOBILE_PROCESSING_FAILED", message.data.message || "Mobile processing error", message.data));
+                    break;
+                case "heartbeat_response":
+                    this.logger.debug("Heartbeat response received");
+                    break;
+                default:
+                    this.logger.warn({ messageType: message.type }, "Unknown message type");
+            }
+        }
+        catch (error) {
+            this.logger.error({ error }, "Error handling WebSocket message");
+            (_p = (_o = this.callbacks).onError) === null || _p === void 0 ? void 0 : _p.call(_o, this.createError("NETWORK_ERROR", "Failed to handle WebSocket message", error));
+        }
+    }
+    sendMessage(message) {
+        var _a, _b;
+        if (!this.socket || !this.isConnected || this.socket.readyState !== WebSocket.OPEN) {
+            this.logger.warn("Cannot send message - WebSocket not connected");
+            return;
+        }
+        const fullMessage = Object.assign({ session_id: this.sessionId, timestamp: Date.now() }, message);
+        try {
+            this.socket.send(JSON.stringify(fullMessage));
+            this.logger.debug({ message: fullMessage }, "Sent message");
+        }
+        catch (error) {
+            this.logger.error({ error }, "Error sending message");
+            (_b = (_a = this.callbacks).onError) === null || _b === void 0 ? void 0 : _b.call(_a, this.createError("WEBSOCKET_CONNECTION_FAILED", "Failed to send WebSocket message", error));
+        }
+    }
+    startHeartbeat() {
+        this.heartbeatInterval = setInterval(() => {
+            this.sendMessage({
+                type: "heartbeat",
+            });
+        }, 30000); // 30 second heartbeat
+    }
+    scheduleReconnect() {
+        this.reconnectAttempts++;
+        const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000); // Exponential backoff, max 30s
+        this.logger.info({
+            attempt: this.reconnectAttempts,
+            maxAttempts: this.maxReconnectAttempts,
+            delay,
+        }, "Scheduling reconnection attempt");
+        setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.connect();
+                this.logger.info("Reconnection successful");
+            }
+            catch (error) {
+                this.logger.error({ error }, "Reconnection failed");
+            }
+        }), delay);
+    }
+    cleanup() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
+    disconnect() {
+        var _a, _b;
+        this.logger.info("Disconnecting WebSocket");
+        this.cleanup();
+        this.isConnected = false;
+        if (this.socket) {
+            this.socket.close(1000, "Normal closure");
+            this.socket = null;
+        }
+        (_b = (_a = this.callbacks).onConnectionStatusChanged) === null || _b === void 0 ? void 0 : _b.call(_a, false);
+    }
+    getConnectionState() {
+        if (!this.socket)
+            return "CLOSED";
+        switch (this.socket.readyState) {
+            case WebSocket.CONNECTING:
+                return "CONNECTING";
+            case WebSocket.OPEN:
+                return "CONNECTED";
+            case WebSocket.CLOSING:
+                return "CLOSING";
+            case WebSocket.CLOSED:
+                return "CLOSED";
+            default:
+                return "UNKNOWN";
+        }
+    }
+    createError(code, message, details) {
+        return {
+            code,
+            message,
+            details,
+        };
+    }
+}
+exports.KeyringWebSocketClient = KeyringWebSocketClient;

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 export * from "@keyringnetwork/contracts-abi";
-export { KeyringConnect } from "./main";
+export { VerificationSession } from "./core/VerificationSession";
 export * from "./types";

package/dist/index.js

@@ -14,8 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KeyringConnect = void 0;
+exports.VerificationSession = void 0;
 __exportStar(require("@keyringnetwork/contracts-abi"), exports);
-var main_1 = require("./main");
-Object.defineProperty(exports, "KeyringConnect", { enumerable: true, get: function () { return main_1.KeyringConnect; } });
+var VerificationSession_1 = require("./core/VerificationSession");
+Object.defineProperty(exports, "VerificationSession", { enumerable: true, get: function () { return VerificationSession_1.VerificationSession; } });
 __exportStar(require("./types"), exports);

package/dist/types/api.d.ts

@@ -0,0 +1,24 @@
+import { DataSource } from "@keyringnetwork/keyring-dtos";
+import { CredentialData, SessionConfig } from "./core";
+export type SessionStatus = "session_created" | "mobile_connected" | "processing_started" | "processing_completed" | "processing_failed" | "session_expired";
+export interface CrossDeviceSession {
+    session_id: string;
+    session_token: string;
+    config: SessionConfig;
+    origin_url: string;
+    status: SessionStatus;
+    created_at: number | string;
+    expires_at: number | string;
+    result?: {
+        credential_data?: CredentialData;
+        entity_type?: string;
+        datasource?: DataSource;
+    };
+    error?: string;
+    platform: "web" | "mobile";
+    qr_code_data: string;
+    connected_clients: {
+        web?: string;
+        mobile?: string;
+    };
+}

package/dist/types/api.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });