@turtleclub/hooks 0.5.0-beta.42 → 0.5.0-beta.44

package/dist/index.cjs

@@ -167,6 +167,7 @@ __export(index_exports, {
   tokenSchema: () => tokenSchema,
   transactionSchema: () => transactionSchema,
   txResponseItemSchema: () => txResponseItemSchema,
+  useActionsDefaultParams: () => useActionsDefaultParams,
   useAttributeAction: () => useAttributeAction,
   useBalance: () => useBalance2,
   useCancelDepositAction: () => useCancelDepositAction,
@@ -211,6 +212,7 @@ __export(index_exports, {
   useSupportedTokens: () => useSupportedTokens,
   useSwapRoute: () => useSwapRoute,
   useTokenBalance: () => useTokenBalance,
+  useTurtleMembershipFlow: () => useTurtleMembershipFlow,
   useUpdateProduct: () => useUpdateProduct,
   useUploadProductLogo: () => useUploadProductLogo,
   useUserById: () => useUserById,
@@ -1895,7 +1897,7 @@ function useCreateMembership() {
 }
 
 // src/v2/earn-deposits/hooks.ts
-var import_react_query6 = require("@tanstack/react-query");
+var import_react_query9 = require("@tanstack/react-query");
 
 // src/v2/earn-deposits/hooks/useDepositValidation.ts
 var import_react = require("react");
@@ -2339,7 +2341,7 @@ var balanceQueries = (0, import_query_key_factory15.createQueryKeys)("balance",
 // src/v2/earn-actions/useEarnDeposit.ts
 var DEFAULT_SLIPPAGE_BPS = 50;
 function useEarnDeposit(options) {
-  const { opportunity, userAddress, distributorId, executeTransaction, onSuccess, referralCode } = options;
+  const { opportunity, userAddress, distributorId, executeTransactionAndWait, 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);
@@ -2360,7 +2362,7 @@ function useEarnDeposit(options) {
       let lastTxHash;
       for (const txItem of transactions) {
         const txRequest = toTransactionRequest(txItem);
-        const txHash = await executeTransaction(txRequest);
+        const txHash = await executeTransactionAndWait(txRequest);
         if (!txHash) {
           throw new Error(`Transaction failed: ${txItem.description || "Unknown transaction"}`);
         }
@@ -2368,7 +2370,7 @@ function useEarnDeposit(options) {
       }
       return lastTxHash;
     },
-    [executeTransaction, toTransactionRequest]
+    [executeTransactionAndWait, toTransactionRequest]
   );
   const attributeTransactionSafely = (0, import_react4.useCallback)(
     async (actionId, txHash) => {
@@ -2471,7 +2473,7 @@ function useDepositFlow({
   userAddress,
   distributorId,
   balances,
-  executeTransaction,
+  executeTransactionAndWait,
   onDepositSuccess,
   refetchBalances,
   slippageBps,
@@ -2493,7 +2495,7 @@ function useDepositFlow({
     opportunity,
     userAddress,
     distributorId,
-    executeTransaction,
+    executeTransactionAndWait,
     onSuccess: () => {
       selection.setAmount(void 0);
       refetchBalances?.();
@@ -2531,163 +2533,13 @@ function useDepositFlow({
   };
 }
 
-// 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_react6 = require("react");
-var import_react_query7 = require("@tanstack/react-query");
-function useMultiChainBalances({
-  chainIds,
-  address
-}) {
-  const queries2 = (0, import_react_query7.useQueries)({
-    queries: chainIds.map((chainId) => ({
-      ...ensoBalancesQueries.byParams({ user: address || "", chain: chainId }),
-      enabled: !!address,
-      staleTime: 60 * 1e3,
-      refetchInterval: 3 * 60 * 1e3,
-      refetchOnMount: false,
-      refetchOnWindowFocus: false
-    }))
-  });
-  const isLoading = queries2.some((query) => query.isLoading);
-  const error = queries2.find((query) => query.error)?.error || null;
-  const refetchAll = () => {
-    queries2.forEach((query) => {
-      query.refetch();
-    });
-  };
-  const balances = (0, import_react6.useMemo)(() => {
-    const balanceMap = {};
-    queries2.forEach((query, index) => {
-      const chainId = chainIds[index];
-      if (query.data && chainId !== void 0) {
-        balanceMap[chainId] = query.data.balances;
-      }
-    });
-    return balanceMap;
-  }, [queries2, chainIds]);
-  return {
-    balances,
-    isLoading,
-    error,
-    refetchAll
-  };
-}
-
-// src/v2/opportunities/hooks.ts
-var import_react_query8 = require("@tanstack/react-query");
-function useOpportunities(options) {
-  return (0, import_react_query8.useQuery)({
-    ...opportunitiesQueries.all,
-    ...queryDefaults,
-    select: (data) => {
-      const uniqueChainsMap = new Map(
-        data.opportunities.map((opportunity) => opportunity.receiptToken?.chain).filter((chain) => chain !== void 0).map((chain) => [chain.id, chain])
-      );
-      const chains = Array.from(uniqueChainsMap.values());
-      return {
-        ...data,
-        chains
-      };
-    }
-  });
-}
-function useOpportunity({ id, ...options }) {
-  return (0, import_react_query8.useQuery)({
-    ...opportunitiesQueries.byId(id),
-    ...queryDefaults,
-    select: (data) => {
-      return {
-        ...data,
-        chain: data.receiptToken?.chain
-      };
-    }
-  });
-}
-function useOpportunitiesPaginated({
-  params,
-  enabled = true
-} = {}) {
-  return (0, import_react_query8.useQuery)({
-    ...opportunitiesQueries.paginated(params),
-    ...queryDefaults,
-    enabled
-  });
-}
-function useOpportunitiesFilterOptions({
-  enabled = true
-} = {}) {
-  return (0, import_react_query8.useQuery)({
-    ...opportunitiesQueries.filterOptions,
-    ...queryDefaults,
-    enabled
-  });
-}
-
-// src/v2/products/hooks.ts
-var import_react_query9 = require("@tanstack/react-query");
-function useProducts({ filters, enabled = true }) {
-  return (0, import_react_query9.useQuery)({
-    ...productsQueries.list(filters),
-    ...queryDefaults,
-    enabled
-  });
-}
-function useProduct({ id, enabled = true }) {
-  return (0, import_react_query9.useQuery)({
-    ...productsQueries.byId(id),
-    ...queryDefaults,
-    enabled
-  });
-}
-function useCreateProduct(options) {
-  return (0, import_react_query9.useMutation)({
-    mutationFn: (input) => createProduct(input),
-    ...options
-  });
-}
-function useUpdateProduct(options) {
-  return (0, import_react_query9.useMutation)({
-    mutationFn: (input) => updateProduct(input),
-    ...options
-  });
-}
-function useDeleteProduct(options) {
-  return (0, import_react_query9.useMutation)({
-    mutationFn: (id) => deleteProduct(id),
-    ...options
-  });
-}
-function useUploadProductLogo(options) {
-  return (0, import_react_query9.useMutation)({
-    mutationFn: (request) => uploadProductLogo(request),
-    ...options
-  });
-}
-
-// src/v2/balance/types.ts
-var BalanceSourcePriority = /* @__PURE__ */ ((BalanceSourcePriority2) => {
-  BalanceSourcePriority2[BalanceSourcePriority2["ONCHAIN"] = 1] = "ONCHAIN";
-  BalanceSourcePriority2[BalanceSourcePriority2["PORTFOLIO"] = 2] = "PORTFOLIO";
-  BalanceSourcePriority2[BalanceSourcePriority2["ENSO"] = 3] = "ENSO";
-  return BalanceSourcePriority2;
-})(BalanceSourcePriority || {});
-
-// src/v2/balance/hooks/useBalance.ts
+// src/v2/earn-deposits/hooks/useActionsDefaultParams.ts
 var import_react10 = require("react");
 
 // src/v2/balance/hooks/useGetOnChainBalance.ts
 var import_wagmi = require("wagmi");
 var import_viem3 = require("viem");
-var import_react7 = require("react");
+var import_react6 = require("react");
 var NATIVE_TOKEN_ADDRESSES = [
   "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
   "0x0000000000000000000000000000000000000000"
@@ -2702,7 +2554,7 @@ function useGetOnChainBalance({
   address,
   enabled = true
 }) {
-  const { nativeTokens, erc20Tokens } = (0, import_react7.useMemo)(() => {
+  const { nativeTokens, erc20Tokens } = (0, import_react6.useMemo)(() => {
     const native = [];
     const erc20 = [];
     for (const token of tokens) {
@@ -2730,7 +2582,7 @@ function useGetOnChainBalance({
       refetchOnWindowFocus: true
     }
   });
-  const contracts = (0, import_react7.useMemo)(() => {
+  const contracts = (0, import_react6.useMemo)(() => {
     if (!address || !enabled) return [];
     return erc20Tokens.map(
       (token) => ({
@@ -2756,7 +2608,7 @@ function useGetOnChainBalance({
       refetchOnWindowFocus: true
     }
   });
-  const balances = (0, import_react7.useMemo)(() => {
+  const balances = (0, import_react6.useMemo)(() => {
     const result = [];
     if (nativeToken && nativeBalanceData) {
       result.push({
@@ -2783,7 +2635,7 @@ function useGetOnChainBalance({
   }, [nativeToken, nativeBalanceData, erc20Results, erc20Tokens]);
   const isLoading = nativeTokens.length > 0 && isNativeLoading || erc20Tokens.length > 0 && isErc20Loading;
   const error = nativeError || erc20Error;
-  const refetch = (0, import_react7.useCallback)(() => {
+  const refetch = (0, import_react6.useCallback)(() => {
     if (nativeTokens.length > 0) {
       refetchNative();
     }
@@ -2799,14 +2651,17 @@ function useGetOnChainBalance({
   };
 }
 
-// src/v2/balance/hooks/usePortfolioBalance.ts
-var import_react_query12 = require("@tanstack/react-query");
+// src/v2/balance/hooks/useBalance.ts
 var import_react9 = require("react");
 
+// src/v2/balance/hooks/usePortfolioBalance.ts
+var import_react_query8 = require("@tanstack/react-query");
+var import_react8 = require("react");
+
 // src/v2/supported-chains/hooks.ts
-var import_react_query10 = require("@tanstack/react-query");
+var import_react_query6 = require("@tanstack/react-query");
 function useSupportedChains() {
-  const { data, isLoading, error, refetch } = (0, import_react_query10.useQuery)({
+  const { data, isLoading, error, refetch } = (0, import_react_query6.useQuery)({
     ...supportedChainsQueries.all,
     ...queryDefaults
   });
@@ -2821,15 +2676,15 @@ function useSupportedChains() {
 }
 
 // src/v2/supported-tokens/hooks.ts
-var import_react_query11 = require("@tanstack/react-query");
-var import_react8 = require("react");
+var import_react_query7 = require("@tanstack/react-query");
+var import_react7 = require("react");
 function useSupportedTokens({
   page = 0,
   limit = 20,
   search,
   enabled = true
 } = {}) {
-  const { data, isLoading, error, refetch } = (0, import_react_query11.useQuery)({
+  const { data, isLoading, error, refetch } = (0, import_react_query7.useQuery)({
     ...supportedTokensQueries.list({ page, limit, search }),
     ...queryDefaults,
     staleTime: 5 * 60 * 1e3,
@@ -2840,7 +2695,7 @@ function useSupportedTokens({
     // Don't refetch on tab focus
     enabled
   });
-  const tokens = (0, import_react8.useMemo)(() => {
+  const tokens = (0, import_react7.useMemo)(() => {
     if (!data?.tokens) return [];
     return data.tokens.map(({ active, ...token }) => token);
   }, [data?.tokens]);
@@ -2871,14 +2726,14 @@ function usePortfolioBalance({
     isLoading,
     error,
     refetch
-  } = (0, import_react_query12.useQuery)({
+  } = (0, import_react_query8.useQuery)({
     ...balanceQueries.portfolio(address || ""),
     ...queryDefaults,
     enabled: !!address,
     refetchInterval: 1 * 60 * 1e3
     // 1 minute
   });
-  const balances = (0, import_react9.useMemo)(() => {
+  const balances = (0, import_react8.useMemo)(() => {
     if (!portfolioData) return [];
     const tokenBalances = [];
     portfolioData.portfolio.holdings.wallets.forEach((wallet) => {
@@ -2933,6 +2788,14 @@ function usePortfolioBalance({
   };
 }
 
+// src/v2/balance/types.ts
+var BalanceSourcePriority = /* @__PURE__ */ ((BalanceSourcePriority2) => {
+  BalanceSourcePriority2[BalanceSourcePriority2["ONCHAIN"] = 1] = "ONCHAIN";
+  BalanceSourcePriority2[BalanceSourcePriority2["PORTFOLIO"] = 2] = "PORTFOLIO";
+  BalanceSourcePriority2[BalanceSourcePriority2["ENSO"] = 3] = "ENSO";
+  return BalanceSourcePriority2;
+})(BalanceSourcePriority || {});
+
 // src/v2/balance/utils.ts
 var import_viem5 = require("viem");
 
@@ -3036,7 +2899,7 @@ function useBalance2({
   } = usePortfolioBalance({
     address
   });
-  const consolidatedBalances = (0, import_react10.useMemo)(() => {
+  const consolidatedBalances = (0, import_react9.useMemo)(() => {
     const sources = [];
     if (depositOpportunity && onChainBalances.length > 0) {
       sources.push(onChainBalances);
@@ -3064,8 +2927,227 @@ function useBalance2({
   };
 }
 
-// src/v2/balance/hooks/useEnsoBalances.ts
+// src/v2/earn-deposits/hooks/useActionsDefaultParams.ts
+function sortByBalance(balances) {
+  return [...balances].sort((a, b) => {
+    const aValue = BigInt(a.amount);
+    const bValue = BigInt(b.amount);
+    if (bValue > aValue) return 1;
+    if (bValue < aValue) return -1;
+    return 0;
+  });
+}
+function useActionsDefaultParams({
+  opportunity,
+  address,
+  depositMode
+}) {
+  const opportunityChainId = opportunity ? Number(opportunity.receiptToken.chain.chainId) : void 0;
+  const isSecondaryOnly = opportunity?.vaultConfig?.secondaryOnly === true;
+  const effectiveDepositMode = isSecondaryOnly ? "route" : depositMode;
+  const useOnChainBalances = effectiveDepositMode === "native";
+  const {
+    balances: depositTokenBalances,
+    isLoading: isDepositBalancesLoading,
+    refetch: refetchDepositBalances
+  } = useGetOnChainBalance({
+    tokens: opportunity?.depositTokens ?? [],
+    chainId: opportunityChainId,
+    address,
+    enabled: !!address && !!opportunity && opportunityChainId != null
+  });
+  const {
+    balances: allChainBalances,
+    isLoading: isAllChainBalancesLoading,
+    refetchAll: refetchAllBalances
+  } = useBalance2({
+    address,
+    chainIds: opportunityChainId ? [opportunityChainId] : [],
+    depositOpportunity: opportunity ?? void 0
+  });
+  const rawBalances = (0, import_react10.useMemo)(() => {
+    if (useOnChainBalances) {
+      if (depositTokenBalances.length > 0) {
+        return depositTokenBalances;
+      }
+      if (opportunity?.depositTokens) {
+        return opportunity.depositTokens.map((token) => ({
+          token,
+          amount: "0",
+          source: "onchain"
+        }));
+      }
+      return [];
+    }
+    return allChainBalances;
+  }, [useOnChainBalances, depositTokenBalances, allChainBalances, opportunity?.depositTokens]);
+  const isBalancesLoading = useOnChainBalances ? isDepositBalancesLoading : isAllChainBalancesLoading;
+  const refetchBalances = useOnChainBalances ? refetchDepositBalances : refetchAllBalances;
+  const balances = (0, import_react10.useMemo)(() => {
+    let filtered = rawBalances;
+    if (!useOnChainBalances && opportunityChainId) {
+      filtered = filtered.filter((b) => {
+        const tokenChainId = Number(b.token.chain?.chainId);
+        return tokenChainId === opportunityChainId;
+      });
+    }
+    if (!useOnChainBalances) {
+      filtered = filtered.filter((b) => BigInt(b.amount) > 0n);
+    }
+    filtered = filterExcludedTokens(filtered);
+    return sortByBalance(filtered);
+  }, [rawBalances, useOnChainBalances, opportunityChainId]);
+  return {
+    balances,
+    isBalancesLoading,
+    refetchBalances
+  };
+}
+
+// src/v2/earn-deposits/hooks.ts
+function useDeposits({ params, enabled = true }) {
+  return (0, import_react_query9.useQuery)({
+    ...earnDepositsQueries.byParams(params),
+    ...queryDefaults,
+    enabled
+  });
+}
+
+// src/v2/enso-balances/hooks.ts
 var import_react11 = require("react");
+var import_react_query10 = require("@tanstack/react-query");
+function useMultiChainBalances({
+  chainIds,
+  address
+}) {
+  const queries2 = (0, import_react_query10.useQueries)({
+    queries: chainIds.map((chainId) => ({
+      ...ensoBalancesQueries.byParams({ user: address || "", chain: chainId }),
+      enabled: !!address,
+      staleTime: 60 * 1e3,
+      refetchInterval: 3 * 60 * 1e3,
+      refetchOnMount: false,
+      refetchOnWindowFocus: false
+    }))
+  });
+  const isLoading = queries2.some((query) => query.isLoading);
+  const error = queries2.find((query) => query.error)?.error || null;
+  const refetchAll = () => {
+    queries2.forEach((query) => {
+      query.refetch();
+    });
+  };
+  const balances = (0, import_react11.useMemo)(() => {
+    const balanceMap = {};
+    queries2.forEach((query, index) => {
+      const chainId = chainIds[index];
+      if (query.data && chainId !== void 0) {
+        balanceMap[chainId] = query.data.balances;
+      }
+    });
+    return balanceMap;
+  }, [queries2, chainIds]);
+  return {
+    balances,
+    isLoading,
+    error,
+    refetchAll
+  };
+}
+
+// src/v2/opportunities/hooks.ts
+var import_react_query11 = require("@tanstack/react-query");
+function useOpportunities(options) {
+  return (0, import_react_query11.useQuery)({
+    ...opportunitiesQueries.all,
+    ...queryDefaults,
+    select: (data) => {
+      const uniqueChainsMap = new Map(
+        data.opportunities.map((opportunity) => opportunity.receiptToken?.chain).filter((chain) => chain !== void 0).map((chain) => [chain.id, chain])
+      );
+      const chains = Array.from(uniqueChainsMap.values());
+      return {
+        ...data,
+        chains
+      };
+    }
+  });
+}
+function useOpportunity({ id, ...options }) {
+  return (0, import_react_query11.useQuery)({
+    ...opportunitiesQueries.byId(id),
+    ...queryDefaults,
+    select: (data) => {
+      return {
+        ...data,
+        chain: data.receiptToken?.chain
+      };
+    }
+  });
+}
+function useOpportunitiesPaginated({
+  params,
+  enabled = true
+} = {}) {
+  return (0, import_react_query11.useQuery)({
+    ...opportunitiesQueries.paginated(params),
+    ...queryDefaults,
+    enabled
+  });
+}
+function useOpportunitiesFilterOptions({
+  enabled = true
+} = {}) {
+  return (0, import_react_query11.useQuery)({
+    ...opportunitiesQueries.filterOptions,
+    ...queryDefaults,
+    enabled
+  });
+}
+
+// src/v2/products/hooks.ts
+var import_react_query12 = require("@tanstack/react-query");
+function useProducts({ filters, enabled = true }) {
+  return (0, import_react_query12.useQuery)({
+    ...productsQueries.list(filters),
+    ...queryDefaults,
+    enabled
+  });
+}
+function useProduct({ id, enabled = true }) {
+  return (0, import_react_query12.useQuery)({
+    ...productsQueries.byId(id),
+    ...queryDefaults,
+    enabled
+  });
+}
+function useCreateProduct(options) {
+  return (0, import_react_query12.useMutation)({
+    mutationFn: (input) => createProduct(input),
+    ...options
+  });
+}
+function useUpdateProduct(options) {
+  return (0, import_react_query12.useMutation)({
+    mutationFn: (input) => updateProduct(input),
+    ...options
+  });
+}
+function useDeleteProduct(options) {
+  return (0, import_react_query12.useMutation)({
+    mutationFn: (id) => deleteProduct(id),
+    ...options
+  });
+}
+function useUploadProductLogo(options) {
+  return (0, import_react_query12.useMutation)({
+    mutationFn: (request) => uploadProductLogo(request),
+    ...options
+  });
+}
+
+// src/v2/balance/hooks/useEnsoBalances.ts
+var import_react12 = require("react");
 function useEnsoBalances({
   address,
   chainIds
@@ -3080,7 +3162,7 @@ function useEnsoBalances({
     chainIds,
     address
   });
-  const balances = (0, import_react11.useMemo)(() => {
+  const balances = (0, import_react12.useMemo)(() => {
     if (isSupportedTokensLoading || isLoading) return [];
     const tokenBalances = [];
     Object.entries(ensoBalances).forEach(([, chainBalances]) => {
@@ -3199,10 +3281,10 @@ function useStreamSupportedChains({
 }
 
 // src/v2/swap/useSwapRoute.ts
-var import_react12 = require("react");
+var import_react13 = require("react");
 
 // src/v2/swap/route-processor.ts
-var import_utils4 = require("@turtleclub/utils");
+var import_utils5 = require("@turtleclub/utils");
 var parseEnsoStep = (kind, fromToken, toToken) => {
   return {
     in: {
@@ -3224,7 +3306,7 @@ var parseApproveStep = (token, amount) => {
       symbol: token.symbol
     },
     out: null,
-    amount: (0, import_utils4.formatToken)(amount, { decimals: token.decimals }, true, false, 4),
+    amount: (0, import_utils5.formatToken)(amount, { decimals: token.decimals }, true, false, 4),
     type: "approve"
   };
 };
@@ -3258,7 +3340,7 @@ function toEnsoTokenAddress(address) {
   return address;
 }
 function useSwapRoute(isEnabled, userAddress, distributorId, options, referralCode) {
-  const params = (0, import_react12.useMemo)(() => {
+  const params = (0, import_react13.useMemo)(() => {
     if (!options || !isEnabled) return void 0;
     return {
       ...options,
@@ -3267,7 +3349,7 @@ function useSwapRoute(isEnabled, userAddress, distributorId, options, referralCo
       referral_code: referralCode
     };
   }, [options, userAddress, distributorId, referralCode]);
-  const hasRequiredParams = (0, import_react12.useMemo)(() => {
+  const hasRequiredParams = (0, import_react13.useMemo)(() => {
     return !!(userAddress && params?.token_in && params?.token_out && params?.amount && params?.chain && params?.slippage && params?.distributor_id);
   }, [options]);
   const { data, isLoading, error } = useEarnRoute({
@@ -3284,7 +3366,7 @@ function useSwapRoute(isEnabled, userAddress, distributorId, options, referralCo
     },
     enabled: hasRequiredParams && isEnabled
   });
-  const routeDetails = (0, import_react12.useMemo)(() => processRouteDetails(data ?? null), [data]);
+  const routeDetails = (0, import_react13.useMemo)(() => processRouteDetails(data ?? null), [data]);
   return {
     fetchedRoute: data ?? null,
     outputAmount: data?.amount_out ?? void 0,
@@ -3369,6 +3451,124 @@ function useSubmitCoverRequest(options) {
   });
 }
 
+// src/v2/membership-flow/hooks.ts
+var import_react14 = require("react");
+var useTurtleMembershipFlow = ({
+  address,
+  walletEcosystem = "evm",
+  signMessage,
+  chainId = "1",
+  url,
+  enabled = true,
+  onError
+}) => {
+  const previousAddressRef = (0, import_react14.useRef)(void 0);
+  const isProcessingRef = (0, import_react14.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_react14.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_react14.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({
@@ -3586,6 +3786,7 @@ var queries = (0, import_query_key_factory16.mergeQueryKeys)(
   tokenSchema,
   transactionSchema,
   txResponseItemSchema,
+  useActionsDefaultParams,
   useAttributeAction,
   useBalance,
   useCancelDepositAction,
@@ -3630,6 +3831,7 @@ var queries = (0, import_query_key_factory16.mergeQueryKeys)(
   useSupportedTokens,
   useSwapRoute,
   useTokenBalance,
+  useTurtleMembershipFlow,
   useUpdateProduct,
   useUploadProductLogo,
   useUserById,