@keyringnetwork/keyring-connect-sdk 3.2.0 → 4.1.0-alpha.2

package/dist/utils/logger.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyringLogger = void 0;
+const pino_1 = __importDefault(require("pino"));
+const package_json_1 = __importDefault(require("../../package.json"));
+class KeyringLogger {
+    static init(scope) {
+        const logger = this.createPinoLogger(scope);
+        return logger;
+    }
+    static createPinoLogger(scope) {
+        const metadata = {
+            scope,
+            packageVersion: this.packageVersion,
+        };
+        const logger = (0, pino_1.default)({
+            name: this.prefix,
+            level: "debug",
+            browser: {
+                asObject: true,
+                formatters: {
+                    level: (label) => ({
+                        level: label.toUpperCase(),
+                    }),
+                    log(object) {
+                        return Object.assign(Object.assign({}, object), { metadata });
+                    },
+                },
+            },
+            timestamp: () => `${new Date(Date.now()).toISOString()}`,
+        });
+        return logger;
+    }
+}
+exports.KeyringLogger = KeyringLogger;
+KeyringLogger.prefix = "[Keyring SDK]";
+KeyringLogger.packageVersion = package_json_1.default.version;

package/dist/utils/platformUtils.d.ts

@@ -0,0 +1,24 @@
+export interface PlatformInfo {
+    isDesktop: boolean;
+    isMobile: boolean;
+    isAndroid: boolean;
+    isIOS: boolean;
+}
+export declare class PlatformUtils {
+    /**
+     * Detect the current platform and capabilities
+     */
+    static detectPlatform(): PlatformInfo;
+    /**
+     * Check if Chrome runtime is available for extension communication
+     */
+    static isChromeRuntimeAvailable(): boolean;
+    /**
+     * Check if running in browser environment
+     */
+    static isBrowser(): boolean;
+    /**
+     * Wait for online status
+     */
+    static waitForOnline(timeout?: number): Promise<boolean>;
+}

package/dist/utils/platformUtils.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlatformUtils = void 0;
+class PlatformUtils {
+    /**
+     * Detect the current platform and capabilities
+     */
+    static detectPlatform() {
+        const userAgent = typeof navigator !== "undefined" ? navigator.userAgent : "";
+        const isAndroid = /Android/i.test(userAgent);
+        const isIOS = /iPad|iPhone|iPod/.test(userAgent);
+        const isMobile = isAndroid ||
+            isIOS ||
+            /Mobile|Opera Mini|Fennec|webOS|BlackBerry|PlayBook|BB10|IEMobile/i.test(userAgent);
+        const isDesktop = !isMobile;
+        return {
+            isDesktop,
+            isMobile,
+            isAndroid,
+            isIOS,
+        };
+    }
+    /**
+     * Check if Chrome runtime is available for extension communication
+     */
+    static isChromeRuntimeAvailable() {
+        var _a;
+        try {
+            return typeof ((_a = chrome === null || chrome === void 0 ? void 0 : chrome.runtime) === null || _a === void 0 ? void 0 : _a.sendMessage) === "function";
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Check if running in browser environment
+     */
+    static isBrowser() {
+        return typeof window !== "undefined";
+    }
+    /**
+     * Wait for online status
+     */
+    static waitForOnline(timeout = 30000) {
+        return new Promise((resolve) => {
+            if (typeof navigator === "undefined" || navigator.onLine) {
+                resolve(true);
+                return;
+            }
+            let timeoutId;
+            const onOnline = () => {
+                clearTimeout(timeoutId);
+                window.removeEventListener("online", onOnline);
+                resolve(true);
+            };
+            window.addEventListener("online", onOnline);
+            timeoutId = setTimeout(() => {
+                window.removeEventListener("online", onOnline);
+                resolve(false);
+            }, timeout);
+        });
+    }
+}
+exports.PlatformUtils = PlatformUtils;

package/package.json

@@ -1,34 +1,49 @@
 {
   "name": "@keyringnetwork/keyring-connect-sdk",
-  "version": "3.2.0",
+  "version": "4.1.0-alpha.2",
   "description": "An SDK for interacting with Keyring Connect browser extension",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "scripts": {
-    "build": "rm -rf dist && tsc",
-    "dev": "tsc --watch",
-    "build_and_publish": "pnpm build && npm publish",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage",
-    "test:ci": "jest --ci --coverage --watchAll=false"
-  },
   "files": [
     "dist"
   ],
-  "keywords": [],
-  "author": "",
+  "keywords": [
+    "keyring",
+    "keyring connect",
+    "sdk"
+  ],
+  "author": "Keyring Network",
   "license": "ISC",
   "devDependencies": {
     "@types/chrome": "^0.0.268",
     "@types/jest": "^29.5.0",
+    "@types/qrcode": "^1.5.5",
+    "autoprefixer": "^10.4.21",
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",
+    "postcss": "^8.5.6",
+    "tailwindcss": "^3.4.17",
     "ts-jest": "^29.1.0",
     "ts-node": "^10.9.2",
     "typescript": "^5.6.3"
   },
   "dependencies": {
-    "@keyringnetwork/contracts-abi": "2.6.0"
+    "@keyringnetwork/contracts-abi": "2.6.1",
+    "@keyringnetwork/keyring-dtos": "1.0.0",
+    "axios": "^1.12.2",
+    "lit": "^3.3.1",
+    "pino": "^9.13.1",
+    "qr-code-styling": "^1.9.2",
+    "socket.io-client": "^4.8.1"
+  },
+  "scripts": {
+    "build:ts": "tsc",
+    "build": "rm -rf dist && npm run build:ts",
+    "dev": "tsc --watch",
+    "prepublish": "pnpm build",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:ci": "jest --ci --coverage --watchAll=false"
   }
-}
+}

package/readme.md

@@ -1,146 +1,98 @@
 # Keyring Connect SDK
 
-A TypeScript SDK for integrating with the Keyring Connect browser extension. This SDK enables seamless interaction with the Keyring Connect extension for user verification and attestation.
+TypeScript SDK for integrating Keyring identity verification into web applications. Supports both browser extension and mobile app verification flows.
 
 ## Installation
 
 ```bash
-npm install @keyringnetwork/keyring-connect-sdk
-yarn add @keyringnetwork/keyring-connect-sdk
 pnpm install @keyringnetwork/keyring-connect-sdk
 ```
 
-## Features
-
-- Check if the extension is installed
-- Launch Keyring Connect with custom client configuration
-- Redirect the user back to the app where they left off after extension installation
-- Monitor extension status and user state
-- Full TypeScript support with comprehensive type definitions
-
-## Usage
-
-### Initialize
+## Quick Start
 
 ```typescript
-import { KeyringConnect } from "@keyringnetwork/keyring-connect-sdk";
-```
-
-### Check if the extension is installed
+import { VerificationSession } from "@keyringnetwork/keyring-connect-sdk";
 
-```typescript
-const isInstalled = await KeyringConnect.isKeyringConnectInstalled();
-```
-
-### Launch Keyring Connect
-
-```typescript
-const extensionConfig = {
+const session = await VerificationSession.launch({
   name: "My App",
   app_url: "https://myapp.com",
   logo_url: "https://myapp.com/logo.png",
   policy_id: 123,
+  api_key: "your-api-key",
   credential_config: {
     chain_id: 1,
-    wallet_address: '0x123abc'
-  }
-};
+    wallet_address: "0x123...",
+  },
+});
 
-// This method handles both launching the extension if installed
-// or redirecting to the Chrome Web Store if not installed
 try {
-  await KeyringConnect.launchExtension(extensionConfig);
+  const credential = await session.start();
+  console.log("Verification successful:", credential);
 } catch (error) {
-  console.error("Failed to launch Keyring Connect:", error);
+  console.error("Verification failed:", error);
 }
 ```
 
-### Monitor Extension Status
+## Features
 
-```typescript
-export interface ExtensionState {
-  status: "idle" | "mounted" | "proving" | "prove_success" | "error";
-  manifest?: any;
-  error?: string; // error message, only if status is 'error'
-  user?: User;
-}
+- Multi-platform support - Browser extension for desktop, QR code flow for mobile
+- Real-time updates - WebSocket-based status updates during verification
+- Built-in UI - Ready-to-use modals for platform selection, QR codes, and status
+- TypeScript - Full type definitions included
+- Error handling - Structured errors with `KeyringError` and error codes
 
-const extensionState = await KeyringConnect.getExtensionState();
-```
+## API
 
-### Integration Example
+### VerificationSession
+
+Main entry point for verification flows.
 
 ```typescript
-import { useEffect, useState } from "react";
-import {
-  ExtensionSDKConfig,
-  KeyringConnect,
-} from "@keyringnetwork/keyring-connect-sdk";
-
-function KeyringConnectButton() {
-  const [isInstalled, setIsInstalled] = useState<boolean | undefined>(
-    undefined
-  );
-
-  // Check if extension is installed
-  useEffect(() => {
-    const checkExtension = async () => {
-      const isInstalled = await KeyringConnect.isKeyringConnectInstalled();
-      setIsInstalled(isInstalled);
-    };
-    checkExtension();
-  }, []);
-
-  // Configure your app
-  const config: ExtensionSDKConfig = {
-    app_url: window.location.origin,
-    name: "My App",
-    logo_url: "https://myapp.com/logo.png",
-    policy_id: 7,
-  };
+// Launch a new session
+const session = await VerificationSession.launch(config);
 
-  // Launch the extension (handles both installed and not installed cases)
-  const launchExtension = () => {
-    KeyringConnect.launchExtension(config);
-  };
+// Start verification (returns credential on success)
+const credential = await session.start();
 
-  if (isInstalled === undefined) {
-    return <button disabled>Checking extension...</button>;
-  }
+// Listen to events
+session.addEventListener("processingStarted", (data) => {
+  console.log("Processing started");
+});
 
-  return (
-    <button onClick={launchExtension}>
-      {isInstalled ? "Launch Extension" : "Install Extension"}
-    </button>
-  );
-}
+// Clean up
+await session.close();
 ```
 
-## API Reference
-
-#### Core Types Overview
-
-- `ExtensionConfig`: Configuration for initializing the Keyring Connect extension
-- `ExtensionState`: Current state and status information of the extension
-- `User`: User's verification and credential status information
-
-#### Status Types
+### SessionConfig
 
-- `ExtensionStatus`: Extension states (`idle`, `mounted`, `proving`, `prove_error`, `prove_success`, `error`)
-- `AttestationStatus`: Off-chain verification status (`onboarding_required`, `onboarding_pending`, `attestation_ready`, `non_compliant`)
-- `CredentialStatus`: On-chain credential status (`expired`, `valid`, `none`)
+```typescript
+interface SessionConfig {
+  name: string; // App display name
+  app_url: string; // Your app URL
+  logo_url: string; // App logo for modals
+  policy_id: number; // On-chain Keyring policy ID
+  api_key: string; // Your API key
+  credential_config: {
+    chain_id: number; // Target chain ID
+    wallet_address: string; // User's wallet address
+  };
+}
+```
 
-## Extension States
+### Events
 
-- **idle**: Extension is installed but not active
-- **mounted**: Extension is launched and ready
-- **proving**: Currently generating proof
-- **prove_success**: Proof generation successful
-- **error**: An error occurred
+- `mobileConnected` - Mobile app connected via QR scan
+- `processingStarted` - Verification processing began
+- `processingCompleted` - Verification successful
+- `sessionExpired` - Session timed out
+- `error` - An error occurred
 
 ## Requirements
 
-- An on-chain Keyring policy
-- Chrome browser (version 88 or higher recommended)
-- Keyring Connect browser extension installed
+- Chrome browser (v88+) for extension flow
 - Active internet connection
+- On-chain Keyring policy
+
+## License
+
+ISC