@zkpassport/sdk 0.2.1 → 0.2.3

package/dist/cjs/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/cjs/json-rpc.js

@@ -4,44 +4,43 @@ exports.createJsonRpcRequest = createJsonRpcRequest;
 exports.createEncryptedJsonRpcRequest = createEncryptedJsonRpcRequest;
 exports.sendEncryptedJsonRpcRequest = sendEncryptedJsonRpcRequest;
 exports.createJsonRpcResponse = createJsonRpcResponse;
-const tslib_1 = require("tslib");
 const crypto_1 = require("crypto");
 const encryption_1 = require("./encryption");
-const logger_1 = tslib_1.__importDefault(require("./logger"));
+const logger_1 = require("./logger");
 function createJsonRpcRequest(method, params) {
     return {
-        jsonrpc: '2.0',
-        id: (0, crypto_1.randomBytes)(16).toString('hex'),
+        jsonrpc: "2.0",
+        id: (0, crypto_1.randomBytes)(16).toString("hex"),
         method,
         params,
     };
 }
 async function createEncryptedJsonRpcRequest(method, params, sharedSecret, topic) {
     const encryptedMessage = await (0, encryption_1.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"),
     });
 }
 async function sendEncryptedJsonRpcRequest(method, params, sharedSecret, topic, wsClient) {
     try {
         const message = { method, params: params || {} };
         const encryptedMessage = await (0, encryption_1.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_1.default.debug('Sending encrypted message (original):', message);
-        logger_1.default.debug('Sending encrypted message (encrypted):', request);
+        logger_1.noLogger.debug("Sending encrypted message (original):", message);
+        logger_1.noLogger.debug("Sending encrypted message (encrypted):", request);
         wsClient.send(JSON.stringify(request));
         return true;
     }
     catch (error) {
-        logger_1.default.error('Error sending encrypted message:', error);
+        logger_1.noLogger.error("Error sending encrypted message:", error);
         return false;
     }
 }
 function createJsonRpcResponse(id, result) {
     return {
-        jsonrpc: '2.0',
+        jsonrpc: "2.0",
         id,
         result,
     };

package/dist/cjs/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/cjs/logger.js

@@ -1,39 +1,15 @@
 "use strict";
-// import { createLogger, transports, format } from 'winston'
-// import colors from 'colors/safe'
-// import util from 'util'
 Object.defineProperty(exports, "__esModule", { value: true });
-// 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 = {
+exports.noLogger = exports.customLogger = void 0;
+exports.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),
 };
-exports.default = customLogger;
+exports.noLogger = {
+    debug: (..._) => { },
+    info: (..._) => { },
+    warn: (..._) => { },
+    error: (..._) => { },
+};

package/dist/cjs/mobile.js

@@ -1,12 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZkPassportProver = void 0;
-const tslib_1 = require("tslib");
 const utils_1 = require("@noble/ciphers/utils");
 const websocket_1 = require("./websocket");
 const json_rpc_1 = require("./json-rpc");
 const encryption_1 = require("./encryption");
-const logger_1 = tslib_1.__importDefault(require("./logger"));
+const logger_1 = require("./logger");
 class ZkPassportProver {
     constructor() {
         this.topicToKeyPair = {};
@@ -24,13 +23,13 @@ class ZkPassportProver {
      * @param outerRequest The outer request.
      */
     async handleEncryptedMessage(topic, request, outerRequest) {
-        logger_1.default.debug('Received encrypted message:', request);
-        if (request.method === 'hello') {
-            logger_1.default.info(`Successfully verified origin domain name: ${outerRequest.origin}`);
+        logger_1.noLogger.debug("Received encrypted message:", request);
+        if (request.method === "hello") {
+            logger_1.noLogger.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
         }
     }
@@ -40,13 +39,13 @@ 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 (0, encryption_1.generateECDHKeyPair)());
         this.topicToKeyPair[topic] = {
@@ -62,7 +61,7 @@ class ZkPassportProver {
         const wsClient = (0, websocket_1.getWebSocketClient)(`wss://bridge.zkpassport.id?topic=${topic}&pubkey=${(0, utils_1.bytesToHex)(keyPair.publicKey)}`);
         this.topicToWebSocketClient[topic] = wsClient;
         wsClient.onopen = async () => {
-            logger_1.default.info('[mobile] WebSocket connection established');
+            logger_1.noLogger.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(
@@ -73,20 +72,20 @@ class ZkPassportProver {
             //   ),
             // )
         };
-        wsClient.addEventListener('message', async (event) => {
-            logger_1.default.info('[mobile] Received message:', event.data);
+        wsClient.addEventListener("message", async (event) => {
+            logger_1.noLogger.info("[mobile] Received message:", event.data);
             try {
                 const data = JSON.parse(event.data);
                 const originDomain = data.origin ? new URL(data.origin).hostname : undefined;
                 // Origin domain must match domain in QR code
                 if (originDomain !== this.domain) {
-                    logger_1.default.warn(`[mobile] Origin does not match domain in QR code. Expected ${this.domain} but got ${originDomain}`);
+                    logger_1.noLogger.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
@@ -95,16 +94,16 @@ class ZkPassportProver {
                         await this.handleEncryptedMessage(topic, decryptedJson, data);
                     }
                     catch (error) {
-                        logger_1.default.error('[mobile] Error decrypting message:', error);
+                        logger_1.noLogger.error("[mobile] Error decrypting message:", error);
                     }
                 }
             }
             catch (error) {
-                logger_1.default.error('[mobile] Error:', error);
+                logger_1.noLogger.error("[mobile] Error:", error);
             }
         });
         wsClient.onerror = (error) => {
-            logger_1.default.error('[mobile] WebSocket error:', error);
+            logger_1.noLogger.error("[mobile] WebSocket error:", error);
         };
         return {
             domain: this.domain,
@@ -114,16 +113,16 @@ class ZkPassportProver {
             onDomainVerified: (callback) => this.onDomainVerifiedCallbacks[topic].push(callback),
             onBridgeConnect: (callback) => this.onBridgeConnectCallbacks[topic].push(callback),
             notifyReject: async () => {
-                await (0, json_rpc_1.sendEncryptedJsonRpcRequest)('reject', null, this.topicToSharedSecret[topic], topic, this.topicToWebSocketClient[topic]);
+                await (0, json_rpc_1.sendEncryptedJsonRpcRequest)("reject", null, this.topicToSharedSecret[topic], topic, this.topicToWebSocketClient[topic]);
             },
             notifyAccept: async () => {
-                await (0, json_rpc_1.sendEncryptedJsonRpcRequest)('accept', null, this.topicToSharedSecret[topic], topic, this.topicToWebSocketClient[topic]);
+                await (0, json_rpc_1.sendEncryptedJsonRpcRequest)("accept", null, this.topicToSharedSecret[topic], topic, this.topicToWebSocketClient[topic]);
             },
             notifyDone: async (proof) => {
-                await (0, json_rpc_1.sendEncryptedJsonRpcRequest)('done', { proof }, this.topicToSharedSecret[topic], topic, this.topicToWebSocketClient[topic]);
+                await (0, json_rpc_1.sendEncryptedJsonRpcRequest)("done", { proof }, this.topicToSharedSecret[topic], topic, this.topicToWebSocketClient[topic]);
             },
             notifyError: async (error) => {
-                await (0, json_rpc_1.sendEncryptedJsonRpcRequest)('error', { error }, this.topicToSharedSecret[topic], topic, this.topicToWebSocketClient[topic]);
+                await (0, json_rpc_1.sendEncryptedJsonRpcRequest)("error", { error }, this.topicToSharedSecret[topic], topic, this.topicToWebSocketClient[topic]);
             },
         };
     }

package/dist/cjs/websocket.js

@@ -2,16 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getWebSocketClient = getWebSocketClient;
 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/dist/esm/encryption.d.ts

@@ -1,7 +1,7 @@
 export declare function generateECDHKeyPair(): Promise<{
-    privateKey: import("@noble/secp256k1").Bytes;
-    publicKey: import("@noble/secp256k1").Bytes;
+    privateKey: Uint8Array;
+    publicKey: Uint8Array;
 }>;
-export declare function getSharedSecret(privateKey: string, publicKey: string): Promise<Uint8Array<ArrayBuffer>>;
-export declare function encrypt(message: string, sharedSecret: Uint8Array, topic: string): Promise<Uint8Array<ArrayBufferLike>>;
+export declare function getSharedSecret(privateKey: string, publicKey: string): Promise<Uint8Array>;
+export declare function encrypt(message: string, sharedSecret: Uint8Array, topic: string): Promise<Uint8Array>;
 export declare function decrypt(ciphertext: Uint8Array, sharedSecret: Uint8Array, topic: string): Promise<string>;

package/dist/esm/encryption.js

@@ -1,15 +1,15 @@
-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) {
     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 {
@@ -18,7 +18,7 @@ export async function generateECDHKeyPair() {
     };
 }
 export async function getSharedSecret(privateKey, publicKey) {
-    const secp256k1 = await import('@noble/secp256k1');
+    const secp256k1 = await import("@noble/secp256k1");
     const sharedSecret = secp256k1.getSharedSecret(privateKey, publicKey);
     return sharedSecret.slice(0, 32);
 }

package/dist/esm/index.d.ts

@@ -1,6 +1,6 @@
-import { type DisclosableIDCredential, type IDCredential, type IDCredentialValue, type NumericalIDCredential, type ProofResult, type QueryResult } from '@zkpassport/utils';
-export type * from '@zkpassport/utils';
-export { SANCTIONED_COUNTRIES, EU_COUNTRIES, EEA_COUNTRIES, SCHENGEN_COUNTRIES, ASEAN_COUNTRIES, MERCOSUR_COUNTRIES, } from '@zkpassport/utils';
+import { type DisclosableIDCredential, type IDCredential, type IDCredentialValue, type NumericalIDCredential, type ProofResult, type QueryResult } from "@zkpassport/utils";
+export type * from "@zkpassport/utils";
+export { SANCTIONED_COUNTRIES, EU_COUNTRIES, EEA_COUNTRIES, SCHENGEN_COUNTRIES, ASEAN_COUNTRIES, MERCOSUR_COUNTRIES, } from "@zkpassport/utils";
 export type QueryBuilderResult = {
     /**
      * The URL of the request.
@@ -85,13 +85,13 @@ export type QueryBuilder = {
      * @param key The attribute to compare.
      * @param value The value of the attribute you require.
      */
-    lte: <T extends 'birthdate' | 'expiry_date'>(key: T, value: IDCredentialValue<T>) => QueryBuilder;
+    lte: <T extends "birthdate" | "expiry_date">(key: T, value: IDCredentialValue<T>) => QueryBuilder;
     /**
      * Requires this attribute to be less than the provided value.
      * @param key The attribute to compare.
      * @param value The value of the attribute you require.
      */
-    lt: <T extends 'age'>(key: T, value: IDCredentialValue<T>) => QueryBuilder;
+    lt: <T extends "age">(key: T, value: IDCredentialValue<T>) => QueryBuilder;
     /**
      * Requires this attribute to be included in the provided range.
      * @param key The attribute to compare.
@@ -104,13 +104,13 @@ export type QueryBuilder = {
      * @param key The attribute to compare.
      * @param value The list of values to check inclusion against.
      */
-    in: <T extends 'nationality'>(key: T, value: IDCredentialValue<T>[]) => QueryBuilder;
+    in: <T extends "nationality">(key: T, value: IDCredentialValue<T>[]) => QueryBuilder;
     /**
      * Requires this attribute to be excluded from the provided list.
      * @param key The attribute to compare.
      * @param value The list of values to check exclusion against.
      */
-    out: <T extends 'nationality'>(key: T, value: IDCredentialValue<T>[]) => QueryBuilder;
+    out: <T extends "nationality">(key: T, value: IDCredentialValue<T>[]) => QueryBuilder;
     /**
      * Requires this attribute to be disclosed.
      * @param key The attribute to disclose.