@volr/react 0.1.130 → 0.1.132

package/dist/index.cjs

@@ -9774,10 +9774,42 @@ function useSessionSync({
 }
 
 // src/config/webauthn.ts
+function isWindows() {
+  if (typeof navigator === "undefined") return false;
+  const platform = navigator.platform || "";
+  return /Win/.test(platform);
+}
+function isLinux() {
+  if (typeof navigator === "undefined") return false;
+  const platform = navigator.platform || "";
+  const ua = navigator.userAgent;
+  return /Linux/.test(platform) && !/CrOS/.test(ua) && !/Android/.test(ua);
+}
+function shouldForceCrossDevice() {
+  return isWindows() || isLinux();
+}
 var AUTHENTICATOR_SELECTION = {
   userVerification: "required",
   residentKey: "required"
 };
+var AUTHENTICATOR_SELECTION_CROSS_DEVICE = {
+  userVerification: "required",
+  residentKey: "required",
+  authenticatorAttachment: "cross-platform"
+};
+function getAuthenticatorSelection() {
+  if (shouldForceCrossDevice()) {
+    return AUTHENTICATOR_SELECTION_CROSS_DEVICE;
+  }
+  return AUTHENTICATOR_SELECTION;
+}
+function getWebAuthnHints() {
+  if (shouldForceCrossDevice()) {
+    return ["hybrid"];
+  }
+  return void 0;
+}
+var AUTHENTICATOR_TRANSPORTS = ["internal", "hybrid"];
 var CREDENTIAL_MEDIATION = "required";
 var USER_VERIFICATION = "required";
 var WEBAUTHN_TIMEOUT = 6e4;
@@ -9945,50 +9977,51 @@ function createPasskeyAdapter(options = {}) {
       return { r, s };
     },
     async authenticate(prfInput) {
-      if (!prfInput.credentialId) {
-        throw new Error(
-          "[PasskeyAdapter] credentialId is required for authentication. This usually means the passkey was not properly registered or user data is incomplete. Please re-enroll your passkey."
-        );
-      }
-      const hexString = prfInput.credentialId.startsWith("0x") ? prfInput.credentialId.slice(2) : prfInput.credentialId;
-      if (!/^[0-9a-fA-F]+$/.test(hexString)) {
-        console.error(
-          "[PasskeyAdapter] Invalid credentialId format (not hex):",
-          prfInput.credentialId
-        );
-        throw new Error(
-          `[PasskeyAdapter] Invalid credentialId format. Expected hex string, got: ${prfInput.credentialId}`
-        );
-      }
-      const normalizedHex = hexString.length % 2 === 0 ? hexString : "0" + hexString;
-      const hexPairs = normalizedHex.match(/.{1,2}/g);
-      if (!hexPairs) {
-        throw new Error(
-          `[PasskeyAdapter] Failed to parse hex string: ${normalizedHex}`
-        );
-      }
-      const credIdBytes = new Uint8Array(
-        hexPairs.map((byte) => parseInt(byte, 16))
-      );
-      const reconvertedHex = Array.from(credIdBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-      if (reconvertedHex.toLowerCase() !== normalizedHex.toLowerCase()) {
-        throw new Error(
-          `[PasskeyAdapter] credentialId conversion failed. Original: ${normalizedHex}, Reconverted: ${reconvertedHex}`
+      const allowCredentials = [];
+      if (prfInput.credentialId) {
+        const hexString = prfInput.credentialId.startsWith("0x") ? prfInput.credentialId.slice(2) : prfInput.credentialId;
+        if (!/^[0-9a-fA-F]+$/.test(hexString)) {
+          console.error(
+            "[PasskeyAdapter] Invalid credentialId format (not hex):",
+            prfInput.credentialId
+          );
+          throw new Error(
+            `[PasskeyAdapter] Invalid credentialId format. Expected hex string, got: ${prfInput.credentialId}`
+          );
+        }
+        const normalizedHex = hexString.length % 2 === 0 ? hexString : "0" + hexString;
+        const hexPairs = normalizedHex.match(/.{1,2}/g);
+        if (!hexPairs) {
+          throw new Error(
+            `[PasskeyAdapter] Failed to parse hex string: ${normalizedHex}`
+          );
+        }
+        const credIdBytes = new Uint8Array(
+          hexPairs.map((byte) => parseInt(byte, 16))
         );
-      }
-      const allowCredentials = [
-        {
-          id: credIdBytes,
-          type: "public-key"
+        const reconvertedHex = Array.from(credIdBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+        if (reconvertedHex.toLowerCase() !== normalizedHex.toLowerCase()) {
+          throw new Error(
+            `[PasskeyAdapter] credentialId conversion failed. Original: ${normalizedHex}, Reconverted: ${reconvertedHex}`
+          );
         }
-      ];
+        const transports = shouldForceCrossDevice() ? ["hybrid"] : AUTHENTICATOR_TRANSPORTS;
+        allowCredentials.push({
+          id: credIdBytes,
+          type: "public-key",
+          transports
+        });
+      }
+      const hints = getWebAuthnHints();
       return withWebAuthnLock(async () => {
         let credential = null;
         try {
-          credential = await navigator.credentials.get({
+          const requestOptions = {
             publicKey: {
               challenge: crypto.getRandomValues(new Uint8Array(32)),
               rpId,
+              // If allowCredentials is empty, the browser will use discoverable credentials.
+              // This enables the account chooser and cross-device (hybrid) QR flows.
               allowCredentials,
               userVerification: USER_VERIFICATION,
               // Shared constant
@@ -9998,11 +10031,15 @@ function createPasskeyAdapter(options = {}) {
                     first: prfInput.salt.buffer
                   }
                 }
-              }
+              },
+              // Chrome 128+ supports hints to prioritize certain authenticator types
+              // On Windows/Linux, this prioritizes QR code over USB security key prompt
+              ...hints && { hints }
             },
             mediation: CREDENTIAL_MEDIATION
             // Use shared constant
-          });
+          };
+          credential = await navigator.credentials.get(requestOptions);
         } catch (error) {
           console.error("[PasskeyAdapter] WebAuthn get() failed:", error);
           console.error("[PasskeyAdapter] Error name:", error?.name);
@@ -10388,6 +10425,10 @@ function VolrProvider({ config, children }) {
   const [isLoading, setIsLoading] = react.useState(true);
   const [error, setError] = react.useState(null);
   const [chainId] = react.useState(config.defaultChainId);
+  const userRef = react.useRef(null);
+  react.useEffect(() => {
+    userRef.current = user;
+  }, [user]);
   const [accessToken, setAccessTokenState] = react.useState(() => {
     return client.getAccessToken();
   });
@@ -10408,10 +10449,11 @@ function VolrProvider({ config, children }) {
         setError(null);
         const keyStorageType = newProvider.keyStorageType;
         setProviderState(newProvider);
-        const userHasCompleteData = user?.keyStorageType === "passkey" && user?.blobUrl && user?.prfInput && user?.id;
+        const currentUser = userRef.current;
+        const userHasCompleteData = currentUser?.keyStorageType === "passkey" && currentUser?.blobUrl && currentUser?.prfInput && currentUser?.id;
         if (userHasCompleteData) {
           console.log("[Provider] setProvider: User data already complete, skipping refresh");
-          if (user.keyStorageType !== keyStorageType) {
+          if (currentUser?.keyStorageType !== keyStorageType) {
             setUser((prev) => ({ ...prev, keyStorageType }));
           }
         } else {
@@ -10443,7 +10485,7 @@ function VolrProvider({ config, children }) {
         throw error2;
       }
     },
-    [client, user, syncRef]
+    [client, syncRef]
   );
   useAutoRecover({
     client,
@@ -18503,26 +18545,28 @@ function createGetRpcUrl(deps) {
   };
 }
 function createGetNetworkInfo(deps) {
-  const { client } = deps;
+  const { client, rpcOverrides } = deps;
   return async function getNetworkInfo(chainId, includeRpcUrl = false) {
+    const overrideUrl = rpcOverrides?.[chainId.toString()];
     const cached = networkCache.get(chainId);
     if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
       return {
         name: cached.name || `Chain ${chainId}`,
-        rpcUrl: includeRpcUrl ? cached.rpcUrl : void 0,
+        rpcUrl: includeRpcUrl ? overrideUrl ?? cached.rpcUrl : void 0,
         invokerAddress: cached.invokerAddress
       };
     }
     const response = await client.get(`/networks/${chainId}${includeRpcUrl ? "?includeRpcUrl=true" : ""}`);
     networkCache.set(chainId, {
       name: response.name,
-      rpcUrl: response.rpcUrl,
+      // If an override exists, cache it as the effective rpcUrl for this chainId
+      rpcUrl: overrideUrl ?? response.rpcUrl,
       invokerAddress: response.invokerAddress,
       timestamp: Date.now()
     });
     return {
       name: response.name,
-      rpcUrl: includeRpcUrl ? response.rpcUrl : void 0,
+      rpcUrl: includeRpcUrl ? overrideUrl ?? response.rpcUrl : void 0,
       invokerAddress: response.invokerAddress
     };
   };
@@ -18561,7 +18605,7 @@ function validateCalls2(calls) {
 
 // src/wallet/normalize.ts
 function normalizeCall(call2) {
-  const normalizedTarget = getAddress(call2.target);
+  const normalizedTarget = normalizeHex(getAddress(call2.target));
   const normalizedData = normalizeHex(call2.data);
   const value = call2.value ?? 0n;
   const gasLimit = call2.gasLimit ?? 0n;
@@ -18797,7 +18841,7 @@ async function sendCalls(args) {
   if (chainId === 0) {
     throw new Error("chainId cannot be 0");
   }
-  const normalizedFrom = from14;
+  const normalizedFrom = normalizeHex(from14);
   const normalizedCalls = normalizeCalls(calls);
   validateCalls2(normalizedCalls);
   if (!deps.provider && deps.user?.keyStorageType !== "passkey") {
@@ -18861,7 +18905,7 @@ async function sendCalls(args) {
   if (!quotePolicyId) {
     throw new Error("Backend did not return policyId in precheck response");
   }
-  const projectPolicyId = quotePolicyId;
+  const projectPolicyId = normalizeHex(quotePolicyId);
   validatePolicyId2(projectPolicyId);
   const tempAuth = buildTempAuth({
     chainId,
@@ -19676,6 +19720,8 @@ async function enrollPasskey(params) {
   };
   const prfSalt = sdkCore.deriveWrapKey(tempPrfInput);
   const displayName = buildDisplayName(userEmail, userEvmAddress, userId);
+  const authenticatorSelection = getAuthenticatorSelection();
+  const hints = getWebAuthnHints();
   const publicKeyCredentialCreationOptions = {
     challenge: challenge2,
     rp: {
@@ -19688,7 +19734,7 @@ async function enrollPasskey(params) {
       displayName
     },
     pubKeyCredParams: PUBKEY_CRED_PARAMS,
-    authenticatorSelection: AUTHENTICATOR_SELECTION,
+    authenticatorSelection,
     timeout: WEBAUTHN_TIMEOUT,
     attestation: ATTESTATION,
     extensions: {
@@ -19697,7 +19743,10 @@ async function enrollPasskey(params) {
           first: prfSalt.buffer
         }
       }
-    }
+    },
+    // Chrome 128+ supports hints to prioritize certain authenticator types
+    // On Windows/Linux, this prioritizes QR code over USB security key prompt
+    ...hints && { hints }
   };
   const credential = await navigator.credentials.create({
     publicKey: publicKeyCredentialCreationOptions
@@ -20891,7 +20940,12 @@ function getPlatformHint(platform) {
     case "Windows":
       return {
         hintKey: "passkey.hint.windows",
-        noteKey: "passkey.hint.note"
+        noteKey: "passkey.hint.windowsNote"
+      };
+    case "Linux":
+      return {
+        hintKey: "passkey.hint.linux",
+        noteKey: "passkey.hint.windowsNote"
       };
     default:
       return {
@@ -21085,6 +21139,8 @@ async function completeMigration(params) {
     credentialId: tempCredentialId
   };
   const prfSalt = sdkCore.deriveWrapKey(tempPrfInput);
+  const authenticatorSelection = getAuthenticatorSelection();
+  const hints = getWebAuthnHints();
   const publicKeyCredentialCreationOptions = {
     challenge: challenge2,
     rp: {
@@ -21097,7 +21153,7 @@ async function completeMigration(params) {
       displayName
     },
     pubKeyCredParams: PUBKEY_CRED_PARAMS,
-    authenticatorSelection: AUTHENTICATOR_SELECTION,
+    authenticatorSelection,
     timeout: WEBAUTHN_TIMEOUT,
     attestation: ATTESTATION,
     extensions: {
@@ -21106,7 +21162,10 @@ async function completeMigration(params) {
           first: prfSalt.buffer
         }
       }
-    }
+    },
+    // Chrome 128+ supports hints to prioritize certain authenticator types
+    // On Windows/Linux, this prioritizes QR code over USB security key prompt
+    ...hints && { hints }
   };
   const credential = await navigator.credentials.create({
     publicKey: publicKeyCredentialCreationOptions