@zkpassport/sdk 0.2.1 → 0.2.3

package/src/json-rpc.ts

@@ -1,13 +1,13 @@
-import { randomBytes } from 'crypto'
-import type { JsonRpcRequest, JsonRpcResponse } from '@zkpassport/utils'
-import { encrypt } from './encryption'
-import { WebSocketClient } from './websocket'
-import logger from './logger'
+import { randomBytes } from "crypto"
+import type { JsonRpcRequest, JsonRpcResponse } from "@zkpassport/utils"
+import { encrypt } from "./encryption"
+import { WebSocketClient } from "./websocket"
+import { noLogger as logger } from "./logger"
 
 export function createJsonRpcRequest(method: string, params: any): JsonRpcRequest {
   return {
-    jsonrpc: '2.0',
-    id: randomBytes(16).toString('hex'),
+    jsonrpc: "2.0",
+    id: randomBytes(16).toString("hex"),
     method,
     params,
   }
@@ -24,8 +24,8 @@ export async function createEncryptedJsonRpcRequest(
     sharedSecret,
     topic,
   )
-  return createJsonRpcRequest('encryptedMessage', {
-    payload: Buffer.from(encryptedMessage).toString('base64'),
+  return createJsonRpcRequest("encryptedMessage", {
+    payload: Buffer.from(encryptedMessage).toString("base64"),
   })
 }
 
@@ -39,22 +39,22 @@ export async function sendEncryptedJsonRpcRequest(
   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: string, result: any): JsonRpcResponse {
   return {
-    jsonrpc: '2.0',
+    jsonrpc: "2.0",
     id,
     result,
   }

package/src/logger.ts

@@ -1,44 +1,13 @@
-// 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: string, ...args: any[]) => console.debug(message, ...args),
   info: (message: string, ...args: any[]) => console.info(message, ...args),
   warn: (message: string, ...args: any[]) => console.warn(message, ...args),
   error: (message: string, ...args: any[]) => console.error(message, ...args),
 }
 
-export default customLogger
+export const noLogger = {
+  debug: (..._: any[]) => {},
+  info: (..._: any[]) => {},
+  warn: (..._: any[]) => {},
+  error: (..._: any[]) => {},
+}

package/src/mobile.ts

@@ -1,9 +1,9 @@
-import { bytesToHex } from '@noble/ciphers/utils'
-import { getWebSocketClient, WebSocketClient } from './websocket'
-import { sendEncryptedJsonRpcRequest } from './json-rpc'
-import { decrypt, generateECDHKeyPair, getSharedSecret } from './encryption'
-import type { JsonRpcRequest } from '@zkpassport/utils'
-import logger from './logger'
+import { bytesToHex } from "@noble/ciphers/utils"
+import { getWebSocketClient, WebSocketClient } from "./websocket"
+import { sendEncryptedJsonRpcRequest } from "./json-rpc"
+import { decrypt, generateECDHKeyPair, getSharedSecret } from "./encryption"
+import type { JsonRpcRequest } from "@zkpassport/utils"
+import { noLogger as logger } from "./logger"
 
 export class ZkPassportProver {
   private domain?: string
@@ -29,12 +29,12 @@ export class ZkPassportProver {
     request: JsonRpcRequest,
     outerRequest: JsonRpcRequest,
   ) {
-    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
     }
   }
@@ -52,15 +52,15 @@ export class ZkPassportProver {
     } = {},
   ) {
     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())
@@ -85,7 +85,7 @@ export class ZkPassportProver {
     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(
@@ -97,8 +97,8 @@ export class ZkPassportProver {
       // )
     }
 
-    wsClient.addEventListener('message', async (event: any) => {
-      logger.info('[mobile] Received message:', event.data)
+    wsClient.addEventListener("message", async (event: any) => {
+      logger.info("[mobile] Received message:", event.data)
 
       try {
         const data: JsonRpcRequest = JSON.parse(event.data)
@@ -111,11 +111,11 @@ export class ZkPassportProver {
           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 {
@@ -124,16 +124,16 @@ export class ZkPassportProver {
             const decryptedJson: JsonRpcRequest = JSON.parse(decrypted)
             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: Event) => {
-      logger.error('[mobile] WebSocket error:', error)
+      logger.error("[mobile] WebSocket error:", error)
     }
 
     return {
@@ -147,7 +147,7 @@ export class ZkPassportProver {
         this.onBridgeConnectCallbacks[topic].push(callback),
       notifyReject: async () => {
         await sendEncryptedJsonRpcRequest(
-          'reject',
+          "reject",
           null,
           this.topicToSharedSecret[topic],
           topic,
@@ -156,7 +156,7 @@ export class ZkPassportProver {
       },
       notifyAccept: async () => {
         await sendEncryptedJsonRpcRequest(
-          'accept',
+          "accept",
           null,
           this.topicToSharedSecret[topic],
           topic,
@@ -165,7 +165,7 @@ export class ZkPassportProver {
       },
       notifyDone: async (proof: any) => {
         await sendEncryptedJsonRpcRequest(
-          'done',
+          "done",
           { proof },
           this.topicToSharedSecret[topic],
           topic,
@@ -174,7 +174,7 @@ export class ZkPassportProver {
       },
       notifyError: async (error: string) => {
         await sendEncryptedJsonRpcRequest(
-          'error',
+          "error",
           { error },
           this.topicToSharedSecret[topic],
           topic,

package/src/websocket.ts

@@ -1,15 +1,15 @@
 export function getWebSocketClient(url: string, origin?: string) {
-  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",
       },
-    }) as import('ws').WebSocket
+    }) as import("ws").WebSocket
   }
 }