@zkpassport/sdk 0.2.1 → 0.2.3

package/dist/esm/json-rpc.d.ts

@@ -1,5 +1,5 @@
-import type { JsonRpcRequest, JsonRpcResponse } from '@zkpassport/utils';
-import { WebSocketClient } from './websocket';
+import type { JsonRpcRequest, JsonRpcResponse } from "@zkpassport/utils";
+import { WebSocketClient } from "./websocket";
 export declare function createJsonRpcRequest(method: string, params: any): JsonRpcRequest;
 export declare function createEncryptedJsonRpcRequest(method: string, params: any, sharedSecret: Uint8Array, topic: string): Promise<JsonRpcRequest>;
 export declare function sendEncryptedJsonRpcRequest(method: string, params: any, sharedSecret: Uint8Array, topic: string, wsClient: WebSocketClient): Promise<boolean>;

package/dist/esm/json-rpc.js

@@ -1,40 +1,40 @@
-import { randomBytes } from 'crypto';
-import { encrypt } from './encryption';
-import logger from './logger';
+import { randomBytes } from "crypto";
+import { encrypt } from "./encryption";
+import { noLogger as logger } from "./logger";
 export function createJsonRpcRequest(method, params) {
     return {
-        jsonrpc: '2.0',
-        id: randomBytes(16).toString('hex'),
+        jsonrpc: "2.0",
+        id: randomBytes(16).toString("hex"),
         method,
         params,
     };
 }
 export async function createEncryptedJsonRpcRequest(method, params, sharedSecret, topic) {
     const encryptedMessage = await encrypt(JSON.stringify({ method, params: params || {} }), sharedSecret, topic);
-    return createJsonRpcRequest('encryptedMessage', {
-        payload: Buffer.from(encryptedMessage).toString('base64'),
+    return createJsonRpcRequest("encryptedMessage", {
+        payload: Buffer.from(encryptedMessage).toString("base64"),
     });
 }
 export async function sendEncryptedJsonRpcRequest(method, params, sharedSecret, topic, wsClient) {
     try {
         const message = { method, params: params || {} };
         const encryptedMessage = await encrypt(JSON.stringify(message), sharedSecret, topic);
-        const request = createJsonRpcRequest('encryptedMessage', {
-            payload: Buffer.from(encryptedMessage).toString('base64'),
+        const request = createJsonRpcRequest("encryptedMessage", {
+            payload: Buffer.from(encryptedMessage).toString("base64"),
         });
-        logger.debug('Sending encrypted message (original):', message);
-        logger.debug('Sending encrypted message (encrypted):', request);
+        logger.debug("Sending encrypted message (original):", message);
+        logger.debug("Sending encrypted message (encrypted):", request);
         wsClient.send(JSON.stringify(request));
         return true;
     }
     catch (error) {
-        logger.error('Error sending encrypted message:', error);
+        logger.error("Error sending encrypted message:", error);
         return false;
     }
 }
 export function createJsonRpcResponse(id, result) {
     return {
-        jsonrpc: '2.0',
+        jsonrpc: "2.0",
         id,
         result,
     };

package/dist/esm/logger.d.ts

@@ -1,7 +1,12 @@
-declare const customLogger: {
+export declare const customLogger: {
     debug: (message: string, ...args: any[]) => void;
     info: (message: string, ...args: any[]) => void;
     warn: (message: string, ...args: any[]) => void;
     error: (message: string, ...args: any[]) => void;
 };
-export default customLogger;
+export declare const noLogger: {
+    debug: (..._: any[]) => void;
+    info: (..._: any[]) => void;
+    warn: (..._: any[]) => void;
+    error: (..._: any[]) => void;
+};

package/dist/esm/logger.js

@@ -1,37 +1,12 @@
-// import { createLogger, transports, format } from 'winston'
-// import colors from 'colors/safe'
-// import util from 'util'
-// const logger = createLogger({
-//   level: 'debug',
-//   format: format.combine(
-//     format.timestamp({ format: 'HH:mm' }),
-//     format.printf(({ timestamp, level, message, additionalInfo }) => {
-//       const colorMap = {
-//         debug: colors.cyan,
-//         info: colors.green,
-//         warn: colors.yellow,
-//         error: colors.red,
-//       } as const
-//       const coloredLevel = (colorMap[level as keyof typeof colorMap] || colors.white)(level.toUpperCase())
-//       let logMessage = `${timestamp} [${coloredLevel}] ${message}`
-//       if (additionalInfo && additionalInfo.length > 0) {
-//         logMessage += ' ' + util.inspect(additionalInfo, { depth: null, colors: true })
-//       }
-//       return logMessage
-//     }),
-//   ),
-//   transports: [new transports.Console()],
-// })
-// const customLogger = {
-//   debug: (message: string, ...args: any[]) => logger.debug(message, { additionalInfo: args }),
-//   info: (message: string, ...args: any[]) => logger.info(message, { additionalInfo: args }),
-//   warn: (message: string, ...args: any[]) => logger.warn(message, { additionalInfo: args }),
-//   error: (message: string, ...args: any[]) => logger.error(message, { additionalInfo: args }),
-// }
-const customLogger = {
+export const customLogger = {
     debug: (message, ...args) => console.debug(message, ...args),
     info: (message, ...args) => console.info(message, ...args),
     warn: (message, ...args) => console.warn(message, ...args),
     error: (message, ...args) => console.error(message, ...args),
 };
-export default customLogger;
+export const noLogger = {
+    debug: (..._) => { },
+    info: (..._) => { },
+    warn: (..._) => { },
+    error: (..._) => { },
+};

package/dist/esm/mobile.js

@@ -1,8 +1,8 @@
-import { bytesToHex } from '@noble/ciphers/utils';
-import { getWebSocketClient } from './websocket';
-import { sendEncryptedJsonRpcRequest } from './json-rpc';
-import { decrypt, generateECDHKeyPair, getSharedSecret } from './encryption';
-import logger from './logger';
+import { bytesToHex } from "@noble/ciphers/utils";
+import { getWebSocketClient } from "./websocket";
+import { sendEncryptedJsonRpcRequest } from "./json-rpc";
+import { decrypt, generateECDHKeyPair, getSharedSecret } from "./encryption";
+import { noLogger as logger } from "./logger";
 export class ZkPassportProver {
     constructor() {
         this.topicToKeyPair = {};
@@ -20,13 +20,13 @@ export class ZkPassportProver {
      * @param outerRequest The outer request.
      */
     async handleEncryptedMessage(topic, request, outerRequest) {
-        logger.debug('Received encrypted message:', request);
-        if (request.method === 'hello') {
+        logger.debug("Received encrypted message:", request);
+        if (request.method === "hello") {
             logger.info(`Successfully verified origin domain name: ${outerRequest.origin}`);
             this.topicToRemoteDomainVerified[topic] = true;
             await Promise.all(this.onDomainVerifiedCallbacks[topic].map((callback) => callback()));
         }
-        else if (request.method === 'closed_page') {
+        else if (request.method === "closed_page") {
             // TODO: Implement
         }
     }
@@ -36,13 +36,13 @@ export class ZkPassportProver {
      */
     async scan(url, { keyPairOverride, } = {}) {
         const parsedUrl = new URL(url);
-        const domain = parsedUrl.searchParams.get('d');
-        const topic = parsedUrl.searchParams.get('t');
-        const pubkeyHex = parsedUrl.searchParams.get('p');
+        const domain = parsedUrl.searchParams.get("d");
+        const topic = parsedUrl.searchParams.get("t");
+        const pubkeyHex = parsedUrl.searchParams.get("p");
         if (!domain || !topic || !pubkeyHex) {
-            throw new Error('Invalid URL: missing required parameters');
+            throw new Error("Invalid URL: missing required parameters");
         }
-        const pubkey = new Uint8Array(Buffer.from(pubkeyHex, 'hex'));
+        const pubkey = new Uint8Array(Buffer.from(pubkeyHex, "hex"));
         this.domain = domain;
         const keyPair = keyPairOverride || (await generateECDHKeyPair());
         this.topicToKeyPair[topic] = {
@@ -58,7 +58,7 @@ export class ZkPassportProver {
         const wsClient = getWebSocketClient(`wss://bridge.zkpassport.id?topic=${topic}&pubkey=${bytesToHex(keyPair.publicKey)}`);
         this.topicToWebSocketClient[topic] = wsClient;
         wsClient.onopen = async () => {
-            logger.info('[mobile] WebSocket connection established');
+            logger.info("[mobile] WebSocket connection established");
             await Promise.all(this.onBridgeConnectCallbacks[topic].map((callback) => callback()));
             // Server sends handshake automatically (when it sees a pubkey in websocket URI)
             // wsClient.send(
@@ -69,8 +69,8 @@ export class ZkPassportProver {
             //   ),
             // )
         };
-        wsClient.addEventListener('message', async (event) => {
-            logger.info('[mobile] Received message:', event.data);
+        wsClient.addEventListener("message", async (event) => {
+            logger.info("[mobile] Received message:", event.data);
             try {
                 const data = JSON.parse(event.data);
                 const originDomain = data.origin ? new URL(data.origin).hostname : undefined;
@@ -79,10 +79,10 @@ export class ZkPassportProver {
                     logger.warn(`[mobile] Origin does not match domain in QR code. Expected ${this.domain} but got ${originDomain}`);
                     return;
                 }
-                if (data.method === 'encryptedMessage') {
+                if (data.method === "encryptedMessage") {
                     // Decode the payload from base64 to Uint8Array
                     const payload = new Uint8Array(atob(data.params.payload)
-                        .split('')
+                        .split("")
                         .map((c) => c.charCodeAt(0)));
                     try {
                         // Decrypt the payload using the shared secret
@@ -91,16 +91,16 @@ export class ZkPassportProver {
                         await this.handleEncryptedMessage(topic, decryptedJson, data);
                     }
                     catch (error) {
-                        logger.error('[mobile] Error decrypting message:', error);
+                        logger.error("[mobile] Error decrypting message:", error);
                     }
                 }
             }
             catch (error) {
-                logger.error('[mobile] Error:', error);
+                logger.error("[mobile] Error:", error);
             }
         });
         wsClient.onerror = (error) => {
-            logger.error('[mobile] WebSocket error:', error);
+            logger.error("[mobile] WebSocket error:", error);
         };
         return {
             domain: this.domain,
@@ -110,16 +110,16 @@ export class ZkPassportProver {
             onDomainVerified: (callback) => this.onDomainVerifiedCallbacks[topic].push(callback),
             onBridgeConnect: (callback) => this.onBridgeConnectCallbacks[topic].push(callback),
             notifyReject: async () => {
-                await sendEncryptedJsonRpcRequest('reject', null, this.topicToSharedSecret[topic], topic, this.topicToWebSocketClient[topic]);
+                await sendEncryptedJsonRpcRequest("reject", null, this.topicToSharedSecret[topic], topic, this.topicToWebSocketClient[topic]);
             },
             notifyAccept: async () => {
-                await sendEncryptedJsonRpcRequest('accept', null, this.topicToSharedSecret[topic], topic, this.topicToWebSocketClient[topic]);
+                await sendEncryptedJsonRpcRequest("accept", null, this.topicToSharedSecret[topic], topic, this.topicToWebSocketClient[topic]);
             },
             notifyDone: async (proof) => {
-                await sendEncryptedJsonRpcRequest('done', { proof }, this.topicToSharedSecret[topic], topic, this.topicToWebSocketClient[topic]);
+                await sendEncryptedJsonRpcRequest("done", { proof }, this.topicToSharedSecret[topic], topic, this.topicToWebSocketClient[topic]);
             },
             notifyError: async (error) => {
-                await sendEncryptedJsonRpcRequest('error', { error }, this.topicToSharedSecret[topic], topic, this.topicToWebSocketClient[topic]);
+                await sendEncryptedJsonRpcRequest("error", { error }, this.topicToSharedSecret[topic], topic, this.topicToWebSocketClient[topic]);
             },
         };
     }

package/dist/esm/websocket.js

@@ -1,14 +1,14 @@
 export function getWebSocketClient(url, origin) {
-    if (typeof window !== 'undefined' && window.WebSocket) {
+    if (typeof window !== "undefined" && window.WebSocket) {
         // Browser environment
         return new WebSocket(url);
     }
     else {
         // Node.js environment
-        const WebSocket = require('ws');
+        const WebSocket = require("ws");
         return new WebSocket(url, {
             headers: {
-                Origin: origin || 'nodejs',
+                Origin: origin || "nodejs",
             },
         });
     }

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@zkpassport/sdk",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Privacy-preserving identity verification using passports and ID cards",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
   "types": "./dist/esm/index.d.ts",
+  "type": "module",
   "files": [
     "src/",
     "dist/**",
@@ -12,28 +13,37 @@
     "README.md"
   ],
   "scripts": {
-    "prepublishOnly": "npm run build",
+    "prepublishOnly": "npm run test && npm run build",
     "build": "npm run build:esm && npm run build:cjs",
     "build:esm": "tsc -p tsconfig.json",
-    "build:cjs": "tsc -p tsconfig.cjs.json"
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "test": "NODE_OPTIONS='--require ts-node/register' NODE_NO_WARNINGS=1 node node_modules/.bin/jest --no-cache --passWithNoTests --runInBand **/*.test.ts",
+    "test:debug": "NODE_OPTIONS='--require ts-node/register' NODE_NO_WARNINGS=1 node --inspect-brk=0.0.0.0 node_modules/.bin/jest --no-cache --passWithNoTests --runInBand **/*.test.ts",
+    "deploy": "npm publish --access public"
   },
   "keywords": [],
   "author": "",
   "license": "Apache-2.0",
   "devDependencies": {
+    "@babel/plugin-proposal-decorators": "^7.25.9",
+    "@babel/preset-env": "^7.26.0",
+    "@babel/preset-typescript": "^7.26.0",
+    "@jest/globals": "^29.7.0",
+    "@types/jest": "^29.5.14",
     "@types/node": "^22.10.9",
     "@types/node-gzip": "^1.1.3",
     "@types/ws": "^8.5.12",
+    "jest": "^29.7.0",
     "typescript": "^5.6.2"
   },
   "dependencies": {
     "@aztec/bb.js": "^0.67.0",
-    "@noble/ciphers": "^1.0.0",
-    "@noble/secp256k1": "^2.1.0",
+    "@noble/ciphers": "^1.2.1",
+    "@noble/secp256k1": "^2.2.3",
     "@zkpassport/utils": "^0.2.12",
     "i18n-iso-countries": "^7.12.0",
     "node-gzip": "^1.1.2",
-    "tslib": "^2.8.1",
     "ws": "^8.18.0"
-  }
+  },
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }

package/src/encryption.ts

@@ -1,17 +1,17 @@
-import { gcm } from '@noble/ciphers/aes'
-import { utf8ToBytes } from '@noble/ciphers/utils'
+import { gcm } from "@noble/ciphers/aes"
+import { utf8ToBytes } from "@noble/ciphers/utils"
 
 async function sha256Truncate(topic: string): Promise<Uint8Array> {
   const encoder = new TextEncoder()
   const data = encoder.encode(topic)
-  const hashBuffer = await crypto.subtle.digest('SHA-256', data)
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data)
   const fullHashArray = new Uint8Array(hashBuffer)
   const truncatedHashArray = fullHashArray.slice(0, 12)
   return truncatedHashArray
 }
 
 export async function generateECDHKeyPair() {
-  const secp256k1 = await import('@noble/secp256k1')
+  const secp256k1 = await import("@noble/secp256k1")
   const privKey = secp256k1.utils.randomPrivateKey()
   const pubKey = secp256k1.getPublicKey(privKey)
   return {
@@ -21,7 +21,7 @@ export async function generateECDHKeyPair() {
 }
 
 export async function getSharedSecret(privateKey: string, publicKey: string) {
-  const secp256k1 = await import('@noble/secp256k1')
+  const secp256k1 = await import("@noble/secp256k1")
   const sharedSecret = secp256k1.getSharedSecret(privateKey, publicKey)
   return sharedSecret.slice(0, 32)
 }