@volr/react 0.1.109 → 0.1.110

package/dist/index.cjs

@@ -7907,7 +7907,7 @@ var init_BlockOverrides = __esm({
 });
 
 // ../node_modules/viem/_esm/constants/abis.js
-var multicall3Abi, batchGatewayAbi, universalResolverErrors, universalResolverResolveAbi, universalResolverReverseAbi, textResolverAbi, addressResolverAbi, erc1271Abi, erc6492SignatureValidatorAbi;
+var multicall3Abi, batchGatewayAbi, universalResolverErrors, universalResolverResolveAbi, universalResolverReverseAbi, textResolverAbi, addressResolverAbi, erc1271Abi, erc6492SignatureValidatorAbi, erc20Abi;
 var init_abis = __esm({
   "../node_modules/viem/_esm/constants/abis.js"() {
     multicall3Abi = [
@@ -8244,6 +8244,194 @@ var init_abis = __esm({
         name: "isValidSig"
       }
     ];
+    erc20Abi = [
+      {
+        type: "event",
+        name: "Approval",
+        inputs: [
+          {
+            indexed: true,
+            name: "owner",
+            type: "address"
+          },
+          {
+            indexed: true,
+            name: "spender",
+            type: "address"
+          },
+          {
+            indexed: false,
+            name: "value",
+            type: "uint256"
+          }
+        ]
+      },
+      {
+        type: "event",
+        name: "Transfer",
+        inputs: [
+          {
+            indexed: true,
+            name: "from",
+            type: "address"
+          },
+          {
+            indexed: true,
+            name: "to",
+            type: "address"
+          },
+          {
+            indexed: false,
+            name: "value",
+            type: "uint256"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "allowance",
+        stateMutability: "view",
+        inputs: [
+          {
+            name: "owner",
+            type: "address"
+          },
+          {
+            name: "spender",
+            type: "address"
+          }
+        ],
+        outputs: [
+          {
+            type: "uint256"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "approve",
+        stateMutability: "nonpayable",
+        inputs: [
+          {
+            name: "spender",
+            type: "address"
+          },
+          {
+            name: "amount",
+            type: "uint256"
+          }
+        ],
+        outputs: [
+          {
+            type: "bool"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "balanceOf",
+        stateMutability: "view",
+        inputs: [
+          {
+            name: "account",
+            type: "address"
+          }
+        ],
+        outputs: [
+          {
+            type: "uint256"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "decimals",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [
+          {
+            type: "uint8"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "name",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [
+          {
+            type: "string"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "symbol",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [
+          {
+            type: "string"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "totalSupply",
+        stateMutability: "view",
+        inputs: [],
+        outputs: [
+          {
+            type: "uint256"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "transfer",
+        stateMutability: "nonpayable",
+        inputs: [
+          {
+            name: "recipient",
+            type: "address"
+          },
+          {
+            name: "amount",
+            type: "uint256"
+          }
+        ],
+        outputs: [
+          {
+            type: "bool"
+          }
+        ]
+      },
+      {
+        type: "function",
+        name: "transferFrom",
+        stateMutability: "nonpayable",
+        inputs: [
+          {
+            name: "sender",
+            type: "address"
+          },
+          {
+            name: "recipient",
+            type: "address"
+          },
+          {
+            name: "amount",
+            type: "uint256"
+          }
+        ],
+        outputs: [
+          {
+            type: "bool"
+          }
+        ]
+      }
+    ];
   }
 });
 
@@ -16026,6 +16214,51 @@ var InvalidWrappedSignatureError = class extends BaseError3 {
   }
 };
 
+// ../node_modules/viem/_esm/errors/unit.js
+init_base();
+var InvalidDecimalNumberError = class extends BaseError2 {
+  constructor({ value }) {
+    super(`Number \`${value}\` is not a valid decimal number.`, {
+      name: "InvalidDecimalNumberError"
+    });
+  }
+};
+
+// ../node_modules/viem/_esm/utils/unit/parseUnits.js
+function parseUnits(value, decimals) {
+  if (!/^(-?)([0-9]*)\.?([0-9]*)$/.test(value))
+    throw new InvalidDecimalNumberError({ value });
+  let [integer, fraction = "0"] = value.split(".");
+  const negative = integer.startsWith("-");
+  if (negative)
+    integer = integer.slice(1);
+  fraction = fraction.replace(/(0+)$/, "");
+  if (decimals === 0) {
+    if (Math.round(Number(`.${fraction}`)) === 1)
+      integer = `${BigInt(integer) + 1n}`;
+    fraction = "";
+  } else if (fraction.length > decimals) {
+    const [left, unit, right] = [
+      fraction.slice(0, decimals - 1),
+      fraction.slice(decimals - 1, decimals),
+      fraction.slice(decimals)
+    ];
+    const rounded = Math.round(Number(`${unit}.${right}`));
+    if (rounded > 9)
+      fraction = `${BigInt(left) + BigInt(1)}0`.padStart(left.length + 1, "0");
+    else
+      fraction = `${left}${rounded}`;
+    if (fraction.length > decimals) {
+      fraction = fraction.slice(1);
+      integer = `${BigInt(integer) + 1n}`;
+    }
+    fraction = fraction.slice(0, decimals);
+  } else {
+    fraction = fraction.padEnd(decimals, "0");
+  }
+  return BigInt(`${negative ? "-" : ""}${integer}${fraction}`);
+}
+
 // ../node_modules/viem/_esm/utils/formatters/proof.js
 function formatStorageProof(storageProof) {
   return storageProof.map((proof) => ({
@@ -18065,6 +18298,7 @@ function http(url, config = {}) {
 }
 
 // ../node_modules/viem/_esm/index.js
+init_abis();
 init_encodeFunctionData();
 init_getAddress();
 init_formatEther();
@@ -19734,6 +19968,216 @@ function useVolrPaymentApi() {
     isLoading
   };
 }
+function formatBalance(raw, decimals) {
+  const divisor = 10n ** BigInt(decimals);
+  const integerPart = raw / divisor;
+  const fractionalPart = raw % divisor;
+  const fractionalStr = fractionalPart.toString().padStart(decimals, "0");
+  const trimmedFractional = fractionalStr.replace(/0+$/, "");
+  const displayFractional = trimmedFractional.slice(0, 6) || "0";
+  if (displayFractional === "0" && integerPart === 0n) {
+    return "0";
+  }
+  return `${integerPart.toLocaleString()}.${displayFractional}`.replace(/\.$/, "");
+}
+function getNativeSymbol(chainId) {
+  switch (chainId) {
+    case 137:
+    case 80002:
+      return "POL";
+    case 56:
+    case 97:
+      return "BNB";
+    case 43114:
+    case 43113:
+      return "AVAX";
+    default:
+      return "ETH";
+  }
+}
+function useUserBalances() {
+  const { user, config } = useVolrContext();
+  const { client } = useInternalAuth();
+  const [brandingData, setBrandingData] = react.useState(null);
+  const [balances, setBalances] = react.useState([]);
+  const [isLoadingBranding, setIsLoadingBranding] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const getRpcUrl = react.useMemo(
+    () => createGetRpcUrl({ client, rpcOverrides: config.rpcOverrides }),
+    [client, config.rpcOverrides]
+  );
+  react.useEffect(() => {
+    setIsLoadingBranding(true);
+    setError(null);
+    client.get("/auth/branding").then((response) => {
+      setBrandingData(response);
+      const initialBalances = response.depositAssets.map((asset) => {
+        const isNative = asset.token === "native";
+        const token = asset.token;
+        const address = isNative ? "0x0000000000000000000000000000000000000000" : token.address;
+        const id = `${asset.chainId}_${isNative ? "native" : address.toLowerCase()}`;
+        return {
+          id,
+          chainId: asset.chainId,
+          symbol: isNative ? getNativeSymbol(asset.chainId) : token.symbol,
+          decimals: isNative ? 18 : token.decimals,
+          address,
+          iconUrl: isNative ? void 0 : token.iconUrl,
+          isNative,
+          balanceRaw: 0n,
+          balance: "0",
+          isLoading: true
+        };
+      });
+      setBalances(initialBalances);
+    }).catch((err) => {
+      console.error("[useUserBalances] Failed to fetch branding:", err);
+      setError(err instanceof Error ? err : new Error("Failed to fetch branding"));
+    }).finally(() => {
+      setIsLoadingBranding(false);
+    });
+  }, [client]);
+  const fetchBalances = react.useCallback(async () => {
+    if (!user?.evmAddress || !brandingData?.depositAssets.length) {
+      return;
+    }
+    const userAddress = user.evmAddress;
+    const balancePromises = brandingData.depositAssets.map(async (asset) => {
+      const isNative = asset.token === "native";
+      const token = asset.token;
+      const address = isNative ? "0x0000000000000000000000000000000000000000" : token.address;
+      const id = `${asset.chainId}_${isNative ? "native" : address.toLowerCase()}`;
+      try {
+        const rpcUrl = await getRpcUrl(asset.chainId);
+        const publicClient = createPublicClient({
+          transport: http(rpcUrl)
+        });
+        let balanceRaw;
+        const decimals = isNative ? 18 : token.decimals;
+        if (isNative) {
+          balanceRaw = await publicClient.getBalance({ address: userAddress });
+        } else {
+          balanceRaw = await publicClient.readContract({
+            address: token.address,
+            abi: erc20Abi,
+            functionName: "balanceOf",
+            args: [userAddress]
+          });
+        }
+        return {
+          id,
+          balanceRaw,
+          balance: formatBalance(balanceRaw, decimals),
+          isLoading: false,
+          error: void 0
+        };
+      } catch (err) {
+        console.error(`[useUserBalances] Failed to fetch balance for ${id}:`, err);
+        return {
+          id,
+          balanceRaw: 0n,
+          balance: "0",
+          isLoading: false,
+          error: "Failed to fetch balance"
+        };
+      }
+    });
+    const results = await Promise.all(balancePromises);
+    setBalances(
+      (prev) => prev.map((b) => {
+        const result = results.find((r) => r.id === b.id);
+        if (result) {
+          return { ...b, ...result };
+        }
+        return b;
+      })
+    );
+  }, [user?.evmAddress, brandingData?.depositAssets, getRpcUrl]);
+  react.useEffect(() => {
+    if (!isLoadingBranding && user?.evmAddress && brandingData) {
+      fetchBalances();
+    }
+  }, [isLoadingBranding, user?.evmAddress, brandingData, fetchBalances]);
+  const totalUsd = react.useMemo(() => {
+    return balances.reduce((sum, b) => sum + (b.balanceUsd ?? 0), 0);
+  }, [balances]);
+  const isLoading = isLoadingBranding || balances.some((b) => b.isLoading);
+  return {
+    balances,
+    totalUsd,
+    isLoading,
+    paymentEnabled: brandingData?.paymentEnabled ?? false,
+    refresh: fetchBalances,
+    error
+  };
+}
+function isNativeToken(address) {
+  const normalized = address.toLowerCase();
+  return normalized === "native" || normalized === "0x0000000000000000000000000000000000000000" || normalized === "0x0";
+}
+function useWithdraw() {
+  const { evm, isLoggedIn } = useVolr();
+  const [isWithdrawing, setIsWithdrawing] = react.useState(false);
+  const [result, setResult] = react.useState(null);
+  const [error, setError] = react.useState(null);
+  const withdraw = react.useCallback(
+    async (params) => {
+      if (!isLoggedIn) {
+        throw new Error("User must be logged in to withdraw");
+      }
+      if (!evm.address) {
+        throw new Error("Wallet address not available");
+      }
+      setIsWithdrawing(true);
+      setError(null);
+      setResult(null);
+      try {
+        const { chainId, tokenAddress, decimals, amount, to } = params;
+        const client = evm.client(chainId);
+        const amountRaw = parseUnits(amount, decimals);
+        let txResult;
+        if (isNativeToken(tokenAddress)) {
+          txResult = await client.sendTransaction({
+            to,
+            data: "0x",
+            value: amountRaw
+          });
+        } else {
+          const data = encodeFunctionData({
+            abi: erc20Abi,
+            functionName: "transfer",
+            args: [to, amountRaw]
+          });
+          txResult = await client.sendTransaction({
+            to: tokenAddress,
+            data
+          });
+        }
+        setResult(txResult);
+        return txResult;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("Withdrawal failed");
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsWithdrawing(false);
+      }
+    },
+    [evm, isLoggedIn]
+  );
+  const reset = react.useCallback(() => {
+    setIsWithdrawing(false);
+    setResult(null);
+    setError(null);
+  }, []);
+  return {
+    withdraw,
+    isWithdrawing,
+    result,
+    error,
+    reset
+  };
+}
 
 // src/utils/contract-analysis.ts
 var EIP7702_PREFIX = "0xef0100";
@@ -20331,6 +20775,101 @@ async function getUserCredentials(client) {
   const response = await client.get("/wallet/credentials");
   return response.credentials;
 }
+function useEIP6963() {
+  const [providers, setProviders] = react.useState([]);
+  const [hasLegacyProvider, setHasLegacyProvider] = react.useState(false);
+  const [isDetecting, setIsDetecting] = react.useState(true);
+  react.useEffect(() => {
+    if (typeof window === "undefined") {
+      setIsDetecting(false);
+      return;
+    }
+    const handleAnnounceProvider = (event) => {
+      const { detail } = event;
+      setProviders((prev) => {
+        if (prev.some((p) => p.info.uuid === detail.info.uuid)) {
+          return prev;
+        }
+        return [...prev, detail];
+      });
+    };
+    window.addEventListener("eip6963:announceProvider", handleAnnounceProvider);
+    window.dispatchEvent(new Event("eip6963:requestProvider"));
+    const hasLegacy = !!window.ethereum;
+    setHasLegacyProvider(hasLegacy);
+    const timeout = setTimeout(() => {
+      setIsDetecting(false);
+    }, 200);
+    return () => {
+      window.removeEventListener(
+        "eip6963:announceProvider",
+        handleAnnounceProvider
+      );
+      clearTimeout(timeout);
+    };
+  }, []);
+  const getProvider = react.useCallback(() => {
+    if (providers.length > 0) {
+      return { provider: providers[0].provider, info: providers[0].info };
+    }
+    if (hasLegacyProvider && window.ethereum) {
+      return { provider: window.ethereum, info: null };
+    }
+    return { provider: null, info: null };
+  }, [providers, hasLegacyProvider]);
+  const getWalletsForDisplay = react.useCallback(() => {
+    const walletsToShow = [];
+    providers.forEach((p) => {
+      walletsToShow.push({
+        id: p.info.uuid,
+        name: p.info.name,
+        icon: p.info.icon,
+        provider: p.provider,
+        rdns: p.info.rdns
+      });
+    });
+    if (hasLegacyProvider && providers.length === 0) {
+      const ethereum = window.ethereum;
+      let name = "Wallet";
+      if (ethereum?.isMetaMask) name = "MetaMask";
+      else if (ethereum?.isCoinbaseWallet) name = "Coinbase Wallet";
+      else if (ethereum?.isRabby) name = "Rabby";
+      else if (ethereum?.isBraveWallet) name = "Brave Wallet";
+      walletsToShow.push({
+        id: "legacy",
+        name,
+        provider: ethereum,
+        isLegacy: true
+      });
+    }
+    return walletsToShow;
+  }, [providers, hasLegacyProvider]);
+  const { provider, info } = getProvider();
+  const hasWallet = provider !== null;
+  return {
+    provider,
+    providerInfo: info,
+    hasWallet,
+    isDetecting,
+    allProviders: providers,
+    hasLegacyProvider,
+    getWalletsForDisplay
+  };
+}
+function detectWalletConnector(provider, providerInfo) {
+  if (providerInfo?.rdns) {
+    return providerInfo.rdns;
+  }
+  if (!provider) return "unknown";
+  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";
+  if (provider.isTrust) return "com.trustwallet";
+  if (provider.isPhantom) return "app.phantom";
+  return "unknown";
+}
 /*! Bundled license information:
 
 @noble/hashes/esm/utils.js:
@@ -20391,6 +20930,7 @@ exports.createGetNetworkInfo = createGetNetworkInfo;
 exports.createPasskeyAdapter = createPasskeyAdapter;
 exports.debugTransactionFailure = debugTransactionFailure;
 exports.defaultIdempotencyKey = defaultIdempotencyKey;
+exports.detectWalletConnector = detectWalletConnector;
 exports.diagnoseTransactionFailure = diagnoseTransactionFailure;
 exports.getERC20Balance = getERC20Balance;
 exports.getPasskeyAuthGuidance = getPasskeyAuthGuidance;
@@ -20407,13 +20947,16 @@ exports.requestSeedFromOpener = requestSeedFromOpener;
 exports.sendSeedToPopup = sendSeedToPopup;
 exports.uploadBlobViaPresign = uploadBlobViaPresign;
 exports.useDepositListener = useDepositListener;
+exports.useEIP6963 = useEIP6963;
 exports.useInternalAuth = useInternalAuth;
 exports.useMpcConnection = useMpcConnection;
 exports.usePasskeyEnrollment = usePasskeyEnrollment;
+exports.useUserBalances = useUserBalances;
 exports.useVolr = useVolr;
 exports.useVolrAuthCallback = useVolrAuthCallback;
 exports.useVolrContext = useVolrContext;
 exports.useVolrLogin = useVolrLogin;
 exports.useVolrPaymentApi = useVolrPaymentApi;
+exports.useWithdraw = useWithdraw;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map