@lumiapassport/ui-kit 1.4.6 → 1.4.8

package/dist/index.js

@@ -750,41 +750,34 @@ var init_passkey = __esm({
 });
 
 // src/internal/lib/iframe-mpc-client.ts
+import { logSdkError } from "@lumiapassport/core/internal/error-tracking";
 async function ensureDkgAndGetOwner(userId, _clientSeedHex) {
   try {
-    console.info("[IframeMPC][DKG] Starting DKG via iframe for user:", userId);
     const iframeManager = getIframeManager();
     const keyshareStatus = await iframeManager.checkKeyshare(userId);
     if (keyshareStatus.hasKeyshare && keyshareStatus.address) {
-      console.info("[IframeMPC][DKG] User already has keyshare in iframe:", {
-        userId,
-        address: keyshareStatus.address
-      });
       return {
         sessionId: "iframe-session",
         ownerAddress: keyshareStatus.address
       };
     }
-    console.info("[IframeMPC][DKG] Authenticating user with iframe...");
     await iframeManager.authenticate(userId);
     const { jwtTokenManager: jwtTokenManager3 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
     const accessToken = jwtTokenManager3.getAccessToken();
     if (!accessToken) {
       throw new Error("No access token available for DKG");
     }
-    console.info("[IframeMPC][DKG] Starting DKG in iframe...");
     const ownerAddress = await iframeManager.startDKG(userId, accessToken);
-    console.info("[IframeMPC][DKG] \u2705 DKG completed successfully:", {
-      userId,
-      ownerAddress,
-      note: "Key share is securely stored in iframe localStorage at auth.lumiapassport.com"
-    });
     return {
       sessionId: "iframe-session",
       ownerAddress
     };
   } catch (error) {
-    console.error("[IframeMPC][DKG] Error in ensureDkgAndGetOwner:", error);
+    logSdkError(
+      error instanceof Error ? error : new Error("DKG failed"),
+      { userId },
+      "iframe-mpc"
+    );
     throw error;
   }
 }
@@ -795,11 +788,6 @@ async function signDigestWithMpc(userId, digest32, userOpDetails) {
     rounds: []
   };
   try {
-    console.info("[IframeMPC][Sign] Starting signature via iframe:", {
-      userId,
-      digest32: `${digest32.substring(0, 20)}...`,
-      hasDetails: !!userOpDetails
-    });
     const iframeManager = getIframeManager();
     const { jwtTokenManager: jwtTokenManager3 } = await Promise.resolve().then(() => (init_auth(), auth_exports));
     const accessToken = jwtTokenManager3.getAccessToken();
@@ -819,14 +807,13 @@ async function signDigestWithMpc(userId, digest32, userOpDetails) {
     const endTime = performance.now();
     currentSigningStats.endTime = endTime;
     currentSigningStats.totalDurationMs = endTime - startTime;
-    console.info("[IframeMPC][Sign] \u2705 Signature obtained from iframe:", {
-      signature: `${signature.substring(0, 20)}...`,
-      duration: `${(endTime - startTime).toFixed(2)}ms`,
-      note: "All signing operations happened securely inside iframe"
-    });
     return signature;
   } catch (error) {
-    console.error("[IframeMPC][Sign] Error in signDigestWithMpc:", error);
+    logSdkError(
+      error instanceof Error ? error : new Error("MPC signing failed"),
+      { userId, hasUserOpDetails: !!userOpDetails },
+      "iframe-mpc"
+    );
     const endTime = performance.now();
     if (currentSigningStats) {
       currentSigningStats.endTime = endTime;
@@ -853,6 +840,7 @@ var init_iframe_mpc_client = __esm({
 });
 
 // src/internal/clients/httpClient.ts
+import { logSdkError as logSdkError2 } from "@lumiapassport/core/internal/error-tracking";
 function createHttpClient(baseUrl) {
   return new HttpClient(baseUrl);
 }
@@ -891,14 +879,11 @@ var init_httpClient = __esm({
         if (body && method !== "GET") {
           requestConfig.body = typeof body === "string" ? body : JSON.stringify(body);
         }
-        console.log(`[HttpClient] Making ${method} request to: ${url}`);
         try {
           const response = await fetch(url, requestConfig);
           if (response.status === 401 && requireAuth) {
-            console.log("[HttpClient] Got 401, attempting token refresh...");
             const refreshSuccess = await jwtTokenManager2.refreshAccessToken();
             if (refreshSuccess) {
-              console.log("[HttpClient] Token refreshed, retrying request...");
               const newAccessToken = jwtTokenManager2.getAccessToken();
               if (newAccessToken) {
                 requestHeaders["Authorization"] = `Bearer ${newAccessToken}`;
@@ -907,7 +892,6 @@ var init_httpClient = __esm({
               const retryResponse = await fetch(url, requestConfig);
               return await this.processResponse(retryResponse);
             } else {
-              console.error("[HttpClient] Token refresh failed");
               return {
                 success: false,
                 error: "Authentication failed - unable to refresh token",
@@ -917,7 +901,11 @@ var init_httpClient = __esm({
           }
           return await this.processResponse(response);
         } catch (error) {
-          console.error(`[HttpClient] Request failed:`, error);
+          logSdkError2(
+            error instanceof Error ? error : new Error("Network error"),
+            { url, method },
+            "http-client"
+          );
           return {
             success: false,
             error: error instanceof Error ? error.message : "Network error",
@@ -930,7 +918,6 @@ var init_httpClient = __esm({
         try {
           const data = await response.json();
           if (!response.ok) {
-            console.log(`[HttpClient] Request failed with status ${status}:`, data);
             return {
               success: false,
               error: data.message || data.error || `HTTP ${status}`,
@@ -938,14 +925,17 @@ var init_httpClient = __esm({
               data
             };
           }
-          console.log(`[HttpClient] Request successful (${status})`);
           return {
             success: true,
             data,
             status
           };
         } catch (parseError) {
-          console.error("[HttpClient] Failed to parse response:", parseError);
+          logSdkError2(
+            parseError instanceof Error ? parseError : new Error("Failed to parse response"),
+            { status },
+            "http-client"
+          );
           return {
             success: false,
             error: "Invalid response format",
@@ -1037,11 +1027,9 @@ var init_cloudStorage = __esm({
             discoveryDocs: [this.DISCOVERY_DOC]
           });
           this.gapiInitialized = true;
-          console.log("[GoogleDrive] Google API client initialized");
         }
         if (!this.gisInitialized) {
           this.gisInitialized = true;
-          console.log("[GoogleDrive] Google Identity Services initialized");
         }
       }
       loadScript(src) {
@@ -1080,7 +1068,6 @@ var init_cloudStorage = __esm({
                 }
                 this.accessToken = response.access_token;
                 window.gapi.client.setToken({ access_token: this.accessToken });
-                console.log("[GoogleDrive] Successfully authenticated");
                 resolve(true);
               }
             });
@@ -1099,7 +1086,6 @@ var init_cloudStorage = __esm({
           window.google?.accounts.oauth2.revoke(this.accessToken);
           this.accessToken = null;
           window.gapi?.client.setToken(null);
-          console.log("[GoogleDrive] Signed out successfully");
         }
       }
       async upload(fileName, content, usePrivateStorage = true) {
@@ -1110,18 +1096,15 @@ var init_cloudStorage = __esm({
         if (usePrivateStorage) {
           try {
             const fileId = await this.uploadToAppDataFolder(fileName, content);
-            console.log("[GoogleDrive] File uploaded to appDataFolder successfully:", fileId);
             return fileId;
           } catch (error) {
             console.warn("[GoogleDrive] AppDataFolder upload failed, trying fallback to regular folder:", error);
             const fileId = await this.uploadToAppFolder(fileName, content);
-            console.log("[GoogleDrive] File uploaded to app folder successfully:", fileId);
             return fileId;
           }
         } else {
           try {
             const fileId = await this.uploadToAppFolder(fileName, content);
-            console.log("[GoogleDrive] File uploaded to app folder successfully:", fileId);
             return fileId;
           } catch (error) {
             console.error("[GoogleDrive] Upload failed:", error);
@@ -1177,7 +1160,6 @@ var init_cloudStorage = __esm({
           throw new Error(`Failed to create folder: ${createResponse.status}`);
         }
         const createResult = await createResponse.json();
-        console.log(`[GoogleDrive] Created folder '${folderName}':`, createResult.id);
         return createResult.id;
       }
       async performUpload(metadata, content) {
@@ -1232,6 +1214,7 @@ __export(vaultClient_exports, {
   updateBackupStatus: () => updateBackupStatus,
   uploadShare: () => uploadShare
 });
+import { logSdkError as logSdkError3 } from "@lumiapassport/core/internal/error-tracking";
 function getBackupEncryptionMethod(backupFile) {
   if (backupFile.encryptionMethod) return backupFile.encryptionMethod;
   return "unknown";
@@ -1307,11 +1290,8 @@ async function deleteShare() {
   if (!response.ok && response.status !== 404) throw new Error(`Failed to delete share: ${response.status} ${response.statusText}`);
 }
 async function deriveKEKFromPasskey(userId, requiredCredentialId) {
-  console.log("[deriveKEKFromPasskey] Starting passkey derivation for userId:", userId);
-  console.log("[deriveKEKFromPasskey] Required credential ID:", requiredCredentialId);
   const challengeString = `lumia-kek:${userId}`;
   const challenge = new TextEncoder().encode(challengeString);
-  console.log("[deriveKEKFromPasskey] Challenge string:", challengeString);
   function base64urlToUint8Array3(base64url) {
     const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
     const pad = base64.length % 4 ? 4 - base64.length % 4 : 0;
@@ -1324,14 +1304,8 @@ async function deriveKEKFromPasskey(userId, requiredCredentialId) {
     return bytes;
   }
   const targetCredentialId = requiredCredentialId || createPasskeyHelpers(userId).getCredId();
-  console.log("[deriveKEKFromPasskey] Target credential ID:", targetCredentialId);
   const allowCredentials = targetCredentialId ? [{ id: base64urlToUint8Array3(targetCredentialId), type: "public-key" }] : [];
-  console.log("[deriveKEKFromPasskey] Using allowCredentials:", allowCredentials.length > 0 ? "specific credential" : "any credential");
-  if (!targetCredentialId) {
-    console.warn("[deriveKEKFromPasskey] Warning: No credential ID available. User must select the correct passkey manually.");
-  }
   try {
-    console.log("[deriveKEKFromPasskey] Calling navigator.credentials.get...");
     const credential = await navigator.credentials.get({
       publicKey: {
         challenge,
@@ -1340,27 +1314,22 @@ async function deriveKEKFromPasskey(userId, requiredCredentialId) {
         extensions: { prf: { eval: { first: challenge } } }
       }
     });
-    console.log("[deriveKEKFromPasskey] Credential received:", !!credential);
     if (credential) {
-      console.log("[deriveKEKFromPasskey] Credential ID:", credential.id);
-      console.log("[deriveKEKFromPasskey] Credential ID length:", credential.id.length);
       const extensionResults = credential.getClientExtensionResults?.();
-      console.log("[deriveKEKFromPasskey] Extension results:", extensionResults);
       if (extensionResults?.prf?.results?.first) {
-        console.log("[deriveKEKFromPasskey] PRF result found, returning KEK");
-        console.log("[deriveKEKFromPasskey] PRF result length:", extensionResults.prf.results.first.byteLength);
         return extensionResults.prf.results.first;
       }
     }
-    console.log("[deriveKEKFromPasskey] No PRF result, falling back to HKDF...");
     const credentialIdBytes = new TextEncoder().encode(credential.id);
-    console.log("[deriveKEKFromPasskey] Credential ID length:", credential.id.length);
     const keyMaterial = await crypto.subtle.importKey("raw", credentialIdBytes, "HKDF", false, ["deriveBits"]);
     const kekBytes = await crypto.subtle.deriveBits({ name: "HKDF", hash: "SHA-256", salt: challenge, info: new TextEncoder().encode("client-share") }, keyMaterial, 256);
-    console.log("[deriveKEKFromPasskey] HKDF fallback completed successfully");
     return kekBytes;
   } catch (error) {
-    console.error("[deriveKEKFromPasskey] Error during passkey operation:", error);
+    logSdkError3(
+      error instanceof Error ? error : new Error("Passkey operation failed"),
+      { userId },
+      "vault"
+    );
     throw error;
   }
 }
@@ -1445,7 +1414,6 @@ async function deriveBackupPasswordFromPasskey(userId, credentialId) {
         type: "public-key",
         transports: ["internal", "hybrid"]
       }];
-      console.log("[deriveBackupPasswordFromPasskey] Using specific credential ID:", credentialId);
     } catch (error) {
       console.warn("[deriveBackupPasswordFromPasskey] Failed to parse credentialId, falling back to open selection:", error);
     }
@@ -1525,7 +1493,6 @@ async function downloadShareFromVault(token) {
 async function envelopeEncryptKeyshare(data, userId) {
   const passkeyHelpers = createPasskeyHelpers(userId);
   const credentialId = passkeyHelpers.getCredId();
-  console.log("[envelopeEncryptKeyshare] Using credential ID for encryption:", credentialId);
   const dek = crypto.getRandomValues(new Uint8Array(32));
   const kekBytes = await deriveKEKFromPasskey(userId);
   const kek = await crypto.subtle.importKey("raw", kekBytes, "AES-GCM", false, ["encrypt"]);
@@ -1557,7 +1524,6 @@ async function envelopeEncryptKeyshare(data, userId) {
   };
 }
 async function envelopeEncryptKeyshareWithPassword(data, password) {
-  console.log("[envelopeEncryptKeyshareWithPassword] Encrypting with password");
   const dek = crypto.getRandomValues(new Uint8Array(32));
   const salt = crypto.getRandomValues(new Uint8Array(16));
   const kekKey = await deriveKeyFromPassword(password, salt);
@@ -1588,39 +1554,27 @@ async function envelopeEncryptKeyshareWithPassword(data, password) {
   };
 }
 async function envelopeDecryptKeyshare(envelope, userId) {
-  console.log("[envelopeDecryptKeyshare] Starting decryption process");
-  console.log("[envelopeDecryptKeyshare] Envelope credential ID:", envelope.credentialId);
-  console.log("[envelopeDecryptKeyshare] Deriving KEK from passkey...");
   const kekBytes = await deriveKEKFromPasskey(userId, envelope.credentialId);
-  console.log("[envelopeDecryptKeyshare] KEK bytes length:", kekBytes.byteLength);
-  console.log("[envelopeDecryptKeyshare] Importing KEK as crypto key...");
   const kek = await crypto.subtle.importKey("raw", kekBytes, "AES-GCM", false, ["decrypt"]);
-  console.log("[envelopeDecryptKeyshare] Decrypting wrapped DEK...");
   const wrappedDekWithIv = base64ToBytes(envelope.wrapped_dek);
-  console.log("[envelopeDecryptKeyshare] Wrapped DEK with IV length:", wrappedDekWithIv.length);
   const wrapIv = wrappedDekWithIv.slice(0, 12);
   const wrappedDekData = wrappedDekWithIv.slice(12);
-  console.log("[envelopeDecryptKeyshare] Wrap IV length:", wrapIv.length, "Wrapped DEK data length:", wrappedDekData.length);
   try {
     const dekBytes = await crypto.subtle.decrypt({ name: "AES-GCM", iv: wrapIv }, kek, wrappedDekData);
-    console.log("[envelopeDecryptKeyshare] DEK decrypted successfully, length:", dekBytes.byteLength);
-    console.log("[envelopeDecryptKeyshare] Importing DEK as crypto key...");
     const dekCryptoKey = await crypto.subtle.importKey("raw", dekBytes, "AES-GCM", false, ["decrypt"]);
-    console.log("[envelopeDecryptKeyshare] Decrypting main data...");
     const ciphertextWithIv = base64ToBytes(envelope.ciphertext_share);
-    console.log("[envelopeDecryptKeyshare] Ciphertext with IV length:", ciphertextWithIv.length);
     const dataIv = ciphertextWithIv.slice(0, 12);
     const encryptedData = ciphertextWithIv.slice(12);
-    console.log("[envelopeDecryptKeyshare] Data IV length:", dataIv.length, "Encrypted data length:", encryptedData.length);
     const decryptedData = await crypto.subtle.decrypt({ name: "AES-GCM", iv: dataIv }, dekCryptoKey, encryptedData);
-    console.log("[envelopeDecryptKeyshare] Main data decrypted successfully, length:", decryptedData.byteLength);
-    console.log("[envelopeDecryptKeyshare] Parsing JSON...");
     const plaintext = new TextDecoder().decode(decryptedData);
     const result = JSON.parse(plaintext);
-    console.log("[envelopeDecryptKeyshare] Decryption completed successfully");
     return result;
   } catch (error) {
-    console.error("[envelopeDecryptKeyshare] Decryption failed:", error);
+    logSdkError3(
+      error instanceof Error ? error : new Error("Envelope decryption failed"),
+      { hasCredentialId: !!envelope.credentialId },
+      "vault"
+    );
     if (error instanceof Error && error.name === "OperationError") {
       const credentialHint = envelope.credentialId ? `The backup requires a specific passkey (ID: ${envelope.credentialId.slice(-8)}...)` : "The backup was encrypted with a different passkey than the one you selected";
       throw new Error(`Passkey mismatch: ${credentialHint}. If you have multiple passkeys, please try again and select the correct passkey that was used when creating this backup.`);
@@ -1629,28 +1583,27 @@ async function envelopeDecryptKeyshare(envelope, userId) {
   }
 }
 async function envelopeDecryptKeyshareWithPassword(envelope, password) {
-  console.log("[envelopeDecryptKeyshareWithPassword] Starting password-based decryption");
   const wrappedDekWithSaltAndIv = base64ToBytes(envelope.wrapped_dek);
   const salt = wrappedDekWithSaltAndIv.slice(0, 16);
   const wrapIv = wrappedDekWithSaltAndIv.slice(16, 28);
   const wrappedDekData = wrappedDekWithSaltAndIv.slice(28);
-  console.log("[envelopeDecryptKeyshareWithPassword] Salt length:", salt.length, "Wrap IV length:", wrapIv.length, "Wrapped DEK data length:", wrappedDekData.length);
   try {
     const kekKey = await deriveKeyFromPassword(password, salt);
     const dekBytes = await crypto.subtle.decrypt({ name: "AES-GCM", iv: wrapIv }, kekKey, wrappedDekData);
-    console.log("[envelopeDecryptKeyshareWithPassword] DEK decrypted successfully, length:", dekBytes.byteLength);
     const dekCryptoKey = await crypto.subtle.importKey("raw", dekBytes, "AES-GCM", false, ["decrypt"]);
     const ciphertextWithIv = base64ToBytes(envelope.ciphertext_share);
     const dataIv = ciphertextWithIv.slice(0, 12);
     const encryptedData = ciphertextWithIv.slice(12);
     const decryptedData = await crypto.subtle.decrypt({ name: "AES-GCM", iv: dataIv }, dekCryptoKey, encryptedData);
-    console.log("[envelopeDecryptKeyshareWithPassword] Main data decrypted successfully");
     const plaintext = new TextDecoder().decode(decryptedData);
     const result = JSON.parse(plaintext);
-    console.log("[envelopeDecryptKeyshareWithPassword] Decryption completed successfully");
     return result;
   } catch (error) {
-    console.error("[envelopeDecryptKeyshareWithPassword] Decryption failed:", error);
+    logSdkError3(
+      error instanceof Error ? error : new Error("Password decryption failed"),
+      { errorName: error instanceof Error ? error.name : "unknown" },
+      "vault"
+    );
     if (error instanceof Error && error.name === "OperationError") {
       throw new Error("Incorrect password: Unable to decrypt the backup with the provided password.");
     }
@@ -1670,22 +1623,15 @@ async function backupToServer(userId, password) {
   updateBackupStatus(userId, "server", { enabled: true, lastBackup: Date.now(), error: void 0 });
 }
 async function restoreFromServer(userId, password = null) {
-  console.log("[restoreFromServer] Starting restore for userId:", userId);
-  console.log("[restoreFromServer] Using password:", !!password);
-  console.log("[restoreFromServer] Getting vault token...");
   const vaultToken = await getShareVaultToken(["share:get"]);
-  console.log("[restoreFromServer] Downloading share from vault...");
   const envelope = await downloadShareFromVault(vaultToken.token);
-  console.log("[restoreFromServer] Envelope encryption method:", envelope.encryptionMethod);
   const backupData = password ? await envelopeDecryptKeyshareWithPassword(envelope, password) : await envelopeDecryptKeyshare(envelope, userId);
   if (backupData.userId !== userId) throw new Error("Server backup does not match current user");
   const storage = typeof window !== "undefined" ? window.localStorage : void 0;
   if (!storage) throw new Error("localStorage not available");
-  console.log("[restoreFromServer] Saving keyshare to localStorage...");
   storage.setItem(`tss.${userId}.keyshare`, backupData.keyshare);
   storage.setItem(`tss.${userId}.sessionId`, backupData.sessionId);
   storage.setItem(`tss.${userId}.ownerAddress`, backupData.ownerAddress);
-  console.log("[restoreFromServer] Restore completed successfully");
 }
 async function restoreFromBackup(file, password, userId) {
   const fileContent = await file.text();
@@ -1731,7 +1677,11 @@ function getCurrentKeyshareBackupData(userId) {
       version: BACKUP_VERSION
     };
   } catch (error) {
-    console.error("[BACKUP] Error getting keyshare data:", error);
+    logSdkError3(
+      error instanceof Error ? error : new Error("Failed to get keyshare data"),
+      { userId },
+      "vault"
+    );
     return null;
   }
 }
@@ -1751,7 +1701,6 @@ async function backupToLocalFile(userId, password) {
     });
     backupPassword = result.password;
     credentialId = result.credentialId;
-    console.log("[backupToLocalFile] Using credential ID from passkey:", credentialId);
   }
   const encryptedBackup = await encryptKeyshare(backupData, backupPassword, encryptionMethod, credentialId);
   const fileName = `lumia-keyshare-backup-${userId}-${Date.now()}.json`;
@@ -1784,7 +1733,6 @@ async function backupToCloud(userId, password, providerId, usePrivateStorage = t
     });
     backupPassword = result.password;
     credentialId = result.credentialId;
-    console.log("[backupToCloud] Using credential ID from passkey:", credentialId);
   }
   const encryptedBackup = await encryptKeyshare(backupData, backupPassword, encryptionMethod, credentialId);
   const timestamp = Date.now();
@@ -1815,9 +1763,12 @@ async function backupToCloud(userId, password, providerId, usePrivateStorage = t
     console.info(`[BACKUP] Uploading backup to ${provider.name}`);
     const fileId = await provider.upload(fileName, fileContent, usePrivateStorage);
     updateBackupStatus(userId, "cloud", { enabled: true, lastBackup: timestamp, error: void 0 });
-    console.info(`[BACKUP] Successfully uploaded backup to ${provider.name}, file ID: ${fileId}`);
   } catch (error) {
-    console.error(`[BACKUP] Cloud backup failed:`, error);
+    logSdkError3(
+      error instanceof Error ? error : new Error("Cloud backup failed"),
+      { userId, providerId },
+      "vault"
+    );
     const errorMsg = error instanceof Error ? error.message : "Cloud backup failed";
     updateBackupStatus(userId, "cloud", { error: errorMsg });
     throw new Error(errorMsg);
@@ -2960,6 +2911,7 @@ var init_iframe_manager = __esm({
 
 // src/context/LumiaPassportContext.tsx
 import { createContext, useCallback, useContext, useEffect, useState } from "react";
+import { initSdkErrorTracking } from "@lumiapassport/core/internal/error-tracking";
 import { jsx as jsx3 } from "react/jsx-runtime";
 var LumiaPassportContext, LumiaPassportProvider, useLumiaPassportConfig;
 var init_LumiaPassportContext = __esm({
@@ -3025,6 +2977,13 @@ var init_LumiaPassportContext = __esm({
           }
         } catch {
         }
+        try {
+          initSdkErrorTracking();
+        } catch (error) {
+          if (process.env.NODE_ENV === "development") {
+            console.warn("[LumiaPassport] Failed to initialize SDK error tracking:", error);
+          }
+        }
         return merged;
       });
       const updateConfig = useCallback((updates) => {
@@ -4091,25 +4050,19 @@ var init_VerificationCodeInput = __esm({
 
 // src/internal/clients/profile.ts
 async function getUserProfile() {
-  console.log("[ProfileClient] Fetching user profile...");
   const response = await tssClient.get("/api/auth/profile", true);
   if (!response.success || !response.data) {
     const error = response.error || "Failed to fetch user profile";
-    console.error("[ProfileClient] Failed to fetch profile:", error);
     throw new Error(error);
   }
-  console.log("[ProfileClient] Profile fetched successfully:", response.data);
   return response.data;
 }
 async function updateUserProfile(updates) {
-  console.log("[ProfileClient] Updating user profile:", updates);
   const response = await tssClient.patch("/api/auth/profile", updates, true);
   if (!response.success || !response.data) {
     const error = response.error || "Failed to update user profile";
-    console.error("[ProfileClient] Failed to update profile:", error);
     throw new Error(error);
   }
-  console.log("[ProfileClient] Profile updated successfully:", response.data);
   return response.data;
 }
 var init_profile = __esm({
@@ -5293,10 +5246,7 @@ async function sendUserOperation(session, callTarget, amountWei, innerData = "0x
         paymasterAndData = `0x${paymasterAddr}${packedPaymasterGasLimits.slice(2)}${paymasterDataClean}`;
       }
       const packedForHash = { sender: session.smartAccountAddress, nonce: BigInt(nonce2), initCode, callData, accountGasLimits, preVerificationGas: BigInt(userOp.preVerificationGas), gasFees, paymasterAndData, signature: "0x" };
-      console.log("[Account] Computing hash for signing with sender:", session.smartAccountAddress);
-      console.log("[Account] PackedForHash for hash computation:", JSON.stringify(packedForHash, (key, value) => typeof value === "bigint" ? `0x${value.toString(16)}` : value, 2));
       opHash = await publicClient.readContract({ address: entryPointAddress, abi: entryPoint07Abi, functionName: "getUserOpHash", args: [packedForHash] });
-      console.log("[Account] \u{1F511} HASH FOR SIGNING:", opHash);
     }
     let signature;
     if (session.mpcUserId) {
@@ -5324,10 +5274,8 @@ async function sendUserOperation(session, callTarget, amountWei, innerData = "0x
     }
     userOp.signature = signature;
     if (typeof userOp.sender !== "string") {
-      console.error("[Account] CRITICAL ERROR: userOp.sender is not a string!", userOp.sender);
       userOp.sender = session.smartAccountAddress;
     }
-    console.log("[Account] \u2705 Final UserOp before sending:", JSON.stringify(userOp, (key, value) => typeof value === "bigint" ? `0x${value.toString(16)}` : value, 2));
     return userOp;
   };
   try {
@@ -5542,8 +5490,6 @@ async function prepareUserOperation(session, callTarget, amountWei, innerData =
   if (typeof userOp.sender !== "string") {
     userOp.sender = session.smartAccountAddress;
   }
-  console.log("[Account] \u2705 Prepared signed UserOp (not sent):", JSON.stringify(userOp, (key, value) => typeof value === "bigint" ? `0x${value.toString(16)}` : value, 2));
-  console.log("[Account] \u{1F511} UserOp Hash:", opHash);
   if (entryPointVersion === "v0.6") {
     const userOpV06 = convertUserOpV07ToV06(userOp);
     return { userOp: userOpV06, userOpHash: opHash };
@@ -8566,7 +8512,7 @@ function useLumiaPassportLinkedProfiles() {
 // package.json
 var package_default = {
   name: "@lumiapassport/ui-kit",
-  version: "1.4.5",
+  version: "1.4.8",
   description: "React UI components and hooks for Lumia Passport authentication and Account Abstraction",
   type: "module",
   main: "./dist/index.cjs",
@@ -8617,6 +8563,7 @@ var package_default = {
   dependencies: {
     "@lumiapassport/core": "workspace:*",
     "@rainbow-me/rainbowkit": "^2.2.8",
+    "@sentry/browser": "^10.22.0",
     "lucide-react": "^0.454.0",
     qrcode: "^1.5.0"
   },