@volr/react 0.1.111 → 0.1.113

package/dist/index.js

@@ -19401,6 +19401,11 @@ function useDepositListener(input) {
   }, [getRpcUrl, input.chainId, input.address, JSON.stringify(input.asset)]);
   return status;
 }
+function debugLog(step, data) {
+  {
+    console.log(`[PasskeyEnrollment] ${step}`, data !== void 0 ? data : "");
+  }
+}
 function blobToBase64(blob) {
   return new Promise((resolve, reject) => {
     const reader = new FileReader();
@@ -19448,6 +19453,14 @@ function buildDisplayName(userEmail, userEvmAddress, userId) {
   return userId || "Volr Wallet";
 }
 async function enrollPasskey(params) {
+  debugLog("Starting enrollment with params:", {
+    userId: params.userId,
+    projectId: params.projectId,
+    rpId: params.rpId,
+    rpName: params.rpName,
+    userEmail: params.userEmail,
+    userEvmAddress: params.userEvmAddress
+  });
   const {
     client,
     baseUrl,
@@ -19459,6 +19472,7 @@ async function enrollPasskey(params) {
     rpId = typeof window !== "undefined" ? window.location.hostname : "localhost",
     rpName
   } = params;
+  debugLog("Step 0: Validating parameters");
   if (!userId) {
     throw new Error("userId is required");
   }
@@ -19474,19 +19488,27 @@ async function enrollPasskey(params) {
   if (!apiKey) {
     throw new Error("apiKey is required");
   }
+  debugLog("Step 0: Parameters validated", { rpId, rpName });
+  debugLog("Step 1: Checking WebAuthn support");
   if (!navigator.credentials || !navigator.credentials.create) {
     throw new Error("WebAuthn API is not supported");
   }
+  debugLog("Step 1: WebAuthn API is supported");
   const challenge2 = new Uint8Array(32);
   crypto.getRandomValues(challenge2);
+  debugLog("Step 1: Challenge generated", { challengeLength: challenge2.length });
   const userHandle = new TextEncoder().encode(userId);
+  debugLog("Step 1: User handle created", { userHandleLength: userHandle.length });
   const tempCredentialId = "temp-" + Date.now();
   const tempPrfInput = {
     projectId,
     credentialId: tempCredentialId
   };
+  debugLog("Step 1: Temp PRF input created", tempPrfInput);
   const prfSalt = deriveWrapKey(tempPrfInput);
+  debugLog("Step 1: PRF salt derived", { prfSaltLength: prfSalt.length });
   const displayName = buildDisplayName(userEmail, userEvmAddress, userId);
+  debugLog("Step 1: Display name built", { displayName });
   const publicKeyCredentialCreationOptions = {
     challenge: challenge2,
     rp: {
@@ -19510,37 +19532,105 @@ async function enrollPasskey(params) {
       }
     }
   };
-  const credential = await navigator.credentials.create({
-    publicKey: publicKeyCredentialCreationOptions
+  debugLog("Step 1: WebAuthn options prepared", {
+    rpId: publicKeyCredentialCreationOptions.rp.id,
+    rpName: publicKeyCredentialCreationOptions.rp.name,
+    timeout: publicKeyCredentialCreationOptions.timeout,
+    attestation: publicKeyCredentialCreationOptions.attestation,
+    authenticatorSelection: publicKeyCredentialCreationOptions.authenticatorSelection,
+    pubKeyCredParams: publicKeyCredentialCreationOptions.pubKeyCredParams
   });
+  debugLog("Step 1: Calling navigator.credentials.create()...");
+  let credential;
+  try {
+    credential = await navigator.credentials.create({
+      publicKey: publicKeyCredentialCreationOptions
+    });
+    debugLog("Step 1: Credential creation completed", {
+      hasCredential: !!credential,
+      credentialId: credential ? Array.from(new Uint8Array(credential.rawId)).slice(0, 8).join(",") + "..." : null
+    });
+  } catch (err) {
+    debugLog("Step 1: Credential creation FAILED", {
+      error: err,
+      errorMessage: err instanceof Error ? err.message : String(err),
+      errorName: err instanceof Error ? err.name : "Unknown"
+    });
+    throw err;
+  }
   if (!credential || !("response" in credential)) {
+    debugLog("Step 1: Invalid credential response", { credential });
     throw new Error("Failed to create passkey credential");
   }
   const credentialId = Array.from(new Uint8Array(credential.rawId)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  debugLog("Step 2: Credential ID extracted", { credentialIdLength: credentialId.length, credentialIdPrefix: credentialId.slice(0, 16) });
+  debugLog("Step 2: Extracting PRF output");
   const extensionResults = credential.getClientExtensionResults();
+  debugLog("Step 2: Extension results", {
+    hasExtensionResults: !!extensionResults,
+    hasPrf: !!extensionResults.prf,
+    hasPrfResults: !!(extensionResults.prf && extensionResults.prf.results),
+    hasPrfFirst: !!(extensionResults.prf && extensionResults.prf.results && extensionResults.prf.results.first),
+    allKeys: Object.keys(extensionResults)
+  });
   if (!extensionResults.prf || !extensionResults.prf.results || !extensionResults.prf.results.first) {
+    debugLog("Step 2: PRF extension not supported or missing", extensionResults);
     throw new Error("PRF extension not supported or PRF output missing. Please use a browser that supports WebAuthn PRF extension.");
   }
   const prfOutputBuffer = extensionResults.prf.results.first;
   const prfOutput = new Uint8Array(prfOutputBuffer);
+  debugLog("Step 2: PRF output extracted", { prfOutputLength: prfOutput.length });
   const prfInput = {
     projectId,
     credentialId
   };
+  debugLog("Step 3: PRF input built", prfInput);
   const wrapKey = prfOutput;
+  debugLog("Step 4: Wrap key created from PRF output", { wrapKeyLength: wrapKey.length });
+  debugLog("Step 4: Generating master key...");
   const masterKeyProvider = createMasterKeyProvider();
-  const masterSeedHandle = await masterKeyProvider.generate();
+  let masterKeyHandle;
+  try {
+    masterKeyHandle = await masterKeyProvider.generate();
+    debugLog("Step 4: Master key generated", {
+      hasEntropy: !!masterKeyHandle.entropy,
+      entropyLength: masterKeyHandle.entropy?.length,
+      hasSeed: !!masterKeyHandle.seed,
+      seedLength: masterKeyHandle.seed?.length
+    });
+  } catch (err) {
+    debugLog("Step 4: Master key generation FAILED", {
+      error: err,
+      errorMessage: err instanceof Error ? err.message : String(err)
+    });
+    throw err;
+  }
   try {
     const keyStorageType = "passkey";
     const version5 = "v1";
     const aadBytes = new TextEncoder().encode(
       `volr/master-seed/v1|${userId}|${keyStorageType}|${version5}`
     );
-    const encryptedBlob = await sealMasterSeed(
-      masterSeedHandle.bytes,
-      wrapKey,
-      aadBytes
-    );
+    debugLog("Step 4: AAD built", { aadLength: aadBytes.length });
+    debugLog("Step 4: Encrypting entropy...");
+    let encryptedBlob;
+    try {
+      encryptedBlob = await sealMasterSeed(
+        masterKeyHandle.entropy,
+        wrapKey,
+        aadBytes
+      );
+      debugLog("Step 4: Entropy encrypted", {
+        cipherLength: encryptedBlob.cipher.length,
+        nonceLength: encryptedBlob.nonce.length
+      });
+    } catch (err) {
+      debugLog("Step 4: Encryption FAILED", {
+        error: err,
+        errorMessage: err instanceof Error ? err.message : String(err)
+      });
+      throw err;
+    }
     const blob = new Blob(
       [
         encryptedBlob.cipher,
@@ -19550,28 +19640,80 @@ async function enrollPasskey(params) {
         type: "application/octet-stream"
       }
     );
+    debugLog("Step 5: Blob prepared", { blobSize: blob.size });
+    debugLog("Step 6: Converting blob to base64...");
     const blobB64 = await blobToBase64(blob);
-    const uploadResponse = await client.post("/blob/upload", {
-      blobB64
-    });
+    debugLog("Step 6: Blob converted", { blobB64Length: blobB64.length });
+    debugLog("Step 6: Uploading blob...");
+    let uploadResponse;
+    try {
+      uploadResponse = await client.post("/blob/upload", {
+        blobB64
+      });
+      debugLog("Step 6: Upload response", uploadResponse);
+    } catch (err) {
+      debugLog("Step 6: Blob upload FAILED", {
+        error: err,
+        errorMessage: err instanceof Error ? err.message : String(err)
+      });
+      throw err;
+    }
     const blobUrl = uploadResponse?.key;
     if (!blobUrl) {
+      debugLog("Step 6: Missing blob URL in response", uploadResponse);
       throw new Error("Failed to upload blob: missing key");
     }
-    const keypair = deriveEvmKey({ masterSeed: masterSeedHandle.bytes });
+    debugLog("Step 6: Blob uploaded", { blobUrl });
+    debugLog("Step 7: Deriving address from seed...");
+    let keypair;
+    try {
+      keypair = deriveEvmKey({ masterSeed: masterKeyHandle.seed });
+      debugLog("Step 7: Keypair derived", { address: keypair.address });
+    } catch (err) {
+      debugLog("Step 7: Key derivation FAILED", {
+        error: err,
+        errorMessage: err instanceof Error ? err.message : String(err)
+      });
+      throw err;
+    }
     const address = keypair.address;
     const platform = detectPlatform();
-    const registerResponse = await client.post("/wallet/provider/register", {
+    debugLog("Step 8: Registering provider...", {
       keyStorageType: "passkey",
       credentialId,
       blobUrl,
-      prfInput: {
-        projectId,
-        credentialId
-      },
       address,
       platform
-      // For UX hints when authenticating on different devices
+    });
+    let registerResponse;
+    try {
+      registerResponse = await client.post("/wallet/provider/register", {
+        keyStorageType: "passkey",
+        credentialId,
+        blobUrl,
+        prfInput: {
+          projectId,
+          credentialId
+        },
+        address,
+        platform
+        // For UX hints when authenticating on different devices
+      });
+      debugLog("Step 8: Provider registered", {
+        providerId: registerResponse?.id,
+        hasUser: !!registerResponse?.user
+      });
+    } catch (err) {
+      debugLog("Step 8: Provider registration FAILED", {
+        error: err,
+        errorMessage: err instanceof Error ? err.message : String(err)
+      });
+      throw err;
+    }
+    debugLog("Enrollment completed successfully!", {
+      credentialId,
+      blobUrl,
+      address
     });
     return {
       credentialId,
@@ -19586,7 +19728,8 @@ async function enrollPasskey(params) {
       user: registerResponse.user
     };
   } finally {
-    masterSeedHandle.destroy();
+    debugLog("Cleanup: Destroying master key handle");
+    masterKeyHandle.destroy();
   }
 }
 function usePasskeyEnrollment() {