@volr/react 0.1.83 → 0.1.85

package/dist/index.cjs

@@ -1723,6 +1723,16 @@ function byteSwap32(arr) {
   }
   return arr;
 }
+function bytesToHex2(bytes) {
+  abytes(bytes);
+  if (hasHexBuiltin)
+    return bytes.toHex();
+  let hex = "";
+  for (let i = 0; i < bytes.length; i++) {
+    hex += hexes2[bytes[i]];
+  }
+  return hex;
+}
 function utf8ToBytes(str) {
   if (typeof str !== "string")
     throw new Error("string expected");
@@ -1766,12 +1776,17 @@ function randomBytes(bytesLength = 32) {
   }
   throw new Error("crypto.getRandomValues must be defined");
 }
-var isLE, swap32IfBE, Hash;
+var isLE, swap32IfBE, hasHexBuiltin, hexes2, Hash;
 var init_utils2 = __esm({
   "../node_modules/@noble/hashes/esm/utils.js"() {
     init_cryptoNode();
     isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
     swap32IfBE = isLE ? (u) => u : byteSwap32;
+    hasHexBuiltin = /* @__PURE__ */ (() => (
+      // @ts-ignore
+      typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function"
+    ))();
+    hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
     Hash = class {
     };
   }
@@ -4601,13 +4616,13 @@ function hexToNumber2(hex) {
     throw new Error("hex string expected, got " + typeof hex);
   return hex === "" ? _0n2 : BigInt("0x" + hex);
 }
-function bytesToHex2(bytes) {
+function bytesToHex3(bytes) {
   abytes2(bytes);
-  if (hasHexBuiltin)
+  if (hasHexBuiltin2)
     return bytes.toHex();
   let hex = "";
   for (let i = 0; i < bytes.length; i++) {
-    hex += hexes2[bytes[i]];
+    hex += hexes3[bytes[i]];
   }
   return hex;
 }
@@ -4623,7 +4638,7 @@ function asciiToBase16(ch) {
 function hexToBytes2(hex) {
   if (typeof hex !== "string")
     throw new Error("hex string expected, got " + typeof hex);
-  if (hasHexBuiltin)
+  if (hasHexBuiltin2)
     return Uint8Array.fromHex(hex);
   const hl = hex.length;
   const al = hl / 2;
@@ -4642,11 +4657,11 @@ function hexToBytes2(hex) {
   return array;
 }
 function bytesToNumberBE(bytes) {
-  return hexToNumber2(bytesToHex2(bytes));
+  return hexToNumber2(bytesToHex3(bytes));
 }
 function bytesToNumberLE(bytes) {
   abytes2(bytes);
-  return hexToNumber2(bytesToHex2(Uint8Array.from(bytes).reverse()));
+  return hexToNumber2(bytesToHex3(Uint8Array.from(bytes).reverse()));
 }
 function numberToBytesBE(n, len) {
   return hexToBytes2(n.toString(16).padStart(len * 2, "0"));
@@ -4782,14 +4797,14 @@ function memoized(fn) {
     return computed;
   };
 }
-var _0n2, _1n2, hasHexBuiltin, hexes2, asciis, isPosBig, bitMask, u8n, u8fr, validatorFns;
+var _0n2, _1n2, hasHexBuiltin2, hexes3, asciis, isPosBig, bitMask, u8n, u8fr, validatorFns;
 var init_utils4 = __esm({
   "../node_modules/@noble/curves/esm/abstract/utils.js"() {
     _0n2 = /* @__PURE__ */ BigInt(0);
     _1n2 = /* @__PURE__ */ BigInt(1);
-    hasHexBuiltin = // @ts-ignore
+    hasHexBuiltin2 = // @ts-ignore
     typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function";
-    hexes2 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+    hexes3 = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
     asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
     isPosBig = (n) => typeof n === "bigint" && _0n2 <= n;
     bitMask = (n) => (_1n2 << BigInt(n)) - _1n2;
@@ -5363,7 +5378,7 @@ function validatePointOpts(curve) {
   return Object.freeze({ ...opts });
 }
 function numToSizedHex(num2, size5) {
-  return bytesToHex2(numberToBytesBE(num2, size5));
+  return bytesToHex3(numberToBytesBE(num2, size5));
 }
 function weierstrassPoints(opts) {
   const CURVE = validatePointOpts(opts);
@@ -5403,7 +5418,7 @@ function weierstrassPoints(opts) {
     const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n: N } = CURVE;
     if (lengths && typeof key !== "bigint") {
       if (isBytes2(key))
-        key = bytesToHex2(key);
+        key = bytesToHex3(key);
       if (typeof key !== "string" || !lengths.includes(key.length))
         throw new Error("invalid private key");
       key = key.padStart(nByteLength * 2, "0");
@@ -5753,7 +5768,7 @@ function weierstrassPoints(opts) {
     }
     toHex(isCompressed = true) {
       abool("isCompressed", isCompressed);
-      return bytesToHex2(this.toRawBytes(isCompressed));
+      return bytesToHex3(this.toRawBytes(isCompressed));
     }
   }
   Point2.BASE = new Point2(CURVE.Gx, CURVE.Gy, Fp.ONE);
@@ -7668,7 +7683,7 @@ function fromBoolean(value, options = {}) {
 function fromBytes(value, options = {}) {
   let string = "";
   for (let i = 0; i < value.length; i++)
-    string += hexes3[value[i]];
+    string += hexes4[value[i]];
   const hex = `0x${string}`;
   if (typeof options.size === "number") {
     assertSize3(hex, options.size);
@@ -7757,14 +7772,14 @@ function validate2(value, options = {}) {
     return false;
   }
 }
-var encoder4, hexes3, IntegerOutOfRangeError2, InvalidHexTypeError, InvalidHexValueError, SizeOverflowError3, SliceOffsetOutOfBoundsError3, SizeExceedsPaddingSizeError3;
+var encoder4, hexes4, IntegerOutOfRangeError2, InvalidHexTypeError, InvalidHexValueError, SizeOverflowError3, SliceOffsetOutOfBoundsError3, SizeExceedsPaddingSizeError3;
 var init_Hex = __esm({
   "../node_modules/ox/_esm/core/Hex.js"() {
     init_Errors();
     init_hex();
     init_Json();
     encoder4 = /* @__PURE__ */ new TextEncoder();
-    hexes3 = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
+    hexes4 = /* @__PURE__ */ Array.from({ length: 256 }, (_v, i) => i.toString(16).padStart(2, "0"));
     IntegerOutOfRangeError2 = class extends BaseError3 {
       constructor({ max, min, signed, size: size5, value }) {
         super(`Number \`${value}\` is not in safe${size5 ? ` ${size5 * 8}-bit` : ""}${signed ? " signed" : " unsigned"} integer range ${max ? `(\`${min}\` to \`${max}\`)` : `(above \`${min}\`)`}`);
@@ -8969,6 +8984,10 @@ var init_call = __esm({
 });
 var VolrContext = react.createContext(null);
 var InternalAuthContext = react.createContext(null);
+var ERROR_CODES = {
+  AUTH_PROJECT_NOT_FOUND: "AUTH_PROJECT_NOT_FOUND",
+  AUTH_PROJECT_REQUIRED: "AUTH_PROJECT_REQUIRED",
+  ORIGIN_NOT_ALLOWED: "ORIGIN_NOT_ALLOWED"};
 function mapBackendError(error) {
   return new sdkCore.VolrError(error.code, error.message);
 }
@@ -9045,6 +9064,32 @@ var STORAGE_CHANNELS = {
 };
 
 // src/headless/client.ts
+var CONFIG_ERROR_CODES = [
+  ERROR_CODES.AUTH_PROJECT_NOT_FOUND,
+  ERROR_CODES.AUTH_PROJECT_REQUIRED,
+  ERROR_CODES.ORIGIN_NOT_ALLOWED
+];
+function logConfigurationError(errorCode, errorMessage) {
+  const isDevelopment = typeof process !== "undefined" && process.env?.NODE_ENV === "development";
+  const errorMessages = {
+    [ERROR_CODES.AUTH_PROJECT_NOT_FOUND]: `[Volr SDK] \u274C Invalid projectApiKey: Project not found.
+Please verify your VolrProvider config.projectApiKey is correct.
+You can find your API key in the Volr Dashboard > Project Settings.`,
+    [ERROR_CODES.AUTH_PROJECT_REQUIRED]: `[Volr SDK] \u274C Missing projectApiKey.
+Please provide projectApiKey in your VolrProvider config.
+Example: <VolrProvider config={{ projectApiKey: 'your-api-key', ... }}>`,
+    [ERROR_CODES.ORIGIN_NOT_ALLOWED]: `[Volr SDK] \u274C Origin not allowed for this project.
+The current origin is not in your project's allowed origins list.
+Add this origin in Volr Dashboard > Project Settings > Security.`
+  };
+  const devMessage = errorMessages[errorCode] || `[Volr SDK] \u274C Configuration error: ${errorCode}
+${errorMessage}`;
+  if (isDevelopment) {
+    console.error(devMessage);
+  } else {
+    console.error(`[Volr SDK] Configuration error: ${errorCode}. Check console in development mode for details.`);
+  }
+}
 var APIClient = class {
   constructor(config) {
     this.refreshPromise = null;
@@ -9091,6 +9136,14 @@ var APIClient = class {
       async (error) => {
         const originalRequest = error.config;
         const requestUrl = originalRequest?.url || "";
+        const responseData = error.response?.data;
+        if (responseData && !responseData.ok && responseData.error) {
+          const errorCode = responseData.error.code;
+          const errorMessage = responseData.error.message;
+          if (CONFIG_ERROR_CODES.includes(errorCode)) {
+            logConfigurationError(errorCode, errorMessage);
+          }
+        }
         const publicAuthEndpoints = [
           "/auth/refresh",
           "/auth/siwe/nonce",
@@ -18614,6 +18667,34 @@ function useVolr() {
     error
   };
 }
+init_sha3();
+init_utils2();
+function toChecksumAddress(address) {
+  const addr = address.toLowerCase().replace("0x", "");
+  const hash3 = bytesToHex2(keccak_256(new TextEncoder().encode(addr)));
+  let checksummed = "0x";
+  for (let i = 0; i < addr.length; i++) {
+    if (parseInt(hash3[i], 16) >= 8) {
+      checksummed += addr[i].toUpperCase();
+    } else {
+      checksummed += addr[i];
+    }
+  }
+  return checksummed;
+}
+function detectWalletConnector() {
+  if (typeof window === "undefined" || !window.ethereum) {
+    return void 0;
+  }
+  const provider = window.ethereum;
+  if (provider.info?.rdns) return provider.info.rdns;
+  if (provider.isMetaMask) return "io.metamask";
+  if (provider.isCoinbaseWallet) return "com.coinbase.wallet";
+  if (provider.isRabby) return "io.rabby";
+  if (provider.isZerion) return "io.zerion";
+  if (provider.isBraveWallet) return "com.brave.wallet";
+  return "unknown";
+}
 function useVolrLogin() {
   const { config, setUser } = useVolrContext();
   const { setAccessToken, setRefreshToken, client } = useInternalAuth();
@@ -18743,15 +18824,84 @@ function useVolrLogin() {
     },
     [client, setAccessToken, setRefreshToken, setUser, toVolrUser]
   );
+  const signWithWallet = react.useCallback(
+    async (walletAddress) => {
+      if (typeof window === "undefined" || !window.ethereum) {
+        throw new Error("No Ethereum wallet found. Please install MetaMask or another wallet.");
+      }
+      const ethereum = window.ethereum;
+      const chainIdHex = await ethereum.request({ method: "eth_chainId" });
+      const chainId = parseInt(chainIdHex, 16);
+      const nonce = await requestSiweNonce();
+      const domain = window.location.host;
+      const origin = window.location.origin;
+      const statement = "Sign in with Ethereum to continue";
+      const issuedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const checksumAddress2 = toChecksumAddress(walletAddress);
+      const message = `${domain} wants you to sign in with your Ethereum account:
+${checksumAddress2}
+
+${statement}
+
+URI: ${origin}
+Version: 1
+Chain ID: ${chainId}
+Nonce: ${nonce}
+Issued At: ${issuedAt}`;
+      const signature = await ethereum.request({
+        method: "personal_sign",
+        params: [message, walletAddress]
+      });
+      const walletConnector = detectWalletConnector();
+      return verifySiweSignature(message, signature, { walletConnector, chainId });
+    },
+    [requestSiweNonce, verifySiweSignature]
+  );
   const handlePasskeyComplete = react.useCallback(async () => {
   }, []);
+  const createSiweSession = react.useCallback(async () => {
+    const response = await client.post("/auth/siwe/session", {});
+    return response;
+  }, [client]);
+  const checkSiweSession = react.useCallback(
+    async (sessionId) => {
+      const response = await client.get(`/auth/siwe/session/${sessionId}`);
+      if (response.status === "completed" && response.tokens && response.user) {
+        setAccessToken(response.tokens.accessToken);
+        setRefreshToken(response.tokens.refreshToken);
+        setUser(toVolrUser(response.user));
+      }
+      return response;
+    },
+    [client, setAccessToken, setRefreshToken, setUser, toVolrUser]
+  );
+  const getSiweSignUrl = react.useCallback(
+    (sessionId) => {
+      const accentColor = config.accentColor || "#303030";
+      const params = new URLSearchParams({
+        session: sessionId,
+        accentColor
+      });
+      if (apiBaseUrl.includes("dev-api") || apiBaseUrl.includes("localhost")) {
+        params.set("env", "dev");
+      }
+      const lang = typeof navigator !== "undefined" ? navigator.language?.startsWith("ko") ? "ko" : "en" : "en";
+      params.set("lang", lang);
+      return `https://sign.volr.io?${params.toString()}`;
+    },
+    [apiBaseUrl, config]
+  );
   return {
     requestEmailCode,
     verifyEmailCode,
     handleSocialLogin,
     requestSiweNonce,
     verifySiweSignature,
-    handlePasskeyComplete
+    signWithWallet,
+    handlePasskeyComplete,
+    createSiweSession,
+    checkSiweSession,
+    getSiweSignUrl
   };
 }
 function useVolrAuthCallback(options = {}) {