@turtleclub/hooks 0.5.0-beta.41 → 0.5.0-beta.43

package/dist/index.cjs

@@ -140,7 +140,10 @@ __export(index_exports, {
   productsQueries: () => productsQueries,
   queries: () => queries,
   requestStreamSignature: () => requestStreamSignature,
+  routeMetadataSchema: () => routeMetadataSchema,
+  routeStepSchema: () => routeStepSchema,
   routeToken: () => routeToken,
+  routeTokenSchema: () => routeTokenSchema,
   routerStep: () => routerStep,
   routerSubstep: () => routerSubstep,
   snapshotSchema: () => snapshotSchema,
@@ -165,7 +168,7 @@ __export(index_exports, {
   transactionSchema: () => transactionSchema,
   txResponseItemSchema: () => txResponseItemSchema,
   useAttributeAction: () => useAttributeAction,
-  useBalance: () => useBalance,
+  useBalance: () => useBalance2,
   useCancelDepositAction: () => useCancelDepositAction,
   useCancelWithdrawAction: () => useCancelWithdrawAction,
   useCheckMembership: () => useCheckMembership,
@@ -179,7 +182,11 @@ __export(index_exports, {
   useCreateWithdrawInteraction: () => useCreateWithdrawInteraction,
   useDeleteProduct: () => useDeleteProduct,
   useDepositAction: () => useDepositAction,
+  useDepositFlow: () => useDepositFlow,
+  useDepositSelection: () => useDepositSelection,
+  useDepositValidation: () => useDepositValidation,
   useDeposits: () => useDeposits,
+  useEarnDeposit: () => useEarnDeposit,
   useEarnOpportunities: () => useEarnOpportunities,
   useEarnRoute: () => useEarnRoute,
   useEnsoBalances: () => useEnsoBalances,
@@ -204,6 +211,7 @@ __export(index_exports, {
   useSupportedTokens: () => useSupportedTokens,
   useSwapRoute: () => useSwapRoute,
   useTokenBalance: () => useTokenBalance,
+  useTurtleMembershipFlow: () => useTurtleMembershipFlow,
   useUpdateProduct: () => useUpdateProduct,
   useUploadProductLogo: () => useUploadProductLogo,
   useUserById: () => useUserById,
@@ -384,6 +392,14 @@ var vaultConfigSchema = import_zod.z.object({
   managementFee: import_zod.z.number().min(0).max(100).optional().nullable(),
   depositFee: import_zod.z.number().min(0).max(100).optional().nullable(),
   withdrawalFee: import_zod.z.number().min(0).max(100).optional().nullable(),
+  minDepositAmount: import_zod.z.number().optional().nullable(),
+  minDepositValueUSD: import_zod.z.number().optional().nullable(),
+  depositCapAmount: import_zod.z.number().optional().nullable(),
+  depositFillSecs: import_zod.z.number().int().optional().nullable(),
+  lockupPeriodSecs: import_zod.z.number().int().optional().nullable(),
+  asyncDeposit: import_zod.z.boolean().optional().nullable(),
+  asyncWithdraw: import_zod.z.boolean().optional().nullable(),
+  secondaryOnly: import_zod.z.boolean().optional().nullable(),
   createdAt: import_zod.z.string().datetime().optional(),
   updatedAt: import_zod.z.string().datetime().optional()
 });
@@ -1880,15 +1896,259 @@ function useCreateMembership() {
 }
 
 // src/v2/earn-deposits/hooks.ts
-var import_react_query4 = require("@tanstack/react-query");
-function useDeposits({ params, enabled = true }) {
-  return (0, import_react_query4.useQuery)({
-    ...earnDepositsQueries.byParams(params),
-    ...queryDefaults,
-    enabled
-  });
+var import_react_query6 = require("@tanstack/react-query");
+
+// src/v2/earn-deposits/hooks/useDepositValidation.ts
+var import_react = require("react");
+var import_viem = require("viem");
+function calculateUsdValue(amount, token) {
+  if (!token.priceUsd) return null;
+  const formatted = parseFloat((0, import_viem.formatUnits)(amount, token.decimals));
+  return formatted * token.priceUsd;
+}
+function useDepositValidation({
+  opportunity,
+  selectedTokenBalance,
+  amountBigInt,
+  isPending = false,
+  isConfirming = false,
+  walletChainId
+}) {
+  return (0, import_react.useMemo)(() => {
+    if (!opportunity) {
+      return {
+        canDeposit: false,
+        isBelowMinimum: false,
+        isAboveMaximum: false,
+        hasInsufficientBalance: false,
+        isDepositDisabled: false,
+        isZeroAmount: true,
+        isNoTokenSelected: true,
+        minDepositUSD: 0,
+        maxDepositUSD: null,
+        depositDisabledReason: null,
+        depositFee: null,
+        performanceFee: null,
+        managementFee: null,
+        withdrawalFee: null,
+        withdrawalCooldownSecs: null,
+        inputAmountUSD: null,
+        balanceUSD: null,
+        hasAsyncDeposit: false,
+        isSecondaryOnly: false,
+        isWrongChain: false,
+        requiredChainId: null,
+        buttonText: "Select opportunity",
+        validationMessage: "Please select an opportunity"
+      };
+    }
+    const vaultConfig = opportunity.vaultConfig;
+    const depositDisabled = opportunity.depositDisabled ?? false;
+    const depositDisabledReason = opportunity.depositDisabledReason || null;
+    const depositFee = vaultConfig?.depositFee ?? null;
+    const performanceFee = vaultConfig?.performanceFee ?? null;
+    const managementFee = vaultConfig?.managementFee ?? null;
+    const withdrawalFee = vaultConfig?.withdrawalFee ?? null;
+    const withdrawalCooldownSecs = vaultConfig?.withdrawalCooldownSecs ?? null;
+    const hasAsyncDeposit = vaultConfig?.asyncDeposit === true;
+    const isSecondaryOnly = vaultConfig?.secondaryOnly === true;
+    const requiredChainId = Number(opportunity.receiptToken.chain.chainId);
+    const isWrongChain = walletChainId !== void 0 && walletChainId !== requiredChainId;
+    const isNoTokenSelected = !selectedTokenBalance;
+    const isZeroAmount = !amountBigInt || amountBigInt <= 0n;
+    const depositTokenPrice = selectedTokenBalance?.token.priceUsd ?? null;
+    let inputAmountUSD = null;
+    let balanceUSD = null;
+    if (selectedTokenBalance && amountBigInt) {
+      inputAmountUSD = calculateUsdValue(amountBigInt, selectedTokenBalance.token);
+    }
+    if (selectedTokenBalance) {
+      const balanceAmount = BigInt(selectedTokenBalance.amount);
+      balanceUSD = calculateUsdValue(balanceAmount, selectedTokenBalance.token);
+    }
+    const minDepositAmount = vaultConfig?.minDepositAmount ?? 0;
+    const minDepositValueUSD = vaultConfig?.minDepositValueUSD ?? 0;
+    const minDepositUSD = Math.max(
+      minDepositAmount * (depositTokenPrice ?? 0),
+      minDepositValueUSD
+    );
+    const depositCapAmount = vaultConfig?.depositCapAmount;
+    const maxDepositUSD = depositCapAmount && depositTokenPrice ? depositCapAmount * depositTokenPrice : null;
+    let hasInsufficientBalance = false;
+    if (selectedTokenBalance && amountBigInt) {
+      const balanceAmount = BigInt(selectedTokenBalance.amount);
+      hasInsufficientBalance = amountBigInt > balanceAmount;
+    }
+    const isBelowMinimum = !!(inputAmountUSD !== null && minDepositUSD > 0 && inputAmountUSD < minDepositUSD);
+    const isAboveMaximum = !!(inputAmountUSD !== null && maxDepositUSD !== null && inputAmountUSD > maxDepositUSD);
+    let buttonText;
+    let validationMessage = null;
+    if (isWrongChain) {
+      buttonText = "Switch chain";
+    } else if (isPending) {
+      buttonText = "Confirming...";
+    } else if (isConfirming) {
+      buttonText = "Processing...";
+    } else if (depositDisabled) {
+      buttonText = depositDisabledReason || "Deposits disabled";
+      validationMessage = depositDisabledReason || "Deposits are currently disabled for this opportunity";
+    } else if (isNoTokenSelected) {
+      buttonText = "Select token";
+      validationMessage = "Please select a token to deposit";
+    } else if (isZeroAmount) {
+      buttonText = "Enter amount";
+    } else if (hasInsufficientBalance) {
+      buttonText = "Insufficient balance";
+      validationMessage = "Your balance is insufficient for this deposit amount";
+    } else if (isBelowMinimum) {
+      buttonText = `Minimum $${minDepositUSD.toLocaleString()}`;
+      validationMessage = `Minimum deposit is $${minDepositUSD.toLocaleString()}`;
+    } else if (isAboveMaximum && maxDepositUSD != null) {
+      buttonText = `Maximum $${maxDepositUSD.toLocaleString()}`;
+      validationMessage = `Maximum deposit is $${maxDepositUSD.toLocaleString()}`;
+    } else if (isSecondaryOnly) {
+      buttonText = "Buy";
+    } else if (hasAsyncDeposit) {
+      buttonText = "Request deposit";
+    } else {
+      buttonText = "Deposit";
+    }
+    const isDepositing = isPending || isConfirming;
+    const canDeposit = !depositDisabled && !isDepositing && !isNoTokenSelected && !isZeroAmount && !hasInsufficientBalance && !isBelowMinimum && !isAboveMaximum;
+    return {
+      canDeposit,
+      isBelowMinimum,
+      isAboveMaximum,
+      hasInsufficientBalance,
+      isDepositDisabled: depositDisabled,
+      isZeroAmount,
+      isNoTokenSelected,
+      minDepositUSD,
+      maxDepositUSD,
+      depositDisabledReason,
+      depositFee,
+      performanceFee,
+      managementFee,
+      withdrawalFee,
+      withdrawalCooldownSecs,
+      inputAmountUSD,
+      balanceUSD,
+      hasAsyncDeposit,
+      isSecondaryOnly,
+      isWrongChain,
+      requiredChainId,
+      buttonText,
+      validationMessage
+    };
+  }, [opportunity, selectedTokenBalance, amountBigInt, isPending, isConfirming, walletChainId]);
 }
 
+// src/v2/earn-deposits/hooks/useDepositSelection.ts
+var import_react3 = require("react");
+
+// src/v2/balance/hooks/useTokenBalance.ts
+var import_react2 = require("react");
+var import_viem2 = require("viem");
+var import_utils2 = require("@turtleclub/utils");
+function checkInsufficientBalance(tokenBalance, amount) {
+  if (!tokenBalance || !amount) return false;
+  try {
+    const balance = BigInt(tokenBalance.amount);
+    const amountBigInt = (0, import_viem2.parseUnits)(amount, tokenBalance.token.decimals);
+    return balance < amountBigInt;
+  } catch (error) {
+    console.error("[Balance Check Error]", error, { tokenBalance, amount });
+    return true;
+  }
+}
+function useTokenBalance({ tokenBalance, amount, setAmount }) {
+  const token = tokenBalance?.token;
+  const usdValue = (0, import_react2.useMemo)(
+    () => (0, import_utils2.calculateUsdValue)(amount, token?.priceUsd),
+    [amount, token?.priceUsd]
+  );
+  const hasInsufficientBalance = (0, import_react2.useMemo)(
+    () => checkInsufficientBalance(tokenBalance, amount),
+    [tokenBalance, amount]
+  );
+  const handleMaxClick = (0, import_react2.useCallback)(() => {
+    if (!tokenBalance?.token || !tokenBalance.amount) return;
+    const maxAmount = (0, import_utils2.calculateMaxAmount)(tokenBalance.amount, tokenBalance.token.decimals);
+    setAmount(maxAmount);
+  }, [tokenBalance, setAmount]);
+  const amountBigInt = (0, import_react2.useMemo)(() => {
+    if (!token || !amount) return void 0;
+    try {
+      return (0, import_viem2.parseUnits)(amount, token.decimals);
+    } catch {
+      return void 0;
+    }
+  }, [amount, token]);
+  return {
+    usdValue,
+    hasInsufficientBalance,
+    handleMaxClick,
+    amountBigInt
+  };
+}
+
+// src/v2/earn-deposits/hooks/useDepositSelection.ts
+function useDepositSelection({
+  balances,
+  opportunityId
+}) {
+  const [selectedTokenAddress, setSelectedTokenAddress] = (0, import_react3.useState)();
+  const [amount, setAmount] = (0, import_react3.useState)();
+  (0, import_react3.useEffect)(() => {
+    setSelectedTokenAddress(void 0);
+    setAmount(void 0);
+  }, [opportunityId]);
+  (0, import_react3.useEffect)(() => {
+    if (balances.length === 0) return;
+    const tokenExistsInBalances = balances.some(
+      (b) => b.token.address === selectedTokenAddress
+    );
+    if (!selectedTokenAddress || !tokenExistsInBalances) {
+      setSelectedTokenAddress(balances[0].token.address);
+    }
+  }, [selectedTokenAddress, balances]);
+  const selectedTokenBalance = (0, import_react3.useMemo)(
+    () => balances.find((b) => b.token.address === selectedTokenAddress) ?? null,
+    [balances, selectedTokenAddress]
+  );
+  const { handleMaxClick, amountBigInt, usdValue, hasInsufficientBalance } = useTokenBalance({
+    tokenBalance: selectedTokenBalance,
+    amount,
+    setAmount
+  });
+  const reset = (0, import_react3.useCallback)(() => {
+    setSelectedTokenAddress(void 0);
+    setAmount(void 0);
+  }, []);
+  return {
+    selectedTokenAddress,
+    setSelectedTokenAddress,
+    amount,
+    setAmount,
+    selectedTokenBalance,
+    amountBigInt,
+    usdValue,
+    hasInsufficientBalance,
+    handleMaxClick,
+    reset
+  };
+}
+
+// src/v2/earn-deposits/hooks/useDepositFlow.ts
+var import_react5 = require("react");
+
+// src/v2/earn-actions/useEarnDeposit.ts
+var import_react4 = require("react");
+var import_react_query5 = require("@tanstack/react-query");
+
+// src/v2/earn-actions/hooks.ts
+var import_react_query4 = require("@tanstack/react-query");
+
 // src/v2/earn-actions/schema.ts
 var import_zod14 = require("zod");
 var transactionSchema = import_zod14.z.object({
@@ -1898,10 +2158,29 @@ var transactionSchema = import_zod14.z.object({
   value: import_zod14.z.string(),
   gasLimit: import_zod14.z.string().optional()
 });
+var routeTokenSchema = import_zod14.z.object({
+  address: import_zod14.z.string(),
+  symbol: import_zod14.z.string(),
+  decimals: import_zod14.z.number().int(),
+  logoUrl: import_zod14.z.string()
+});
+var routeStepSchema = import_zod14.z.object({
+  action: import_zod14.z.string(),
+  from: routeTokenSchema,
+  to: routeTokenSchema
+});
+var routeMetadataSchema = import_zod14.z.object({
+  provider: import_zod14.z.string(),
+  providerImg: import_zod14.z.string(),
+  amountOut: import_zod14.z.string(),
+  gas: import_zod14.z.string(),
+  route: import_zod14.z.array(routeStepSchema)
+});
 var txResponseItemSchema = import_zod14.z.object({
   type: import_zod14.z.string().optional(),
   description: import_zod14.z.string().optional(),
-  transaction: transactionSchema
+  transaction: transactionSchema,
+  metadata: routeMetadataSchema.optional()
 });
 var actionResponseSchema = import_zod14.z.object({
   actionId: import_zod14.z.string().uuid().optional(),
@@ -1975,10 +2254,9 @@ var createWithdrawInteraction = createWithdrawAction;
 var createClaimWithdrawInteraction = createClaimWithdrawAction;
 
 // src/v2/earn-actions/hooks.ts
-var import_react_query5 = require("@tanstack/react-query");
 function createActionHook(mutationFn) {
   return function useAction(options) {
-    return (0, import_react_query5.useMutation)({
+    return (0, import_react_query4.useMutation)({
       mutationFn,
       ...options
     });
@@ -1991,7 +2269,7 @@ var useClaimDepositAction = createActionHook(createClaimDepositAction);
 var useCancelDepositAction = createActionHook(createCancelDepositAction);
 var useCancelWithdrawAction = createActionHook(createCancelWithdrawAction);
 function useAttributeAction(options) {
-  return (0, import_react_query5.useMutation)({
+  return (0, import_react_query4.useMutation)({
     mutationFn: attributeAction,
     ...options
   });
@@ -2000,14 +2278,277 @@ var useCreateDepositInteraction = useDepositAction;
 var useCreateWithdrawInteraction = useWithdrawAction;
 var useCreateClaimWithdrawInteraction = useClaimWithdrawAction;
 
+// src/v2/balance/queries.ts
+var import_query_key_factory15 = require("@lukemorales/query-key-factory");
+
+// src/v2/balance/schema.ts
+var import_zod15 = require("zod");
+var portfolioTokenSchema = import_zod15.z.object({
+  id: import_zod15.z.string(),
+  address: import_zod15.z.string(),
+  name: import_zod15.z.string(),
+  symbol: import_zod15.z.string(),
+  decimals: import_zod15.z.number(),
+  isNative: import_zod15.z.boolean(),
+  logoUrl: import_zod15.z.string().nullable(),
+  amount: import_zod15.z.string(),
+  // Portfolio-specific field (decimal format)
+  price: import_zod15.z.string().nullable().transform((val) => val ? parseFloat(val) : null),
+  // Portfolio-specific field
+  // Chain with optional fields to match Portfolio API response
+  chain: chainSchema.partial().required({ chainId: true })
+});
+var portfolioWalletSchema = import_zod15.z.object({
+  id: import_zod15.z.string().optional(),
+  address: import_zod15.z.string(),
+  blockchain: import_zod15.z.string().optional(),
+  tokens: import_zod15.z.array(portfolioTokenSchema)
+});
+var portfolioHoldingsSchema = import_zod15.z.object({
+  wallets: import_zod15.z.array(portfolioWalletSchema)
+});
+var portfolioBalanceResponseSchema = import_zod15.z.object({
+  portfolio: import_zod15.z.object({
+    holdings: portfolioHoldingsSchema
+  })
+});
+
+// src/v2/balance/api.ts
+async function getPortfolioBalance(address, options) {
+  const data = await apiClient.fetch(`/wallet/${address}/balance`, {
+    method: "GET",
+    domain: "api",
+    debug: options?.debug
+  });
+  const result = portfolioBalanceResponseSchema.safeParse(data);
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to parse portfolio balance: ${result.error.message}`);
+  }
+  return result.data;
+}
+
+// src/v2/balance/queries.ts
+var balanceQueries = (0, import_query_key_factory15.createQueryKeys)("balance", {
+  // Portfolio balance by address
+  portfolio: (address) => ({
+    queryKey: [address],
+    queryFn: () => getPortfolioBalance(address)
+  })
+});
+
+// src/v2/earn-actions/useEarnDeposit.ts
+var DEFAULT_SLIPPAGE_BPS = 50;
+function useEarnDeposit(options) {
+  const { opportunity, userAddress, distributorId, executeTransaction, onSuccess, referralCode } = options;
+  const queryClient = (0, import_react_query5.useQueryClient)();
+  const [isConfirming, setIsConfirming] = (0, import_react4.useState)(false);
+  const [error, setError] = (0, import_react4.useState)(null);
+  const [metadata, setMetadata] = (0, import_react4.useState)(null);
+  const [hasApprove, setHasApprove] = (0, import_react4.useState)(false);
+  const depositAction = useDepositAction();
+  const attributeAction2 = useAttributeAction();
+  const toTransactionRequest = (0, import_react4.useCallback)((txItem) => {
+    return {
+      to: txItem.transaction.to,
+      data: txItem.transaction.data,
+      value: txItem.transaction.value,
+      gasLimit: txItem.transaction.gasLimit
+    };
+  }, []);
+  const executeTransactionsSequentially = (0, import_react4.useCallback)(
+    async (transactions) => {
+      let lastTxHash;
+      for (const txItem of transactions) {
+        const txRequest = toTransactionRequest(txItem);
+        const txHash = await executeTransaction(txRequest);
+        if (!txHash) {
+          throw new Error(`Transaction failed: ${txItem.description || "Unknown transaction"}`);
+        }
+        lastTxHash = txHash;
+      }
+      return lastTxHash;
+    },
+    [executeTransaction, toTransactionRequest]
+  );
+  const attributeTransactionSafely = (0, import_react4.useCallback)(
+    async (actionId, txHash) => {
+      try {
+        await attributeAction2.mutateAsync({ actionId, txHash });
+      } catch (attributeError) {
+        console.warn("[useEarnDeposit] Attribution failed (non-blocking):", attributeError);
+      }
+    },
+    [attributeAction2]
+  );
+  const deposit = (0, import_react4.useCallback)(
+    async (amount, tokenAddress, slippage = DEFAULT_SLIPPAGE_BPS) => {
+      setError(null);
+      if (!opportunity?.id) {
+        const err = new Error("No opportunity selected");
+        setError(err);
+        throw err;
+      }
+      if (!userAddress) {
+        const err = new Error("No wallet connected");
+        setError(err);
+        throw err;
+      }
+      if (amount <= 0n) {
+        const err = new Error("Amount must be greater than 0");
+        setError(err);
+        throw err;
+      }
+      try {
+        const actionResponse = await depositAction.mutateAsync({
+          opportunityId: opportunity.id,
+          userAddress,
+          tokenIn: tokenAddress,
+          amount: amount.toString(),
+          distributorId,
+          referralCode,
+          slippageBps: slippage
+        });
+        const { actionId, transactions } = actionResponse;
+        if (!transactions || transactions.length === 0) {
+          throw new Error("No transactions returned from deposit action");
+        }
+        const txWithMetadata = transactions.find((tx) => tx.metadata);
+        if (txWithMetadata?.metadata) {
+          setMetadata(txWithMetadata.metadata);
+        }
+        const hasApproveTx = transactions.some((tx) => tx.type === "approve");
+        setHasApprove(hasApproveTx);
+        setIsConfirming(true);
+        const finalTxHash = await executeTransactionsSequentially(transactions);
+        if (actionId && finalTxHash) {
+          await attributeTransactionSafely(actionId, finalTxHash);
+        }
+        if (userAddress) {
+          queryClient.invalidateQueries({
+            queryKey: balanceQueries.portfolio(userAddress).queryKey
+          });
+        }
+        onSuccess?.();
+        return finalTxHash;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        throw error2;
+      } finally {
+        setIsConfirming(false);
+      }
+    },
+    [
+      opportunity?.id,
+      userAddress,
+      distributorId,
+      referralCode,
+      depositAction,
+      executeTransactionsSequentially,
+      attributeTransactionSafely,
+      queryClient,
+      onSuccess
+    ]
+  );
+  const resetMetadata = (0, import_react4.useCallback)(() => {
+    setMetadata(null);
+    setHasApprove(false);
+  }, []);
+  return {
+    deposit,
+    isPending: depositAction.isPending,
+    isConfirming,
+    error,
+    metadata,
+    hasApprove,
+    resetMetadata
+  };
+}
+
+// src/v2/earn-deposits/hooks/useDepositFlow.ts
+function useDepositFlow({
+  opportunity,
+  userAddress,
+  distributorId,
+  balances,
+  executeTransaction,
+  onDepositSuccess,
+  refetchBalances,
+  slippageBps,
+  walletChainId
+}) {
+  const selection = useDepositSelection({
+    balances,
+    opportunityId: opportunity?.id
+  });
+  const {
+    deposit: executeDeposit,
+    isPending,
+    isConfirming,
+    error,
+    metadata,
+    hasApprove,
+    resetMetadata
+  } = useEarnDeposit({
+    opportunity,
+    userAddress,
+    distributorId,
+    executeTransaction,
+    onSuccess: () => {
+      selection.setAmount(void 0);
+      refetchBalances?.();
+      onDepositSuccess?.();
+    }
+  });
+  const isDepositing = isPending || isConfirming;
+  const validation = useDepositValidation({
+    opportunity,
+    selectedTokenBalance: selection.selectedTokenBalance,
+    amountBigInt: selection.amountBigInt,
+    isPending,
+    isConfirming,
+    walletChainId
+  });
+  const execute = (0, import_react5.useCallback)(async () => {
+    if (!selection.amountBigInt || !selection.selectedTokenAddress) {
+      return void 0;
+    }
+    return executeDeposit(selection.amountBigInt, selection.selectedTokenAddress, slippageBps);
+  }, [selection.amountBigInt, selection.selectedTokenAddress, executeDeposit, slippageBps]);
+  return {
+    selection,
+    validation,
+    deposit: {
+      execute,
+      isPending,
+      isConfirming,
+      isDepositing,
+      error,
+      metadata,
+      hasApprove,
+      resetMetadata
+    }
+  };
+}
+
+// src/v2/earn-deposits/hooks.ts
+function useDeposits({ params, enabled = true }) {
+  return (0, import_react_query6.useQuery)({
+    ...earnDepositsQueries.byParams(params),
+    ...queryDefaults,
+    enabled
+  });
+}
+
 // src/v2/enso-balances/hooks.ts
-var import_react = require("react");
-var import_react_query6 = require("@tanstack/react-query");
+var import_react6 = require("react");
+var import_react_query7 = require("@tanstack/react-query");
 function useMultiChainBalances({
   chainIds,
   address
 }) {
-  const queries2 = (0, import_react_query6.useQueries)({
+  const queries2 = (0, import_react_query7.useQueries)({
     queries: chainIds.map((chainId) => ({
       ...ensoBalancesQueries.byParams({ user: address || "", chain: chainId }),
       enabled: !!address,
@@ -2024,7 +2565,7 @@ function useMultiChainBalances({
       query.refetch();
     });
   };
-  const balances = (0, import_react.useMemo)(() => {
+  const balances = (0, import_react6.useMemo)(() => {
     const balanceMap = {};
     queries2.forEach((query, index) => {
       const chainId = chainIds[index];
@@ -2043,9 +2584,9 @@ function useMultiChainBalances({
 }
 
 // src/v2/opportunities/hooks.ts
-var import_react_query7 = require("@tanstack/react-query");
+var import_react_query8 = require("@tanstack/react-query");
 function useOpportunities(options) {
-  return (0, import_react_query7.useQuery)({
+  return (0, import_react_query8.useQuery)({
     ...opportunitiesQueries.all,
     ...queryDefaults,
     select: (data) => {
@@ -2061,7 +2602,7 @@ function useOpportunities(options) {
   });
 }
 function useOpportunity({ id, ...options }) {
-  return (0, import_react_query7.useQuery)({
+  return (0, import_react_query8.useQuery)({
     ...opportunitiesQueries.byId(id),
     ...queryDefaults,
     select: (data) => {
@@ -2076,7 +2617,7 @@ function useOpportunitiesPaginated({
   params,
   enabled = true
 } = {}) {
-  return (0, import_react_query7.useQuery)({
+  return (0, import_react_query8.useQuery)({
     ...opportunitiesQueries.paginated(params),
     ...queryDefaults,
     enabled
@@ -2085,7 +2626,7 @@ function useOpportunitiesPaginated({
 function useOpportunitiesFilterOptions({
   enabled = true
 } = {}) {
-  return (0, import_react_query7.useQuery)({
+  return (0, import_react_query8.useQuery)({
     ...opportunitiesQueries.filterOptions,
     ...queryDefaults,
     enabled
@@ -2093,92 +2634,46 @@ function useOpportunitiesFilterOptions({
 }
 
 // src/v2/products/hooks.ts
-var import_react_query8 = require("@tanstack/react-query");
+var import_react_query9 = require("@tanstack/react-query");
 function useProducts({ filters, enabled = true }) {
-  return (0, import_react_query8.useQuery)({
+  return (0, import_react_query9.useQuery)({
     ...productsQueries.list(filters),
     ...queryDefaults,
     enabled
   });
 }
 function useProduct({ id, enabled = true }) {
-  return (0, import_react_query8.useQuery)({
+  return (0, import_react_query9.useQuery)({
     ...productsQueries.byId(id),
     ...queryDefaults,
     enabled
   });
 }
 function useCreateProduct(options) {
-  return (0, import_react_query8.useMutation)({
+  return (0, import_react_query9.useMutation)({
     mutationFn: (input) => createProduct(input),
     ...options
   });
 }
 function useUpdateProduct(options) {
-  return (0, import_react_query8.useMutation)({
+  return (0, import_react_query9.useMutation)({
     mutationFn: (input) => updateProduct(input),
     ...options
   });
 }
 function useDeleteProduct(options) {
-  return (0, import_react_query8.useMutation)({
+  return (0, import_react_query9.useMutation)({
     mutationFn: (id) => deleteProduct(id),
     ...options
   });
 }
 function useUploadProductLogo(options) {
-  return (0, import_react_query8.useMutation)({
+  return (0, import_react_query9.useMutation)({
     mutationFn: (request) => uploadProductLogo(request),
     ...options
   });
 }
 
-// src/v2/balance/hooks/useTokenBalance.ts
-var import_react2 = require("react");
-var import_viem = require("viem");
-var import_utils2 = require("@turtleclub/utils");
-function checkInsufficientBalance(tokenBalance, amount) {
-  if (!tokenBalance || !amount) return false;
-  try {
-    const balance = BigInt(tokenBalance.amount);
-    const amountBigInt = (0, import_viem.parseUnits)(amount, tokenBalance.token.decimals);
-    return balance < amountBigInt;
-  } catch (error) {
-    console.error("[Balance Check Error]", error, { tokenBalance, amount });
-    return true;
-  }
-}
-function useTokenBalance({ tokenBalance, amount, setAmount }) {
-  const token = tokenBalance?.token;
-  const usdValue = (0, import_react2.useMemo)(
-    () => (0, import_utils2.calculateUsdValue)(amount, token?.priceUsd),
-    [amount, token?.priceUsd]
-  );
-  const hasInsufficientBalance = (0, import_react2.useMemo)(
-    () => checkInsufficientBalance(tokenBalance, amount),
-    [tokenBalance, amount]
-  );
-  const handleMaxClick = (0, import_react2.useCallback)(() => {
-    if (!tokenBalance?.token || !tokenBalance.amount) return;
-    const maxAmount = (0, import_utils2.calculateMaxAmount)(tokenBalance.amount, tokenBalance.token.decimals);
-    setAmount(maxAmount);
-  }, [tokenBalance, setAmount]);
-  const amountBigInt = (0, import_react2.useMemo)(() => {
-    if (!token || !amount) return void 0;
-    try {
-      return (0, import_viem.parseUnits)(amount, token.decimals);
-    } catch {
-      return void 0;
-    }
-  }, [amount, token]);
-  return {
-    usdValue,
-    hasInsufficientBalance,
-    handleMaxClick,
-    amountBigInt
-  };
-}
-
 // src/v2/balance/types.ts
 var BalanceSourcePriority = /* @__PURE__ */ ((BalanceSourcePriority2) => {
   BalanceSourcePriority2[BalanceSourcePriority2["ONCHAIN"] = 1] = "ONCHAIN";
@@ -2187,115 +2682,116 @@ var BalanceSourcePriority = /* @__PURE__ */ ((BalanceSourcePriority2) => {
   return BalanceSourcePriority2;
 })(BalanceSourcePriority || {});
 
-// src/v2/balance/schema.ts
-var import_zod15 = require("zod");
-var portfolioTokenSchema = import_zod15.z.object({
-  id: import_zod15.z.string(),
-  address: import_zod15.z.string(),
-  name: import_zod15.z.string(),
-  symbol: import_zod15.z.string(),
-  decimals: import_zod15.z.number(),
-  isNative: import_zod15.z.boolean(),
-  logoUrl: import_zod15.z.string().nullable(),
-  amount: import_zod15.z.string(),
-  // Portfolio-specific field (decimal format)
-  price: import_zod15.z.string().nullable().transform((val) => val ? parseFloat(val) : null),
-  // Portfolio-specific field
-  // Chain with optional fields to match Portfolio API response
-  chain: chainSchema.partial().required({ chainId: true })
-});
-var portfolioWalletSchema = import_zod15.z.object({
-  id: import_zod15.z.string().optional(),
-  address: import_zod15.z.string(),
-  blockchain: import_zod15.z.string().optional(),
-  tokens: import_zod15.z.array(portfolioTokenSchema)
-});
-var portfolioHoldingsSchema = import_zod15.z.object({
-  wallets: import_zod15.z.array(portfolioWalletSchema)
-});
-var portfolioBalanceResponseSchema = import_zod15.z.object({
-  portfolio: import_zod15.z.object({
-    holdings: portfolioHoldingsSchema
-  })
-});
-
-// src/v2/balance/api.ts
-async function getPortfolioBalance(address, options) {
-  const data = await apiClient.fetch(`/wallet/${address}/balance`, {
-    method: "GET",
-    domain: "api",
-    debug: options?.debug
-  });
-  const result = portfolioBalanceResponseSchema.safeParse(data);
-  if (result.success === false) {
-    console.log("[ZOD ERROR]", result.error);
-    throw new Error(`Failed to parse portfolio balance: ${result.error.message}`);
-  }
-  return result.data;
-}
-
-// src/v2/balance/queries.ts
-var import_query_key_factory15 = require("@lukemorales/query-key-factory");
-var balanceQueries = (0, import_query_key_factory15.createQueryKeys)("balance", {
-  // Portfolio balance by address
-  portfolio: (address) => ({
-    queryKey: [address],
-    queryFn: () => getPortfolioBalance(address)
-  })
-});
-
 // src/v2/balance/hooks/useBalance.ts
-var import_react7 = require("react");
+var import_react10 = require("react");
 
 // src/v2/balance/hooks/useGetOnChainBalance.ts
 var import_wagmi = require("wagmi");
-var import_viem2 = require("viem");
-var import_react3 = require("react");
+var import_viem3 = require("viem");
+var import_react7 = require("react");
+var NATIVE_TOKEN_ADDRESSES = [
+  "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+  "0x0000000000000000000000000000000000000000"
+];
+var QUERY_REFETCH_INTERVAL = 5e3;
+function isNativeToken(token) {
+  return token.isNative || NATIVE_TOKEN_ADDRESSES.includes(token.address.toLowerCase());
+}
 function useGetOnChainBalance({
   tokens,
   chainId,
   address,
   enabled = true
 }) {
-  const contracts = (0, import_react3.useMemo)(() => {
+  const { nativeTokens, erc20Tokens } = (0, import_react7.useMemo)(() => {
+    const native = [];
+    const erc20 = [];
+    for (const token of tokens) {
+      if (isNativeToken(token)) {
+        native.push(token);
+      } else {
+        erc20.push(token);
+      }
+    }
+    return { nativeTokens: native, erc20Tokens: erc20 };
+  }, [tokens]);
+  const nativeToken = nativeTokens[0];
+  const {
+    data: nativeBalanceData,
+    isLoading: isNativeLoading,
+    error: nativeError,
+    refetch: refetchNative
+  } = (0, import_wagmi.useBalance)({
+    address,
+    chainId,
+    query: {
+      ...queryDefaults,
+      enabled: enabled && !!address && nativeTokens.length > 0,
+      refetchInterval: QUERY_REFETCH_INTERVAL,
+      refetchOnWindowFocus: true
+    }
+  });
+  const contracts = (0, import_react7.useMemo)(() => {
     if (!address || !enabled) return [];
-    return tokens.map((token) => ({
-      address: token.address,
-      abi: import_viem2.erc20Abi,
-      functionName: "balanceOf",
-      args: [address],
-      chainId
-    }));
-  }, [tokens, address, chainId, enabled]);
+    return erc20Tokens.map(
+      (token) => ({
+        address: token.address,
+        abi: import_viem3.erc20Abi,
+        functionName: "balanceOf",
+        args: [address],
+        chainId
+      })
+    );
+  }, [erc20Tokens, address, chainId, enabled]);
   const {
-    data: results,
-    isLoading,
-    error,
-    refetch
+    data: erc20Results,
+    isLoading: isErc20Loading,
+    error: erc20Error,
+    refetch: refetchErc20
   } = (0, import_wagmi.useReadContracts)({
     contracts,
     query: {
       ...queryDefaults,
-      enabled: enabled && !!address && tokens.length > 0,
-      refetchInterval: 5e3,
+      enabled: enabled && !!address && erc20Tokens.length > 0,
+      refetchInterval: QUERY_REFETCH_INTERVAL,
       refetchOnWindowFocus: true
     }
   });
-  const balances = (0, import_react3.useMemo)(() => {
-    if (!results || results.length === 0) return [];
-    return tokens.map((token, index) => {
-      const result = results[index];
-      let balance = "0";
-      if (result?.status === "success" && typeof result.result === "bigint") {
-        balance = result.result.toString();
-      }
-      return {
-        token,
-        amount: balance,
+  const balances = (0, import_react7.useMemo)(() => {
+    const result = [];
+    if (nativeToken && nativeBalanceData) {
+      result.push({
+        token: nativeToken,
+        amount: nativeBalanceData.value.toString(),
         source: "onchain"
-      };
-    });
-  }, [results, tokens]);
+      });
+    }
+    if (erc20Results && erc20Results.length > 0) {
+      erc20Tokens.forEach((token, index) => {
+        const erc20Result = erc20Results[index];
+        let balance = "0";
+        if (erc20Result?.status === "success" && typeof erc20Result.result === "bigint") {
+          balance = erc20Result.result.toString();
+        }
+        result.push({
+          token,
+          amount: balance,
+          source: "onchain"
+        });
+      });
+    }
+    return result;
+  }, [nativeToken, nativeBalanceData, erc20Results, erc20Tokens]);
+  const isLoading = nativeTokens.length > 0 && isNativeLoading || erc20Tokens.length > 0 && isErc20Loading;
+  const error = nativeError || erc20Error;
+  const refetch = (0, import_react7.useCallback)(() => {
+    if (nativeTokens.length > 0) {
+      refetchNative();
+    }
+    if (erc20Tokens.length > 0) {
+      refetchErc20();
+    }
+  }, [nativeTokens.length, erc20Tokens.length, refetchNative, refetchErc20]);
   return {
     balances,
     isLoading,
@@ -2305,13 +2801,13 @@ function useGetOnChainBalance({
 }
 
 // src/v2/balance/hooks/usePortfolioBalance.ts
-var import_react_query11 = require("@tanstack/react-query");
-var import_react5 = require("react");
+var import_react_query12 = require("@tanstack/react-query");
+var import_react9 = require("react");
 
 // src/v2/supported-chains/hooks.ts
-var import_react_query9 = require("@tanstack/react-query");
+var import_react_query10 = require("@tanstack/react-query");
 function useSupportedChains() {
-  const { data, isLoading, error, refetch } = (0, import_react_query9.useQuery)({
+  const { data, isLoading, error, refetch } = (0, import_react_query10.useQuery)({
     ...supportedChainsQueries.all,
     ...queryDefaults
   });
@@ -2326,15 +2822,15 @@ function useSupportedChains() {
 }
 
 // src/v2/supported-tokens/hooks.ts
-var import_react_query10 = require("@tanstack/react-query");
-var import_react4 = require("react");
+var import_react_query11 = require("@tanstack/react-query");
+var import_react8 = require("react");
 function useSupportedTokens({
   page = 0,
   limit = 20,
   search,
   enabled = true
 } = {}) {
-  const { data, isLoading, error, refetch } = (0, import_react_query10.useQuery)({
+  const { data, isLoading, error, refetch } = (0, import_react_query11.useQuery)({
     ...supportedTokensQueries.list({ page, limit, search }),
     ...queryDefaults,
     staleTime: 5 * 60 * 1e3,
@@ -2345,7 +2841,7 @@ function useSupportedTokens({
     // Don't refetch on tab focus
     enabled
   });
-  const tokens = (0, import_react4.useMemo)(() => {
+  const tokens = (0, import_react8.useMemo)(() => {
     if (!data?.tokens) return [];
     return data.tokens.map(({ active, ...token }) => token);
   }, [data?.tokens]);
@@ -2365,7 +2861,7 @@ function useSupportedTokens({
 }
 
 // src/v2/balance/hooks/usePortfolioBalance.ts
-var import_viem3 = require("viem");
+var import_viem4 = require("viem");
 function usePortfolioBalance({
   address
 }) {
@@ -2376,14 +2872,14 @@ function usePortfolioBalance({
     isLoading,
     error,
     refetch
-  } = (0, import_react_query11.useQuery)({
+  } = (0, import_react_query12.useQuery)({
     ...balanceQueries.portfolio(address || ""),
     ...queryDefaults,
     enabled: !!address,
     refetchInterval: 1 * 60 * 1e3
     // 1 minute
   });
-  const balances = (0, import_react5.useMemo)(() => {
+  const balances = (0, import_react9.useMemo)(() => {
     if (!portfolioData) return [];
     const tokenBalances = [];
     portfolioData.portfolio.holdings.wallets.forEach((wallet) => {
@@ -2412,7 +2908,7 @@ function usePortfolioBalance({
         };
         let amountInWei;
         try {
-          amountInWei = (0, import_viem3.parseUnits)(portfolioToken.amount, token.decimals).toString();
+          amountInWei = (0, import_viem4.parseUnits)(portfolioToken.amount, token.decimals).toString();
         } catch (error2) {
           console.error("[Portfolio Balance] Failed to parse amount:", {
             amount: portfolioToken.amount,
@@ -2438,49 +2934,8 @@ function usePortfolioBalance({
   };
 }
 
-// src/v2/balance/hooks/useEnsoBalances.ts
-var import_react6 = require("react");
-function useEnsoBalances({
-  address,
-  chainIds
-}) {
-  const { getToken, isLoading: isSupportedTokensLoading } = useSupportedTokens();
-  const {
-    balances: ensoBalances,
-    isLoading,
-    error,
-    refetchAll
-  } = useMultiChainBalances({
-    chainIds,
-    address
-  });
-  const balances = (0, import_react6.useMemo)(() => {
-    if (isSupportedTokensLoading || isLoading) return [];
-    const tokenBalances = [];
-    Object.entries(ensoBalances).forEach(([, chainBalances]) => {
-      chainBalances.forEach((walletBalance) => {
-        const chainId = walletBalance.token.chain.toString();
-        const token = getToken(walletBalance.token.address, chainId);
-        if (!token) return;
-        tokenBalances.push({
-          token,
-          amount: walletBalance.amount,
-          source: "enso"
-        });
-      });
-    });
-    return tokenBalances;
-  }, [ensoBalances, getToken, isSupportedTokensLoading, isLoading]);
-  return {
-    balances,
-    isLoading,
-    error,
-    refetch: refetchAll
-  };
-}
-
 // src/v2/balance/utils.ts
-var import_viem4 = require("viem");
+var import_viem5 = require("viem");
 
 // src/v2/balance/constants.ts
 var EXCLUDE_TOKEN_ADDRESS_LIST = [
@@ -2534,8 +2989,8 @@ function mergeBalancesByPriority(sources, receiptToken) {
     if (a.token.chain.chainId !== b.token.chain.chainId) {
       return Number(a.token.chain.chainId) - Number(b.token.chain.chainId);
     }
-    const balanceA = Number((0, import_viem4.formatUnits)(BigInt(a.amount), a.token.decimals));
-    const balanceB = Number((0, import_viem4.formatUnits)(BigInt(b.amount), b.token.decimals));
+    const balanceA = Number((0, import_viem5.formatUnits)(BigInt(a.amount), a.token.decimals));
+    const balanceB = Number((0, import_viem5.formatUnits)(BigInt(b.amount), b.token.decimals));
     return balanceB - balanceA;
   });
 }
@@ -2558,7 +3013,7 @@ function filterExcludedTokens(balances) {
 }
 
 // src/v2/balance/hooks/useBalance.ts
-function useBalance({
+function useBalance2({
   address,
   chainIds,
   depositOpportunity
@@ -2582,16 +3037,7 @@ function useBalance({
   } = usePortfolioBalance({
     address
   });
-  const {
-    balances: ensoBalances,
-    isLoading: isEnsoLoading,
-    error: ensoError,
-    refetch: refetchEnso
-  } = useEnsoBalances({
-    address,
-    chainIds
-  });
-  const consolidatedBalances = (0, import_react7.useMemo)(() => {
+  const consolidatedBalances = (0, import_react10.useMemo)(() => {
     const sources = [];
     if (depositOpportunity && onChainBalances.length > 0) {
       sources.push(onChainBalances);
@@ -2599,21 +3045,17 @@ function useBalance({
     if (portfolioBalances.length > 0) {
       sources.push(portfolioBalances);
     }
-    if (ensoBalances.length > 0) {
-      sources.push(ensoBalances);
-    }
     const merged = mergeBalancesByPriority(sources, depositOpportunity?.receiptToken);
     const nonZero = filterNonZeroBalances(merged);
     return filterExcludedTokens(nonZero);
-  }, [onChainBalances, portfolioBalances, ensoBalances, depositOpportunity]);
-  const isLoading = isOnChainLoading || isPortfolioLoading || isEnsoLoading;
-  const error = onChainError || portfolioError || ensoError;
+  }, [onChainBalances, portfolioBalances, depositOpportunity]);
+  const isLoading = isOnChainLoading || isPortfolioLoading;
+  const error = onChainError || portfolioError;
   const refetchAll = () => {
     if (depositOpportunity) {
       refetchOnChain();
     }
     refetchPortfolio();
-    refetchEnso();
   };
   return {
     balances: consolidatedBalances,
@@ -2623,10 +3065,51 @@ function useBalance({
   };
 }
 
+// src/v2/balance/hooks/useEnsoBalances.ts
+var import_react11 = require("react");
+function useEnsoBalances({
+  address,
+  chainIds
+}) {
+  const { getToken, isLoading: isSupportedTokensLoading } = useSupportedTokens();
+  const {
+    balances: ensoBalances,
+    isLoading,
+    error,
+    refetchAll
+  } = useMultiChainBalances({
+    chainIds,
+    address
+  });
+  const balances = (0, import_react11.useMemo)(() => {
+    if (isSupportedTokensLoading || isLoading) return [];
+    const tokenBalances = [];
+    Object.entries(ensoBalances).forEach(([, chainBalances]) => {
+      chainBalances.forEach((walletBalance) => {
+        const chainId = walletBalance.token.chain.toString();
+        const token = getToken(walletBalance.token.address, chainId);
+        if (!token) return;
+        tokenBalances.push({
+          token,
+          amount: walletBalance.amount,
+          source: "enso"
+        });
+      });
+    });
+    return tokenBalances;
+  }, [ensoBalances, getToken, isSupportedTokensLoading, isLoading]);
+  return {
+    balances,
+    isLoading,
+    error,
+    refetch: refetchAll
+  };
+}
+
 // src/v2/widget/hooks.ts
-var import_react_query12 = require("@tanstack/react-query");
+var import_react_query13 = require("@tanstack/react-query");
 function useWidgetOpportunities(distributorId) {
-  return (0, import_react_query12.useQuery)({
+  return (0, import_react_query13.useQuery)({
     ...widgetQueries.opportunities(distributorId),
     ...queryDefaults,
     select: (data) => {
@@ -2650,7 +3133,7 @@ function useWidgetOpportunities(distributorId) {
 }
 
 // src/v2/geocheck/useGeocheck.ts
-var import_react_query13 = require("@tanstack/react-query");
+var import_react_query14 = require("@tanstack/react-query");
 var INDEXER_ENDPOINT = "https://api.turtle.xyz";
 async function fetchGeocheck() {
   const url = `${INDEXER_ENDPOINT}/turtle/geocheck`;
@@ -2666,13 +3149,13 @@ async function fetchGeocheck() {
   }
   return data;
 }
-var geocheckQueryOptions = () => (0, import_react_query13.queryOptions)({
+var geocheckQueryOptions = () => (0, import_react_query14.queryOptions)({
   queryKey: ["geocheck"],
   queryFn: fetchGeocheck
 });
 function useGeocheck(options = {}) {
   const { enabled = true, staleTime, gcTime } = options;
-  return (0, import_react_query13.useQuery)({
+  return (0, import_react_query14.useQuery)({
     ...geocheckQueryOptions(),
     enabled,
     staleTime: staleTime ?? 5 * 60 * 1e3,
@@ -2685,39 +3168,39 @@ function useGeocheck(options = {}) {
 }
 
 // src/v2/streams/hooks.ts
-var import_react_query14 = require("@tanstack/react-query");
+var import_react_query15 = require("@tanstack/react-query");
 function useStreams({
   query,
   options
 } = {}) {
-  return (0, import_react_query14.useQuery)(createQueryOptions(streamsQueries.list(query), options));
+  return (0, import_react_query15.useQuery)(createQueryOptions(streamsQueries.list(query), options));
 }
 function useStreamPoints({
   query,
   options
 } = {}) {
-  return (0, import_react_query14.useQuery)(createQueryOptions(streamsQueries.points(query), options));
+  return (0, import_react_query15.useQuery)(createQueryOptions(streamsQueries.points(query), options));
 }
 function useStreamWallets({
   query,
   options
 }) {
-  return (0, import_react_query14.useQuery)(createQueryOptions(streamsQueries.wallets(query), options));
+  return (0, import_react_query15.useQuery)(createQueryOptions(streamsQueries.wallets(query), options));
 }
 function useStreamWalletDetails({
   query,
   options
 }) {
-  return (0, import_react_query14.useQuery)(createQueryOptions(streamsQueries.walletDetails(query), options));
+  return (0, import_react_query15.useQuery)(createQueryOptions(streamsQueries.walletDetails(query), options));
 }
 function useStreamSupportedChains({
   options
 } = {}) {
-  return (0, import_react_query14.useQuery)(createQueryOptions(streamsQueries.supportedChains, options));
+  return (0, import_react_query15.useQuery)(createQueryOptions(streamsQueries.supportedChains, options));
 }
 
 // src/v2/swap/useSwapRoute.ts
-var import_react8 = require("react");
+var import_react12 = require("react");
 
 // src/v2/swap/route-processor.ts
 var import_utils4 = require("@turtleclub/utils");
@@ -2776,7 +3259,7 @@ function toEnsoTokenAddress(address) {
   return address;
 }
 function useSwapRoute(isEnabled, userAddress, distributorId, options, referralCode) {
-  const params = (0, import_react8.useMemo)(() => {
+  const params = (0, import_react12.useMemo)(() => {
     if (!options || !isEnabled) return void 0;
     return {
       ...options,
@@ -2785,7 +3268,7 @@ function useSwapRoute(isEnabled, userAddress, distributorId, options, referralCo
       referral_code: referralCode
     };
   }, [options, userAddress, distributorId, referralCode]);
-  const hasRequiredParams = (0, import_react8.useMemo)(() => {
+  const hasRequiredParams = (0, import_react12.useMemo)(() => {
     return !!(userAddress && params?.token_in && params?.token_out && params?.amount && params?.chain && params?.slippage && params?.distributor_id);
   }, [options]);
   const { data, isLoading, error } = useEarnRoute({
@@ -2802,7 +3285,7 @@ function useSwapRoute(isEnabled, userAddress, distributorId, options, referralCo
     },
     enabled: hasRequiredParams && isEnabled
   });
-  const routeDetails = (0, import_react8.useMemo)(() => processRouteDetails(data ?? null), [data]);
+  const routeDetails = (0, import_react12.useMemo)(() => processRouteDetails(data ?? null), [data]);
   return {
     fetchedRoute: data ?? null,
     outputAmount: data?.amount_out ?? void 0,
@@ -2815,9 +3298,9 @@ function useSwapRoute(isEnabled, userAddress, distributorId, options, referralCo
 }
 
 // src/v2/users/hooks.ts
-var import_react_query15 = require("@tanstack/react-query");
+var import_react_query16 = require("@tanstack/react-query");
 function useUserById({ userId, enabled = true }) {
-  return (0, import_react_query15.useQuery)({
+  return (0, import_react_query16.useQuery)({
     ...usersQueries.byId({ userId }),
     ...queryDefaults,
     enabled
@@ -2825,7 +3308,7 @@ function useUserById({ userId, enabled = true }) {
 }
 function useUserPortfolio({ userId, enabled = true }) {
   const input = { userId };
-  return (0, import_react_query15.useQuery)({
+  return (0, import_react_query16.useQuery)({
     ...usersQueries.portfolio(input),
     ...queryDefaults,
     enabled
@@ -2833,17 +3316,17 @@ function useUserPortfolio({ userId, enabled = true }) {
 }
 
 // src/v2/nfts/hooks.ts
-var import_react_query16 = require("@tanstack/react-query");
+var import_react_query17 = require("@tanstack/react-query");
 function useUserNfts({ userAddress, chain, tokenAddress }) {
-  return (0, import_react_query16.useQuery)(
+  return (0, import_react_query17.useQuery)(
     userAddress ? createQueryOptions(nftsQueries.byUser(userAddress, chain), {
       select: (data) => tokenAddress ? data.filter((nft) => nft.token.toLowerCase() === tokenAddress.toLowerCase()) : data
-    }) : { queryKey: ["nfts", "byUser", "skip"], queryFn: import_react_query16.skipToken }
+    }) : { queryKey: ["nfts", "byUser", "skip"], queryFn: import_react_query17.skipToken }
   );
 }
 
 // src/v2/covers/hooks.ts
-var import_react_query17 = require("@tanstack/react-query");
+var import_react_query18 = require("@tanstack/react-query");
 
 // src/v2/covers/schema.ts
 var import_zod16 = require("zod");
@@ -2875,7 +3358,7 @@ async function submitCoverRequest(data) {
 
 // src/v2/covers/hooks.ts
 function useSubmitCoverRequest(options) {
-  return (0, import_react_query17.useMutation)({
+  return (0, import_react_query18.useMutation)({
     mutationFn: submitCoverRequest,
     onSuccess: () => {
       options?.onSuccess?.("Cover request submitted successfully!");
@@ -2887,6 +3370,124 @@ function useSubmitCoverRequest(options) {
   });
 }
 
+// src/v2/membership-flow/hooks.ts
+var import_react13 = require("react");
+var useTurtleMembershipFlow = ({
+  address,
+  walletEcosystem = "evm",
+  signMessage,
+  chainId = "1",
+  url,
+  enabled = true,
+  onError
+}) => {
+  const previousAddressRef = (0, import_react13.useRef)(void 0);
+  const isProcessingRef = (0, import_react13.useRef)(false);
+  const {
+    data: membershipData,
+    isLoading: isCheckingMembership
+  } = useCheckMembership({
+    params: {
+      address: address || "",
+      walletEcosystem
+    },
+    enabled: !!address
+  });
+  const {
+    mutateAsync: createAgreement,
+    isPending: isCreatingAgreement,
+    error: agreementError
+  } = useCreateMembershipAgreement();
+  const {
+    mutateAsync: createMembership2,
+    isPending: isCreatingMembership,
+    error: membershipError
+  } = useCreateMembership();
+  const handleMembershipFlow = (0, import_react13.useCallback)(async (memberAddress) => {
+    if (isProcessingRef.current) return;
+    isProcessingRef.current = true;
+    try {
+      const agreementResult = await createAgreement({
+        address: memberAddress,
+        walletEcosystem,
+        url: url || (typeof window !== "undefined" ? window.location.href : ""),
+        chainId
+      });
+      let signature;
+      try {
+        signature = await signMessage(agreementResult.message);
+      } catch (signError) {
+        const errorMessage = signError?.message || "User rejected signature";
+        if (onError) {
+          await onError({
+            type: "signature_rejected",
+            message: errorMessage
+          });
+        }
+        return;
+      }
+      const membershipResult = await createMembership2({
+        address: memberAddress,
+        walletEcosystem,
+        signature,
+        nonce: agreementResult.nonce
+      });
+      if (!membershipResult.isMember && membershipResult.error) {
+        const errorMessage = membershipResult.error;
+        if (onError) {
+          await onError({
+            type: "membership_failed",
+            message: errorMessage
+          });
+        }
+      }
+    } catch (error2) {
+      const errorMessage = error2?.message || "Unknown error during membership flow";
+      if (onError) {
+        await onError({
+          type: "membership_failed",
+          message: errorMessage
+        });
+      }
+    } finally {
+      isProcessingRef.current = false;
+    }
+  }, [createAgreement, walletEcosystem, url, chainId, signMessage, createMembership2, onError]);
+  (0, import_react13.useEffect)(() => {
+    if (!enabled) return;
+    const currentAddress = address;
+    if (!currentAddress) {
+      if (previousAddressRef.current !== void 0) {
+        previousAddressRef.current = void 0;
+      }
+      return;
+    }
+    if (isCheckingMembership) {
+      return;
+    }
+    if (currentAddress !== previousAddressRef.current) {
+      previousAddressRef.current = currentAddress;
+      if (membershipData?.isMember) {
+        return;
+      }
+      handleMembershipFlow(currentAddress);
+    }
+  }, [address, enabled, isCheckingMembership, membershipData, handleMembershipFlow]);
+  const refetch = async () => {
+    if (address) {
+      await handleMembershipFlow(address);
+    }
+  };
+  const isLoading = isCheckingMembership || isCreatingAgreement || isCreatingMembership;
+  const error = agreementError?.message || membershipError?.message || null;
+  return {
+    isMember: membershipData?.isMember,
+    isLoading,
+    error,
+    refetch
+  };
+};
+
 // src/v2/organizations/schema.ts
 var import_zod17 = require("zod");
 var LeaveOrganizationInputSchema = import_zod17.z.object({
@@ -2912,9 +3513,9 @@ async function leaveOrganization(input) {
 }
 
 // src/v2/organizations/hooks.ts
-var import_react_query18 = require("@tanstack/react-query");
+var import_react_query19 = require("@tanstack/react-query");
 function useLeaveOrganization(options) {
-  return (0, import_react_query18.useMutation)({
+  return (0, import_react_query19.useMutation)({
     mutationFn: leaveOrganization,
     ...options
   });
@@ -3077,7 +3678,10 @@ var queries = (0, import_query_key_factory16.mergeQueryKeys)(
   productsQueries,
   queries,
   requestStreamSignature,
+  routeMetadataSchema,
+  routeStepSchema,
   routeToken,
+  routeTokenSchema,
   routerStep,
   routerSubstep,
   snapshotSchema,
@@ -3116,7 +3720,11 @@ var queries = (0, import_query_key_factory16.mergeQueryKeys)(
   useCreateWithdrawInteraction,
   useDeleteProduct,
   useDepositAction,
+  useDepositFlow,
+  useDepositSelection,
+  useDepositValidation,
   useDeposits,
+  useEarnDeposit,
   useEarnOpportunities,
   useEarnRoute,
   useEnsoBalances,
@@ -3141,6 +3749,7 @@ var queries = (0, import_query_key_factory16.mergeQueryKeys)(
   useSupportedTokens,
   useSwapRoute,
   useTokenBalance,
+  useTurtleMembershipFlow,
   useUpdateProduct,
   useUploadProductLogo,
   useUserById,