@agg-build/hooks 1.0.0

package/dist/deposit.mjs

@@ -0,0 +1,628 @@
+import {
+  __async,
+  getWalletAddressFromUserProfile,
+  useAggAuthState,
+  useAggBalanceState,
+  useAggUiConfig,
+  useDepositAddresses,
+  useRampQuotes,
+  useRampSession,
+  useSyncBalances
+} from "./chunk-CDPQERUC.mjs";
+
+// src/deposit/normalize-wallet-error.ts
+function normalizeWalletError(error, supportedChains) {
+  var _a, _b;
+  const message = error instanceof Error ? error.message : String(error);
+  const lower = message.toLowerCase();
+  if (lower.includes("user rejected") || lower.includes("user denied") || lower.includes("rejected the request") || lower.includes("denied transaction signature")) {
+    return { message: "Wallet request rejected.", tone: "error" };
+  }
+  const chainMismatch = message.includes("does not match the target chain") || message.includes("Expected Chain ID:");
+  if (chainMismatch) {
+    const match = message.match(/Expected Chain ID:\s*(\d+)/i);
+    const targetChainId = match ? Number(match[1]) : void 0;
+    const targetChainName = (_b = (_a = supportedChains == null ? void 0 : supportedChains.find((chain) => chain.chainId === targetChainId)) == null ? void 0 : _a.name) != null ? _b : targetChainId ? `chain ${targetChainId}` : "the selected chain";
+    return {
+      message: `Wallet chain does not match. Please switch your wallet to ${targetChainName}.`,
+      tone: "warning"
+    };
+  }
+  return { message, tone: "error" };
+}
+
+// src/deposit/use-wallet-token-balance.ts
+import { useEffect, useMemo, useState } from "react";
+import { useQuery } from "@tanstack/react-query";
+import { formatUnits } from "viem";
+import { useAccount, useReadContract } from "wagmi";
+import { useWallet } from "@solana/wallet-adapter-react";
+import { Connection, PublicKey } from "@solana/web3.js";
+
+// src/deposit/constants.ts
+var DEFAULT_SOLANA_RPC_ENDPOINT = "https://solana-rpc.publicnode.com";
+var SVM_CHAIN_IDS = /* @__PURE__ */ new Set([792703809]);
+
+// src/deposit/use-wallet-token-balance.ts
+var ERC20_BALANCE_OF_ABI = [
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+function getPhantomProvider() {
+  var _a, _b;
+  if (typeof window === "undefined") return void 0;
+  const w = window;
+  return (_b = (_a = w.phantom) == null ? void 0 : _a.solana) != null ? _b : w.solana;
+}
+function useWalletTokenBalance({
+  isOpen = true,
+  chainId,
+  tokenAddress,
+  decimals,
+  svmAddress
+}) {
+  var _a, _b, _c;
+  const { solanaRpcUrl } = useAggUiConfig();
+  const rpcEndpoint = solanaRpcUrl != null ? solanaRpcUrl : DEFAULT_SOLANA_RPC_ENDPOINT;
+  const isSvm = chainId !== void 0 && SVM_CHAIN_IDS.has(chainId);
+  const { address: evmAddress } = useAccount();
+  const evmEnabled = isOpen && !isSvm && !!chainId && !!tokenAddress && !!evmAddress && decimals !== void 0;
+  const { data: rawEvmBalance, isLoading: evmLoading } = useReadContract({
+    address: tokenAddress,
+    chainId,
+    abi: ERC20_BALANCE_OF_ABI,
+    functionName: "balanceOf",
+    args: evmAddress ? [evmAddress] : void 0,
+    query: { enabled: evmEnabled, staleTime: 0, refetchOnMount: true }
+  });
+  const { publicKey: adapterPublicKey } = useWallet();
+  const [phantomAddress, setPhantomAddress] = useState(void 0);
+  useEffect(() => {
+    var _a2;
+    if (!isSvm) return;
+    const provider = getPhantomProvider();
+    if (!provider) return;
+    const existing = (_a2 = provider.publicKey) == null ? void 0 : _a2.toBase58();
+    if (existing) {
+      setPhantomAddress(existing);
+      return;
+    }
+    provider.connect({ onlyIfTrusted: true }).then((res) => setPhantomAddress(res.publicKey.toString())).catch(() => {
+    });
+  }, [isSvm]);
+  const resolvedSvmAddress = (_b = (_a = adapterPublicKey == null ? void 0 : adapterPublicKey.toBase58()) != null ? _a : phantomAddress) != null ? _b : svmAddress;
+  const connection = useMemo(() => new Connection(rpcEndpoint), [rpcEndpoint]);
+  const svmEnabled = isOpen && isSvm && !!resolvedSvmAddress && !!tokenAddress;
+  const svmQuery = useQuery({
+    queryKey: ["svm-token-balance", resolvedSvmAddress != null ? resolvedSvmAddress : null, tokenAddress != null ? tokenAddress : null, isOpen],
+    enabled: svmEnabled,
+    staleTime: 0,
+    queryFn: () => __async(null, null, function* () {
+      var _a2;
+      if (!resolvedSvmAddress || !tokenAddress) return 0;
+      const owner = new PublicKey(resolvedSvmAddress);
+      const mint = new PublicKey(tokenAddress);
+      const accounts = yield connection.getTokenAccountsByOwner(owner, { mint });
+      if (accounts.value.length === 0) return 0;
+      const first = accounts.value[0];
+      if (!first) return 0;
+      const balance = yield connection.getTokenAccountBalance(first.pubkey);
+      return (_a2 = balance.value.uiAmount) != null ? _a2 : 0;
+    })
+  });
+  if (isSvm) {
+    const awaitingSelection2 = isOpen && !!chainId && !tokenAddress;
+    return {
+      balance: (_c = svmQuery.data) != null ? _c : 0,
+      isLoading: awaitingSelection2 || svmQuery.isLoading || svmQuery.isFetching
+    };
+  }
+  const evmBalance = rawEvmBalance !== void 0 && decimals !== void 0 ? Number(formatUnits(rawEvmBalance, decimals)) : 0;
+  const awaitingSelection = isOpen && !!chainId && !tokenAddress;
+  return { balance: evmBalance, isLoading: awaitingSelection || evmLoading };
+}
+
+// src/deposit/use-wallet-send-token.ts
+import { useCallback } from "react";
+import { parseUnits } from "viem";
+import { useWriteContract } from "wagmi";
+import { useWallet as useWallet2 } from "@solana/wallet-adapter-react";
+import {
+  Connection as Connection2,
+  Keypair,
+  PublicKey as PublicKey2,
+  SystemProgram,
+  Transaction,
+  TransactionInstruction
+} from "@solana/web3.js";
+function getPhantomProvider2() {
+  var _a, _b;
+  if (typeof window === "undefined") return void 0;
+  const w = window;
+  return (_b = (_a = w.phantom) == null ? void 0 : _a.solana) != null ? _b : w.solana;
+}
+var ERC20_TRANSFER_ABI = [
+  {
+    constant: false,
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    name: "transfer",
+    outputs: [{ name: "", type: "bool" }],
+    type: "function"
+  }
+];
+function useWalletSendToken() {
+  const { solanaRpcUrl } = useAggUiConfig();
+  const rpcEndpoint = solanaRpcUrl != null ? solanaRpcUrl : DEFAULT_SOLANA_RPC_ENDPOINT;
+  const { writeContractAsync } = useWriteContract();
+  const { publicKey, sendTransaction } = useWallet2();
+  return useCallback(
+    (params) => __async(null, null, function* () {
+      var _a, _b;
+      const isSvm = SVM_CHAIN_IDS.has(params.chainId);
+      if (!isSvm) {
+        const tokenAddress = params.token.address;
+        if (!tokenAddress) {
+          throw new Error("Missing ERC-20 token address for EVM transfer");
+        }
+        const value = parseUnits(params.amount || "0", params.token.decimals);
+        const txHash = yield writeContractAsync({
+          chainId: params.chainId,
+          address: tokenAddress,
+          abi: ERC20_TRANSFER_ABI,
+          functionName: "transfer",
+          args: [params.to, value]
+        });
+        return { txId: txHash };
+      }
+      if (!params.token.address) {
+        throw new Error("Missing SPL token mint address for Solana transfer");
+      }
+      const phantom = getPhantomProvider2();
+      let ownerBase58 = publicKey == null ? void 0 : publicKey.toBase58();
+      if (!ownerBase58 && phantom) {
+        try {
+          const res = yield phantom.connect();
+          ownerBase58 = res.publicKey.toString();
+        } catch (err) {
+          throw new Error(
+            `Failed to connect Phantom: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+      if (!ownerBase58) {
+        throw new Error("No Solana wallet connected");
+      }
+      const sendConnection = new Connection2(rpcEndpoint, "confirmed");
+      const TOKEN_PROGRAM_ID = new PublicKey2("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+      const ASSOCIATED_TOKEN_PROGRAM_ID = new PublicKey2(
+        "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+      );
+      const owner = new PublicKey2(ownerBase58);
+      const mint = new PublicKey2(params.token.address);
+      const destinationOwner = new PublicKey2(params.to);
+      const getAta = (walletPk, mintPk) => {
+        const [ata] = PublicKey2.findProgramAddressSync(
+          [walletPk.toBuffer(), TOKEN_PROGRAM_ID.toBuffer(), mintPk.toBuffer()],
+          ASSOCIATED_TOKEN_PROGRAM_ID
+        );
+        return ata;
+      };
+      const sourceAta = getAta(owner, mint);
+      const destinationAta = getAta(destinationOwner, mint);
+      const tx = new Transaction();
+      let destinationTokenAccountSigner = null;
+      const destinationOwnerInfo = yield sendConnection.getAccountInfo(destinationOwner);
+      const destinationInfo = yield sendConnection.getAccountInfo(destinationAta);
+      let destinationTokenAccount = destinationAta;
+      if (!destinationInfo) {
+        const rentExemptLamports = yield sendConnection.getMinimumBalanceForRentExemption(165);
+        const payerLamports = yield sendConnection.getBalance(owner, "confirmed");
+        const feeBufferLamports = 1e4;
+        const requiredLamports = rentExemptLamports + feeBufferLamports;
+        if (payerLamports < requiredLamports) {
+          const requiredSol = (requiredLamports / 1e9).toFixed(6);
+          const currentSol = (payerLamports / 1e9).toFixed(6);
+          throw new Error(
+            `This Solana deposit needs about ${requiredSol} SOL to create the destination token account, but the connected wallet only has ${currentSol} SOL available.`
+          );
+        }
+        const canCreateAta = (_b = (_a = destinationOwnerInfo == null ? void 0 : destinationOwnerInfo.owner) == null ? void 0 : _a.equals(SystemProgram.programId)) != null ? _b : false;
+        if (canCreateAta) {
+          const createIx = new TransactionInstruction({
+            programId: ASSOCIATED_TOKEN_PROGRAM_ID,
+            keys: [
+              { pubkey: owner, isSigner: true, isWritable: true },
+              { pubkey: destinationAta, isSigner: false, isWritable: true },
+              { pubkey: destinationOwner, isSigner: false, isWritable: false },
+              { pubkey: mint, isSigner: false, isWritable: false },
+              { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+              { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false }
+            ],
+            data: Buffer.alloc(0)
+          });
+          tx.add(createIx);
+        } else {
+          destinationTokenAccountSigner = Keypair.generate();
+          destinationTokenAccount = destinationTokenAccountSigner.publicKey;
+          tx.add(
+            SystemProgram.createAccount({
+              fromPubkey: owner,
+              newAccountPubkey: destinationTokenAccount,
+              lamports: rentExemptLamports,
+              space: 165,
+              programId: TOKEN_PROGRAM_ID
+            })
+          );
+          const initAccountData = Buffer.concat([
+            Buffer.from([18]),
+            // InitializeAccount3
+            destinationOwner.toBuffer()
+          ]);
+          tx.add(
+            new TransactionInstruction({
+              programId: TOKEN_PROGRAM_ID,
+              keys: [
+                { pubkey: destinationTokenAccount, isSigner: false, isWritable: true },
+                { pubkey: mint, isSigner: false, isWritable: false }
+              ],
+              data: initAccountData
+            })
+          );
+        }
+      }
+      let factor = BigInt(1);
+      for (let i = 0; i < params.token.decimals; i += 1) {
+        factor *= BigInt(10);
+      }
+      const amountRaw = BigInt(Math.trunc(Number(params.amount || "0") * Number(factor)));
+      const data = new Uint8Array(10);
+      data[0] = 12;
+      let remaining = amountRaw;
+      const mask = BigInt(255);
+      for (let i = 0; i < 8; i += 1) {
+        data[1 + i] = Number(remaining & mask);
+        remaining >>= BigInt(8);
+      }
+      data[9] = params.token.decimals;
+      const transferIx = new TransactionInstruction({
+        programId: TOKEN_PROGRAM_ID,
+        keys: [
+          { pubkey: sourceAta, isSigner: false, isWritable: true },
+          { pubkey: mint, isSigner: false, isWritable: false },
+          { pubkey: destinationTokenAccount, isSigner: false, isWritable: true },
+          { pubkey: owner, isSigner: true, isWritable: false }
+        ],
+        data: Buffer.from(data)
+      });
+      tx.add(transferIx);
+      tx.feePayer = owner;
+      const { blockhash } = yield sendConnection.getLatestBlockhash("confirmed");
+      tx.recentBlockhash = blockhash;
+      if (destinationTokenAccountSigner) {
+        tx.partialSign(destinationTokenAccountSigner);
+      }
+      let signature;
+      if (publicKey && sendTransaction) {
+        signature = yield sendTransaction(tx, sendConnection);
+      } else if (phantom) {
+        const res = yield phantom.signAndSendTransaction(tx);
+        signature = res.signature;
+      } else {
+        throw new Error("No Solana signer available");
+      }
+      return { txId: signature };
+    }),
+    [publicKey, rpcEndpoint, sendTransaction, writeContractAsync]
+  );
+}
+
+// src/deposit/use-wallet-transaction-status.ts
+import { useMemo as useMemo2 } from "react";
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+import { formatEther } from "viem";
+import { Connection as Connection3 } from "@solana/web3.js";
+import { useWaitForTransactionReceipt } from "wagmi";
+function useWalletTransactionStatus({
+  chainId,
+  txId
+}) {
+  var _a;
+  const { solanaRpcUrl } = useAggUiConfig();
+  const rpcEndpoint = solanaRpcUrl != null ? solanaRpcUrl : DEFAULT_SOLANA_RPC_ENDPOINT;
+  const isSvm = chainId !== void 0 && SVM_CHAIN_IDS.has(chainId);
+  const evmHash = !isSvm && txId ? txId : void 0;
+  const evmReceipt = useWaitForTransactionReceipt({
+    chainId,
+    hash: evmHash,
+    query: {
+      enabled: !!evmHash && !!chainId,
+      refetchInterval: 2e3
+    }
+  });
+  const connection = useMemo2(() => new Connection3(rpcEndpoint, "confirmed"), [rpcEndpoint]);
+  const svmQuery = useQuery2({
+    queryKey: ["wallet-transaction-status", chainId != null ? chainId : null, txId != null ? txId : null],
+    enabled: isSvm && !!txId,
+    refetchInterval: (query) => query.state.data === "settled" || query.state.data === "error" ? false : 2e3,
+    queryFn: () => __async(null, null, function* () {
+      if (!txId) return "submitted";
+      const [status] = (yield connection.getSignatureStatuses([txId], { searchTransactionHistory: true })).value;
+      if (!status) return "submitted";
+      if (status.err) return "error";
+      if (status.confirmationStatus === "confirmed" || status.confirmationStatus === "finalized") {
+        return "settled";
+      }
+      return "confirming";
+    })
+  });
+  if (isSvm) {
+    return { status: txId ? (_a = svmQuery.data) != null ? _a : "submitted" : null, gasFee: "" };
+  }
+  if (!txId) {
+    return { status: null, gasFee: "" };
+  }
+  if (evmReceipt.isError) {
+    return { status: "error", gasFee: "" };
+  }
+  if (!evmReceipt.data) {
+    return { status: evmReceipt.isPending ? "confirming" : "submitted", gasFee: "" };
+  }
+  const effectiveGasPrice = evmReceipt.data.effectiveGasPrice;
+  const gasFeeWei = effectiveGasPrice * evmReceipt.data.gasUsed;
+  const gasFeeEth = Number(formatEther(gasFeeWei));
+  const gasFee = gasFeeEth > 0 ? `${gasFeeEth.toFixed(6)} ETH` : "";
+  return { status: "settled", gasFee };
+}
+
+// src/deposit/use-deposit-flow.ts
+import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo3, useRef, useState as useState2 } from "react";
+import { useAccount as useAccount2, useSwitchChain } from "wagmi";
+import { useWallet as useSolanaWallet } from "@solana/wallet-adapter-react";
+function useDepositFlow(options) {
+  var _a, _b;
+  const { open, onOpenChange } = options;
+  const { user } = useAggAuthState();
+  const { walletActions } = useAggUiConfig();
+  const { totalBalance } = useAggBalanceState();
+  const deposit = useDepositAddresses({ enabled: !!user });
+  const { supportedChains } = deposit;
+  const { mutate: syncBalancesMutate } = useSyncBalances();
+  const defaultSendToken = useWalletSendToken();
+  const sendToken = (_a = walletActions == null ? void 0 : walletActions.sendToken) != null ? _a : defaultSendToken;
+  const { mutateAsync: getRampQuotes } = useRampQuotes();
+  const { mutateAsync: createRampSession } = useRampSession();
+  const [depositAmount, setDepositAmount] = useState2("");
+  const [cardAmount, setCardAmount] = useState2("");
+  const [cardNetwork, setCardNetwork] = useState2("solana");
+  const [walletModalChainId, setWalletModalChainId] = useState2(null);
+  const [walletModalTokenSymbol, setWalletModalTokenSymbol] = useState2(null);
+  const [walletTransaction, setWalletTransaction] = useState2(null);
+  const [walletTransactionError, setWalletTransactionError] = useState2(null);
+  const [walletTransactionErrorTone, setWalletTransactionErrorTone] = useState2(
+    "error"
+  );
+  const [pendingCardPurchaseSummary, setPendingCardPurchaseSummary] = useState2(null);
+  const rampRedirectHandled = useRef(false);
+  useEffect2(() => {
+    var _a2, _b2;
+    if (rampRedirectHandled.current) return;
+    if (typeof window === "undefined") return;
+    const url = new URL(window.location.href);
+    const cryptoAmount = url.searchParams.get("cryptoAmount");
+    const cryptoCurrency = url.searchParams.get("cryptoCurrency");
+    if (!cryptoAmount) return;
+    rampRedirectHandled.current = true;
+    const network = (_a2 = url.searchParams.get("network")) != null ? _a2 : "";
+    const totalFee = (_b2 = url.searchParams.get("totalFeeInFiat")) != null ? _b2 : "";
+    setPendingCardPurchaseSummary({
+      amountReceived: `+${cryptoAmount} ${cryptoCurrency != null ? cryptoCurrency : "USDC"}`,
+      network: network.charAt(0).toUpperCase() + network.slice(1),
+      fees: totalFee ? `$${totalFee}` : ""
+    });
+    onOpenChange(true);
+  }, []);
+  const { chainId: connectedChainId, address: connectedAddress } = useAccount2();
+  const { switchChainAsync } = useSwitchChain();
+  const { publicKey: solanaPublicKey } = useSolanaWallet();
+  const balanceChainId = walletModalChainId ? Number(walletModalChainId) : connectedChainId;
+  const selectedChainTokens = useMemo3(() => {
+    var _a2;
+    if (!supportedChains || !balanceChainId) return [];
+    const chain = supportedChains.find((c) => c.chainId === balanceChainId);
+    return (_a2 = chain == null ? void 0 : chain.tokens) != null ? _a2 : [];
+  }, [supportedChains, balanceChainId]);
+  const selectedTokenMeta = useMemo3(() => {
+    if (!walletModalTokenSymbol) return void 0;
+    const match = selectedChainTokens.find((t) => t.symbol === walletModalTokenSymbol);
+    return match ? { address: match.address, decimals: match.decimals } : void 0;
+  }, [selectedChainTokens, walletModalTokenSymbol]);
+  const authSvmAddress = useMemo3(() => {
+    var _a2;
+    const wallets = user == null ? void 0 : user.wallets;
+    return (_a2 = wallets == null ? void 0 : wallets.find((w) => w.chain === "solana" || w.chain === "svm")) == null ? void 0 : _a2.address;
+  }, [user]);
+  const isSvmBalanceChain = balanceChainId !== void 0 && SVM_CHAIN_IDS.has(balanceChainId);
+  const walletAddress = useMemo3(() => {
+    var _a2, _b2, _c;
+    if (isSvmBalanceChain) {
+      return (_b2 = (_a2 = solanaPublicKey == null ? void 0 : solanaPublicKey.toBase58()) != null ? _a2 : authSvmAddress) != null ? _b2 : "";
+    }
+    return (_c = connectedAddress != null ? connectedAddress : getWalletAddressFromUserProfile(user)) != null ? _c : "";
+  }, [authSvmAddress, connectedAddress, isSvmBalanceChain, solanaPublicKey, user]);
+  const walletLabel = useMemo3(() => {
+    return walletAddress ? `${walletAddress.slice(0, 6)}...${walletAddress.slice(-4)}` : "\u2014";
+  }, [walletAddress]);
+  const { balance: walletBalance, isLoading: isWalletBalanceLoading } = useWalletTokenBalance({
+    isOpen: open,
+    chainId: balanceChainId,
+    tokenAddress: selectedTokenMeta == null ? void 0 : selectedTokenMeta.address,
+    decimals: selectedTokenMeta == null ? void 0 : selectedTokenMeta.decimals,
+    svmAddress: authSvmAddress
+  });
+  const { status: observedWalletTransactionStatus, gasFee: walletTransactionGasFee } = useWalletTransactionStatus({
+    chainId: walletTransaction == null ? void 0 : walletTransaction.chainId,
+    txId: (_b = walletTransaction == null ? void 0 : walletTransaction.txId) != null ? _b : null
+  });
+  const walletTransactionStatus = walletTransactionError ? "error" : walletTransaction ? observedWalletTransactionStatus != null ? observedWalletTransactionStatus : "submitted" : void 0;
+  const syncedDepositTxIdRef = useRef(null);
+  useEffect2(() => {
+    if (walletTransactionStatus !== "settled" || !(walletTransaction == null ? void 0 : walletTransaction.txId)) return;
+    if (syncedDepositTxIdRef.current === walletTransaction.txId) return;
+    syncedDepositTxIdRef.current = walletTransaction.txId;
+    syncBalancesMutate();
+  }, [syncBalancesMutate, walletTransaction == null ? void 0 : walletTransaction.txId, walletTransactionStatus]);
+  const handleDepositModalOpenChange = useCallback2(
+    (isOpen) => {
+      if (!isOpen) {
+        setDepositAmount("");
+        setCardAmount("");
+        setCardNetwork("solana");
+        setWalletModalChainId(null);
+        setWalletModalTokenSymbol(null);
+        setWalletTransaction(null);
+        setWalletTransactionError(null);
+        setWalletTransactionErrorTone("error");
+        setPendingCardPurchaseSummary(null);
+        syncedDepositTxIdRef.current = null;
+      }
+      onOpenChange(isOpen);
+    },
+    [onOpenChange]
+  );
+  const handleConfirmWalletDeposit = useCallback2(
+    (params) => __async(null, null, function* () {
+      var _a2, _b2, _c;
+      const { address, amount, chainId, token } = params;
+      const chain = (_a2 = supportedChains == null ? void 0 : supportedChains.find((c) => c.chainId === chainId)) != null ? _a2 : null;
+      const tokenMeta = (_b2 = chain == null ? void 0 : chain.tokens.find((t) => t.symbol === token)) != null ? _b2 : null;
+      try {
+        setWalletTransactionError(null);
+        setWalletTransactionErrorTone("error");
+        const isEvmTarget = !SVM_CHAIN_IDS.has(chainId);
+        if (isEvmTarget && connectedChainId && connectedChainId !== chainId) {
+          yield switchChainAsync({ chainId });
+        }
+        const { txId } = yield sendToken({
+          chainId,
+          token: {
+            symbol: token,
+            address: tokenMeta == null ? void 0 : tokenMeta.address,
+            decimals: (_c = tokenMeta == null ? void 0 : tokenMeta.decimals) != null ? _c : 6
+          },
+          to: address,
+          amount
+        });
+        setWalletTransaction({ chainId, txId });
+      } catch (err) {
+        setWalletTransaction(null);
+        const normalizedError = normalizeWalletError(err, supportedChains);
+        setWalletTransactionError(normalizedError.message);
+        setWalletTransactionErrorTone(normalizedError.tone);
+        throw err;
+      }
+    }),
+    [connectedChainId, sendToken, supportedChains, switchChainAsync]
+  );
+  const handleGetCardQuotes = useCallback2(
+    (params) => __async(null, null, function* () {
+      const quotes = yield getRampQuotes(params);
+      return quotes.map(
+        (q, i) => ({
+          id: q.serviceProvider,
+          name: q.serviceProvider,
+          quote: `~ ${q.destinationAmount.toFixed(2)} USDC`,
+          fee: `$${q.totalFee.toFixed(2)}`,
+          badge: i === 0 ? "best" : q.lowKyc ? "low-kyc" : void 0
+        })
+      );
+    }),
+    [getRampQuotes]
+  );
+  const handleCreateCardSession = useCallback2(
+    (params) => __async(null, null, function* () {
+      if (!params.walletAddress) {
+        throw new Error("Deposit address not available for the selected network");
+      }
+      const session = yield createRampSession(params);
+      return {
+        id: session.id,
+        widgetUrl: session.widgetUrl,
+        serviceProviderWidgetUrl: session.serviceProviderWidgetUrl
+      };
+    }),
+    [createRampSession]
+  );
+  const cardRedirectUrl = typeof window !== "undefined" ? `${window.location.origin}/profile?tab=activity` : void 0;
+  return {
+    open,
+    onOpenChange: handleDepositModalOpenChange,
+    pendingCardPurchaseSummary,
+    walletFlow: {
+      balance: totalBalance != null ? totalBalance : 0,
+      walletLabel,
+      walletBalance,
+      isWalletBalanceLoading,
+      amount: depositAmount,
+      formErrorMessage: walletTransaction ? void 0 : walletTransactionError != null ? walletTransactionError : void 0,
+      formErrorTone: walletTransactionErrorTone,
+      transactionStatus: walletTransactionStatus,
+      transactionErrorMessage: walletTransactionError != null ? walletTransactionError : void 0,
+      successSummary: {
+        fromWallet: walletLabel,
+        gasFee: walletTransactionGasFee
+      }
+    },
+    onWalletAmountChange: setDepositAmount,
+    onWalletMax: useCallback2(() => setDepositAmount(String(walletBalance)), [walletBalance]),
+    onConfirmWalletDeposit: handleConfirmWalletDeposit,
+    onWalletNetworkChange: setWalletModalChainId,
+    onWalletTokenChange: setWalletModalTokenSymbol,
+    initialWalletChainId: connectedChainId ? String(connectedChainId) : void 0,
+    connectedWalletKind: connectedChainId && !solanaPublicKey ? "evm" : solanaPublicKey && !connectedChainId ? "solana" : void 0,
+    sendCryptoConfig: { minDeposit: "$1", feeEstimate: "~$0.01", eta: "~30s" },
+    onDoneSendCrypto: useCallback2(
+      () => handleDepositModalOpenChange(false),
+      [handleDepositModalOpenChange]
+    ),
+    cardFlow: {
+      amount: cardAmount,
+      currency: "USD",
+      tokenOptions: [{ value: "USDC", label: "USDC" }],
+      selectedToken: "USDC",
+      selectedNetwork: cardNetwork,
+      providers: [],
+      purchaseSummary: { amountReceived: "", network: "", fees: "" },
+      minAmount: 11
+    },
+    onCardAmountChange: setCardAmount,
+    onCardNetworkChange: setCardNetwork,
+    onDoneCardPurchase: useCallback2(() => {
+      syncBalancesMutate();
+      if (typeof window !== "undefined") {
+        window.history.replaceState({}, "", window.location.pathname);
+      }
+    }, [syncBalancesMutate]),
+    cardRedirectUrl,
+    onGetCardQuotes: handleGetCardQuotes,
+    onCreateCardSession: handleCreateCardSession
+  };
+}
+export {
+  DEFAULT_SOLANA_RPC_ENDPOINT,
+  SVM_CHAIN_IDS,
+  normalizeWalletError,
+  useDepositAddresses,
+  useDepositFlow,
+  useSyncBalances,
+  useWalletSendToken,
+  useWalletTokenBalance,
+  useWalletTransactionStatus
+};