@volr/react 0.1.67 → 0.1.69

package/dist/index.cjs

@@ -9502,6 +9502,52 @@ var PUBKEY_CRED_PARAMS = [
 ];
 var ATTESTATION = "direct";
 
+// src/errors/passkey-errors.ts
+var UserCancelledError = class _UserCancelledError extends Error {
+  constructor(message) {
+    super(message || "User cancelled the passkey authentication");
+    this.code = "USER_CANCELLED";
+    this.isUserCancelled = true;
+    this.name = "UserCancelledError";
+    Object.setPrototypeOf(this, _UserCancelledError.prototype);
+  }
+};
+var PasskeyNotFoundError = class _PasskeyNotFoundError extends Error {
+  constructor(message) {
+    super(message || "Passkey not found. Please re-enroll your passkey.");
+    this.code = "PASSKEY_NOT_FOUND";
+    this.name = "PasskeyNotFoundError";
+    Object.setPrototypeOf(this, _PasskeyNotFoundError.prototype);
+  }
+};
+var PrfNotSupportedError = class _PrfNotSupportedError extends Error {
+  constructor(message) {
+    super(
+      message || "WebAuthn PRF extension is not supported by this browser or device. Please use a browser that supports WebAuthn PRF extension."
+    );
+    this.code = "PRF_NOT_SUPPORTED";
+    this.name = "PrfNotSupportedError";
+    Object.setPrototypeOf(this, _PrfNotSupportedError.prototype);
+  }
+};
+function isUserCancelledError(error) {
+  if (error instanceof UserCancelledError) {
+    return true;
+  }
+  if (error instanceof Error) {
+    if (error.name === "NotAllowedError") {
+      return true;
+    }
+    if (error.isUserCancelled === true) {
+      return true;
+    }
+    if (error.message.includes("cancelled") || error.message.includes("denied")) {
+      return true;
+    }
+  }
+  return false;
+}
+
 // src/adapters/passkey.ts
 function createPasskeyAdapter(options = {}) {
   const rpId = options.rpId || (typeof window !== "undefined" ? window.location.hostname : "localhost");
@@ -9630,16 +9676,18 @@ function createPasskeyAdapter(options = {}) {
         console.error("[PasskeyAdapter] Error name:", error?.name);
         console.error("[PasskeyAdapter] Error message:", error?.message);
         if (error?.name === "NotAllowedError") {
-          throw new Error(
-            "[PasskeyAdapter] User cancelled the passkey prompt or authentication was denied. Please try again and complete the authentication."
+          throw new UserCancelledError(
+            "User cancelled the passkey prompt or authentication was denied."
           );
-        } else if (error?.name === "NotFoundError" || error?.name === "InvalidStateError") {
-          throw new Error(
-            "[PasskeyAdapter] No passkey found matching the provided credentialId. This may happen if the passkey was deleted or the credentialId is incorrect. Please re-enroll your passkey."
+        }
+        if (error?.name === "NotFoundError" || error?.name === "InvalidStateError") {
+          throw new PasskeyNotFoundError(
+            "No passkey found matching the provided credentialId. This may happen if the passkey was deleted or the credentialId is incorrect."
           );
-        } else if (error?.name === "NotSupportedError") {
-          throw new Error(
-            "[PasskeyAdapter] WebAuthn PRF extension is not supported by this browser or device. Please use a browser that supports WebAuthn PRF extension (Chrome 108+, Edge 108+, Safari 16.4+)."
+        }
+        if (error?.name === "NotSupportedError") {
+          throw new PrfNotSupportedError(
+            "WebAuthn PRF extension is not supported by this browser or device. Please use a browser that supports WebAuthn PRF extension (Chrome 108+, Edge 108+, Safari 16.4+)."
           );
         }
         throw new Error(
@@ -18093,7 +18141,14 @@ async function resolveSigner(input) {
     return { signer: explicitSigner, activeProvider: null };
   }
   if (provider) {
-    await provider.ensureSession({ interactive: true, force: true });
+    try {
+      await provider.ensureSession({ interactive: true });
+    } catch (error) {
+      if (isUserCancelledError(error)) {
+        throw error;
+      }
+      throw error;
+    }
     const signerContext = {
       provider,
       chainId,
@@ -18112,7 +18167,14 @@ async function resolveSigner(input) {
       credentialId: user.credentialId
     });
     await setProvider(restoredProvider);
-    await restoredProvider.ensureSession({ interactive: true, force: true });
+    try {
+      await restoredProvider.ensureSession({ interactive: true });
+    } catch (error) {
+      if (isUserCancelledError(error)) {
+        throw error;
+      }
+      throw error;
+    }
     const signerContext = {
       provider: restoredProvider,
       chainId,
@@ -18917,6 +18979,16 @@ function detectPlatform() {
   }
   return "Unknown";
 }
+function buildDisplayName(userEmail, userEvmAddress, userId) {
+  if (userEmail) {
+    return userEmail;
+  }
+  if (userEvmAddress) {
+    const short = `${userEvmAddress.slice(0, 6)}...${userEvmAddress.slice(-4)}`;
+    return `Volr (${short})`;
+  }
+  return userId || "Volr Wallet";
+}
 async function enrollPasskey(params) {
   const {
     client,
@@ -18955,7 +19027,7 @@ async function enrollPasskey(params) {
     credentialId: tempCredentialId
   };
   const prfSalt = sdkCore.deriveWrapKey(tempPrfInput);
-  const displayName = userEmail || userEvmAddress || userId;
+  const displayName = buildDisplayName(userEmail, userEvmAddress, userId);
   const publicKeyCredentialCreationOptions = {
     challenge: challenge2,
     rp: {
@@ -19533,6 +19605,159 @@ async function debugTransactionFailure(publicClient, failingWallet, workingWalle
     analysis
   };
 }
+
+// src/utils/platform-check.ts
+function detectPlatform2() {
+  if (typeof navigator === "undefined") return "Unknown";
+  const ua = navigator.userAgent;
+  const platform = navigator.platform || "";
+  if (/iPhone|iPad|iPod/.test(ua) || platform === "MacIntel" && navigator.maxTouchPoints > 1) {
+    return "iOS";
+  }
+  if (/Android/.test(ua)) {
+    return "Android";
+  }
+  if (/Mac/.test(platform)) {
+    return "macOS";
+  }
+  if (/Win/.test(platform)) {
+    return "Windows";
+  }
+  if (/CrOS/.test(ua)) {
+    return "ChromeOS";
+  }
+  if (/Linux/.test(platform)) {
+    return "Linux";
+  }
+  return "Unknown";
+}
+function detectBrowser() {
+  if (typeof navigator === "undefined") return "Unknown";
+  const ua = navigator.userAgent;
+  if (/Edg/.test(ua)) return "Edge";
+  if (/Chrome/.test(ua) && !/Chromium/.test(ua)) return "Chrome";
+  if (/Safari/.test(ua) && !/Chrome/.test(ua)) return "Safari";
+  if (/Firefox/.test(ua)) return "Firefox";
+  if (/Opera|OPR/.test(ua)) return "Opera";
+  return "Unknown";
+}
+function checkPrfSupport() {
+  const platform = detectPlatform2();
+  const browser = detectBrowser();
+  if (typeof navigator === "undefined" || !navigator.credentials) {
+    return {
+      prfSupported: false,
+      crossDeviceAvailable: false,
+      message: "WebAuthn is not supported in this environment.",
+      platform,
+      browser
+    };
+  }
+  let prfSupported = false;
+  let message;
+  switch (platform) {
+    case "iOS":
+      if (browser === "Safari") {
+        prfSupported = true;
+      } else {
+        prfSupported = true;
+      }
+      break;
+    case "Android":
+      if (browser === "Chrome" || browser === "Edge") {
+        prfSupported = true;
+      } else if (browser === "Firefox") {
+        prfSupported = false;
+        message = "Firefox on Android does not support passkey encryption. Please use Chrome.";
+      } else {
+        prfSupported = true;
+      }
+      break;
+    case "macOS":
+      if (browser === "Safari" || browser === "Chrome" || browser === "Edge") {
+        prfSupported = true;
+      } else if (browser === "Firefox") {
+        prfSupported = false;
+        message = "Firefox may not support passkey encryption. Please use Safari or Chrome.";
+      } else {
+        prfSupported = true;
+      }
+      break;
+    case "Windows":
+      if (browser === "Chrome" || browser === "Edge") {
+        prfSupported = true;
+        message = "If your device does not support passkey encryption, you can use your mobile device by scanning a QR code.";
+      } else {
+        prfSupported = false;
+        message = "Please use Chrome or Edge for passkey encryption support.";
+      }
+      break;
+    case "ChromeOS":
+      prfSupported = true;
+      break;
+    case "Linux":
+      if (browser === "Chrome" || browser === "Edge") {
+        prfSupported = true;
+        message = "If your device does not support passkey encryption, you can use your mobile device by scanning a QR code.";
+      } else {
+        prfSupported = false;
+        message = "Please use Chrome for passkey encryption support.";
+      }
+      break;
+    default:
+      prfSupported = false;
+      message = "Unknown platform. Passkey encryption may not be supported.";
+  }
+  const crossDeviceAvailable = true;
+  return {
+    prfSupported,
+    crossDeviceAvailable,
+    message,
+    platform,
+    browser
+  };
+}
+function getPasskeyAuthGuidance(passkeyPlatform) {
+  const { platform: currentPlatform, prfSupported } = checkPrfSupport();
+  if (prfSupported && (!passkeyPlatform || passkeyPlatform === currentPlatform)) {
+    return "";
+  }
+  if (passkeyPlatform && passkeyPlatform !== currentPlatform) {
+    const platformDisplayName = getPlatformDisplayName(passkeyPlatform);
+    return `Your passkey was registered on ${platformDisplayName}. You can use your ${platformDisplayName} device to authenticate by scanning a QR code.`;
+  }
+  if (!prfSupported) {
+    return "This device may not support passkey encryption. You can use your mobile device by scanning a QR code.";
+  }
+  return "";
+}
+function getPlatformDisplayName(platform) {
+  const displayNames = {
+    iOS: "iPhone/iPad",
+    Android: "Android",
+    macOS: "Mac",
+    Windows: "Windows PC",
+    ChromeOS: "Chromebook",
+    Linux: "Linux"
+  };
+  return displayNames[platform] || platform;
+}
+async function checkPrfExtensionAvailable() {
+  if (typeof PublicKeyCredential === "undefined") {
+    return false;
+  }
+  if ("getClientCapabilities" in PublicKeyCredential) {
+    try {
+      const capabilities = await PublicKeyCredential.getClientCapabilities();
+      if (capabilities && typeof capabilities.extensions?.prf === "boolean") {
+        return capabilities.extensions.prf;
+      }
+    } catch {
+    }
+  }
+  const { prfSupported } = checkPrfSupport();
+  return prfSupported;
+}
 /*! Bundled license information:
 
 @noble/hashes/esm/utils.js:
@@ -19577,10 +19802,15 @@ Object.defineProperty(exports, "uploadBlob", {
 });
 exports.DEFAULT_EXPIRES_IN_SEC = DEFAULT_EXPIRES_IN_SEC;
 exports.DEFAULT_MODE = DEFAULT_MODE;
+exports.PasskeyNotFoundError = PasskeyNotFoundError;
+exports.PrfNotSupportedError = PrfNotSupportedError;
+exports.UserCancelledError = UserCancelledError;
 exports.VolrProvider = VolrProvider;
 exports.analyzeContractForEIP7702 = analyzeContractForEIP7702;
 exports.buildCall = buildCall;
 exports.buildCalls = buildCalls;
+exports.checkPrfExtensionAvailable = checkPrfExtensionAvailable;
+exports.checkPrfSupport = checkPrfSupport;
 exports.compareERC20Balances = compareERC20Balances;
 exports.compareWalletStates = compareWalletStates;
 exports.createGetNetworkInfo = createGetNetworkInfo;
@@ -19589,8 +19819,10 @@ exports.debugTransactionFailure = debugTransactionFailure;
 exports.defaultIdempotencyKey = defaultIdempotencyKey;
 exports.diagnoseTransactionFailure = diagnoseTransactionFailure;
 exports.getERC20Balance = getERC20Balance;
+exports.getPasskeyAuthGuidance = getPasskeyAuthGuidance;
 exports.getWalletState = getWalletState;
 exports.isEIP7702Delegated = isEIP7702Delegated;
+exports.isUserCancelledError = isUserCancelledError;
 exports.normalizeHex = normalizeHex;
 exports.normalizeHexArray = normalizeHexArray;
 exports.uploadBlobViaPresign = uploadBlobViaPresign;