@turtleclub/hooks 0.5.0-beta.52 → 0.5.0-beta.54

package/dist/index.cjs

@@ -22,6 +22,7 @@ var index_exports = {};
 __export(index_exports, {
   ApiError: () => ApiError,
   BalanceSourcePriority: () => BalanceSourcePriority,
+  GetLiquidityProvidersResponseSchema: () => GetLiquidityProvidersResponseSchema,
   LeaveOrganizationInputSchema: () => LeaveOrganizationInputSchema,
   LeaveOrganizationOutputSchema: () => LeaveOrganizationOutputSchema,
   TurtleHooksProvider: () => TurtleHooksProvider,
@@ -49,15 +50,22 @@ __export(index_exports, {
   createClaimWithdrawInteraction: () => createClaimWithdrawInteraction,
   createDepositAction: () => createDepositAction,
   createDepositInteraction: () => createDepositInteraction,
+  createIncentive: () => createIncentive,
+  createIncentiveInputSchema: () => createIncentiveInputSchema,
   createMembership: () => createMembership,
   createMembershipAgreement: () => createMembershipAgreement,
   createMembershipRequestSchema: () => createMembershipRequestSchema,
   createMembershipResponseSchema: () => createMembershipResponseSchema,
+  createProduct: () => createProduct,
+  createProductInputSchema: () => createProductInputSchema,
+  createProductResponseSchema: () => createProductResponseSchema,
   createStreamPoint: () => createStreamPoint,
   createStreamPointBodySchema: () => createStreamPointBodySchema,
   createStreamPointOutputSchema: () => createStreamPointOutputSchema,
   createWithdrawAction: () => createWithdrawAction,
   createWithdrawInteraction: () => createWithdrawInteraction,
+  deleteIncentive: () => deleteIncentive,
+  deleteProduct: () => deleteProduct,
   depositSchema: () => depositSchema,
   depositSubstep: () => depositSubstep,
   depositsResponseSchema: () => depositsResponseSchema,
@@ -82,6 +90,10 @@ __export(index_exports, {
   getDeposits: () => getDeposits,
   getEarnOpportunities: () => getEarnOpportunities,
   getEarnRoute: () => getEarnRoute,
+  getIncentive: () => getIncentive,
+  getIncentives: () => getIncentives,
+  getLiquidityProviders: () => getLiquidityProviders,
+  getLiquidityProvidersInputSchema: () => getLiquidityProvidersInputSchema,
   getOpportunities: () => getOpportunities,
   getOpportunitiesFilterOptions: () => getOpportunitiesFilterOptions,
   getOpportunitiesFilterOptionsSchema: () => getOpportunitiesFilterOptionsSchema,
@@ -90,6 +102,7 @@ __export(index_exports, {
   getOpportunitiesPaginatedSchema: () => getOpportunitiesPaginatedSchema,
   getOpportunityById: () => getOpportunityById,
   getPortfolioBalance: () => getPortfolioBalance,
+  getProduct: () => getProduct,
   getProducts: () => getProducts,
   getSourcePriority: () => getSourcePriority,
   getStreamPoints: () => getStreamPoints,
@@ -119,8 +132,12 @@ __export(index_exports, {
   getWidgetOpportunities: () => getWidgetOpportunities,
   holdingsDataSchema: () => holdingsDataSchema,
   incentiveSchema: () => incentiveSchema,
+  incentivesQueries: () => incentivesQueries,
+  incentivesResponseSchema: () => incentivesResponseSchema,
   leaveOrganization: () => leaveOrganization,
   lendingConfigSchema: () => lendingConfigSchema,
+  liquidityProviderSchema: () => liquidityProviderSchema,
+  liquidityProvidersQueries: () => liquidityProvidersQueries,
   mergeBalancesByPriority: () => mergeBalancesByPriority,
   nftsQueries: () => nftsQueries,
   opportunitiesQueries: () => opportunitiesQueries,
@@ -137,8 +154,11 @@ __export(index_exports, {
   portfolioTokenSchema: () => portfolioTokenSchema,
   portfolioWalletSchema: () => portfolioWalletSchema,
   processRouteDetails: () => processRouteDetails,
+  productFiltersSchema: () => productFiltersSchema,
+  productResponseSchema: () => productResponseSchema,
   productSchema: () => productSchema,
   productsQueries: () => productsQueries,
+  productsResponseSchema: () => productsResponseSchema,
   queries: () => queries,
   requestStreamSignature: () => requestStreamSignature,
   routeMetadataSchema: () => routeMetadataSchema,
@@ -168,6 +188,18 @@ __export(index_exports, {
   tokenSchema: () => tokenSchema,
   transactionSchema: () => transactionSchema,
   txResponseItemSchema: () => txResponseItemSchema,
+  updateDistributorEarnDetails: () => updateDistributorEarnDetails,
+  updateIncentive: () => updateIncentive,
+  updateIncentiveInputSchema: () => updateIncentiveInputSchema,
+  updateProduct: () => updateProduct,
+  updateProductInputSchema: () => updateProductInputSchema,
+  updateProductResponseSchema: () => updateProductResponseSchema,
+  uploadIncentiveIcon: () => uploadIncentiveIcon,
+  uploadIncentiveIconRequestSchema: () => uploadIncentiveIconRequestSchema,
+  uploadIncentiveIconResponseSchema: () => uploadIncentiveIconResponseSchema,
+  uploadProductLogo: () => uploadProductLogo,
+  uploadProductLogoRequestSchema: () => uploadProductLogoRequestSchema,
+  uploadProductLogoResponseSchema: () => uploadProductLogoResponseSchema,
   useActionsDefaultParams: () => useActionsDefaultParams,
   useAttributeAction: () => useAttributeAction,
   useBalance: () => useBalance2,
@@ -178,10 +210,12 @@ __export(index_exports, {
   useClaimWithdrawAction: () => useClaimWithdrawAction,
   useCreateClaimWithdrawInteraction: () => useCreateClaimWithdrawInteraction,
   useCreateDepositInteraction: () => useCreateDepositInteraction,
+  useCreateIncentive: () => useCreateIncentive,
   useCreateMembership: () => useCreateMembership,
   useCreateMembershipAgreement: () => useCreateMembershipAgreement,
   useCreateProduct: () => useCreateProduct,
   useCreateWithdrawInteraction: () => useCreateWithdrawInteraction,
+  useDeleteIncentive: () => useDeleteIncentive,
   useDeleteProduct: () => useDeleteProduct,
   useDepositAction: () => useDepositAction,
   useDepositFlow: () => useDepositFlow,
@@ -194,7 +228,10 @@ __export(index_exports, {
   useEnsoBalances: () => useEnsoBalances,
   useGeocheck: () => useGeocheck,
   useGetOnChainBalance: () => useGetOnChainBalance,
+  useIncentive: () => useIncentive,
+  useIncentives: () => useIncentives,
   useLeaveOrganization: () => useLeaveOrganization,
+  useLiquidityProviders: () => useLiquidityProviders,
   useMultiChainBalances: () => useMultiChainBalances,
   useOpportunities: () => useOpportunities,
   useOpportunitiesFilterOptions: () => useOpportunitiesFilterOptions,
@@ -214,7 +251,10 @@ __export(index_exports, {
   useSwapRoute: () => useSwapRoute,
   useTokenBalance: () => useTokenBalance,
   useTurtleMembershipFlow: () => useTurtleMembershipFlow,
+  useUpdateDistributorEarnDetails: () => useUpdateDistributorEarnDetails,
+  useUpdateIncentive: () => useUpdateIncentive,
   useUpdateProduct: () => useUpdateProduct,
+  useUploadIncentiveIcon: () => useUploadIncentiveIcon,
   useUploadProductLogo: () => useUploadProductLogo,
   useUserById: () => useUserById,
   useUserNfts: () => useUserNfts,
@@ -235,10 +275,10 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/v2/index.ts
-var import_query_key_factory16 = require("@lukemorales/query-key-factory");
+var import_query_key_factory19 = require("@lukemorales/query-key-factory");
 
 // src/v2/opportunities/queries.ts
-var import_query_key_factory = require("@lukemorales/query-key-factory");
+var import_query_key_factory3 = require("@lukemorales/query-key-factory");
 
 // src/v2/lib/api-client.ts
 var API_BASE_URL = "https://api.turtle.xyz";
@@ -329,32 +369,20 @@ var ApiClient = class _ApiClient {
 };
 var apiClient = ApiClient.getInstance();
 
+// src/v2/opportunities/schema.ts
+var import_zod7 = require("zod");
+
+// src/v2/supported-tokens/schema.ts
+var import_zod4 = require("zod");
+
+// src/v2/supported-chains/schema.ts
+var import_zod3 = require("zod");
+
 // src/v2/schemas/shared.ts
+var import_zod2 = require("zod");
+
+// src/v2/organizations/schema.ts
 var import_zod = require("zod");
-var chainSchema = import_zod.z.object({
-  id: import_zod.z.string().optional(),
-  name: import_zod.z.string(),
-  slug: import_zod.z.string().optional(),
-  chainId: import_zod.z.string(),
-  logoUrl: import_zod.z.string().optional(),
-  ecosystem: import_zod.z.string().optional(),
-  status: import_zod.z.string().optional(),
-  explorerUrl: import_zod.z.string().optional()
-});
-var tokenSchema = import_zod.z.object({
-  id: import_zod.z.string().optional(),
-  name: import_zod.z.string(),
-  symbol: import_zod.z.string(),
-  address: import_zod.z.string(),
-  chain: chainSchema,
-  decimals: import_zod.z.number(),
-  logoUrl: import_zod.z.string().optional(),
-  isNative: import_zod.z.boolean(),
-  priceUsd: import_zod.z.number().optional(),
-  price: import_zod.z.string().optional(),
-  amount: import_zod.z.string().optional(),
-  rawAmount: import_zod.z.string().optional()
-});
 var organizationSchema = import_zod.z.object({
   id: import_zod.z.string(),
   name: import_zod.z.string(),
@@ -367,360 +395,697 @@ var organizationSchema = import_zod.z.object({
   status: import_zod.z.string().optional().nullable(),
   featured: import_zod.z.boolean().optional().nullable()
 });
-var productSchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  name: import_zod.z.string(),
-  title: import_zod.z.string().optional().nullable(),
-  subtitle: import_zod.z.string().optional().nullable(),
-  description: import_zod.z.string().optional().nullable(),
-  logoUrl: import_zod.z.string().optional().nullable(),
-  productUrl: import_zod.z.string().optional().nullable(),
-  startedAt: import_zod.z.string().optional().nullable(),
-  status: import_zod.z.string().optional().nullable(),
-  productType: import_zod.z.string().optional().nullable(),
-  organization: organizationSchema,
-  createdAt: import_zod.z.string().optional().nullable()
-});
-var vaultConfigSchema = import_zod.z.object({
-  id: import_zod.z.string().uuid().optional(),
-  infraProvider: organizationSchema.optional().nullable(),
-  curator: organizationSchema.optional().nullable(),
-  withdrawalCooldownSecs: import_zod.z.number().int().min(0).optional().nullable(),
-  withdrawalContractAddress: import_zod.z.string().optional().nullable(),
-  withdrawalDetails: import_zod.z.any().optional().nullable(),
-  depositUrl: import_zod.z.string().optional().nullable(),
-  providerMetadata: import_zod.z.any().optional().nullable(),
-  performanceFee: import_zod.z.number().min(0).max(100).optional().nullable(),
-  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(),
-  depositCapValueUSD: 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()
-});
-var lendingConfigSchema = import_zod.z.object({
-  id: import_zod.z.string().uuid().optional(),
-  protocol: import_zod.z.object({ id: import_zod.z.string() }),
-  marketAddress: import_zod.z.string().min(1, "Market address is required"),
-  depositUrl: import_zod.z.string().optional().nullable(),
-  providerMetadata: import_zod.z.any().optional().nullable(),
-  createdAt: import_zod.z.string().datetime().optional(),
-  updatedAt: import_zod.z.string().datetime().optional()
-});
-var incentiveSchema = import_zod.z.object({
-  id: import_zod.z.string().uuid(),
-  name: import_zod.z.string(),
-  description: import_zod.z.string(),
-  iconUrl: import_zod.z.string(),
-  rewardType: import_zod.z.string(),
-  rewardTypeName: import_zod.z.string(),
-  boostPct: import_zod.z.number().nullable(),
-  totalCapacity: import_zod.z.number().nullable(),
-  maxCapacityPerLP: import_zod.z.number().nullable(),
-  lockup: import_zod.z.string().nullable(),
-  minCommitment: import_zod.z.number().nullable(),
-  baseYieldTarget: import_zod.z.number().nullable(),
-  baseYieldSource: import_zod.z.string().nullable(),
-  incentiveYieldTarget: import_zod.z.number().nullable(),
-  fdvEstimate: import_zod.z.number().nullable(),
-  isIncentiveYieldGuaranteed: import_zod.z.boolean().nullable(),
-  tokenSupplyAllocation: import_zod.z.number().nullable(),
-  yield: import_zod.z.number().nullable()
-});
-var opportunityTypeEnum = import_zod.z.enum(["vault", "lending", "staking", "stablecoin", "draft", ""]);
-var opportunityStatusEnum = import_zod.z.enum(["active", "paused", "deprecated", "draft", "ended"]);
-var opportunitySchema = import_zod.z.object({
-  id: import_zod.z.string().uuid().optional(),
-  name: import_zod.z.string(),
-  shortName: import_zod.z.string(),
-  type: opportunityTypeEnum,
-  description: import_zod.z.string().optional().default(""),
-  curator: import_zod.z.string().optional().default(""),
-  tvl: import_zod.z.number().min(0, "TVL must be positive"),
-  featured: import_zod.z.boolean().optional().default(false),
-  featuredOrder: import_zod.z.number().int().optional().nullable(),
-  originalConfig: import_zod.z.any().optional().nullable(),
-  exposures: import_zod.z.array(import_zod.z.string()).optional().default([]),
-  status: opportunityStatusEnum.optional().default("active"),
-  statusReason: import_zod.z.string().optional().default(""),
-  depositDisabled: import_zod.z.boolean().optional().default(false),
-  depositDisabledReason: import_zod.z.string().optional().default(""),
-  withdrawalDisabled: import_zod.z.boolean().optional().default(false),
-  withdrawalDisabledReason: import_zod.z.string().optional().default(""),
-  docsUrl: import_zod.z.string().optional().nullable(),
-  auditsUrl: import_zod.z.string().optional().nullable(),
-  turtleTvl: import_zod.z.number(),
-  turtleUsers: import_zod.z.number(),
-  earnEnabled: import_zod.z.boolean(),
-  createdAt: import_zod.z.string().datetime().optional(),
-  updatedAt: import_zod.z.string().datetime().optional(),
-  // Relationships
-  depositTokens: import_zod.z.array(tokenSchema),
-  baseTokens: tokenSchema,
-  receiptToken: tokenSchema,
-  incentives: import_zod.z.array(incentiveSchema),
-  products: import_zod.z.array(productSchema),
-  vaultConfig: vaultConfigSchema.optional().nullable(),
-  lendingConfig: lendingConfigSchema.optional().nullable(),
-  // Will be deprecated
-  exposure: import_zod.z.array(import_zod.z.string()),
-  explorerUrl: import_zod.z.string().nullable()
-});
-var paginationMetadataSchema = import_zod.z.object({
-  page: import_zod.z.number().int().min(1).catch(1),
-  limit: import_zod.z.number().int().min(1).max(100),
-  total: import_zod.z.number().int().min(0),
-  total_pages: import_zod.z.number().int().min(1),
-  has_next: import_zod.z.boolean(),
-  has_previous: import_zod.z.boolean()
-});
-
-// src/v2/opportunities/schema.ts
-var import_zod2 = require("zod");
-var opportunityFiltersSchema = import_zod2.z.object({
-  tokenId: import_zod2.z.string().uuid().optional(),
-  chain: import_zod2.z.string().optional(),
-  productId: import_zod2.z.string().uuid().optional()
-});
-var opportunitiesResponseSchema = import_zod2.z.object({
-  opportunities: import_zod2.z.array(opportunitySchema),
-  total: import_zod2.z.number().optional()
-});
-var getOpportunitiesPaginatedInputSchema = import_zod2.z.object({
-  page: import_zod2.z.number().min(1).default(1),
-  limit: import_zod2.z.number().min(1).max(100).default(10),
-  // Sorting
-  sortBy: import_zod2.z.enum([
-    "turtleTvl",
-    "tvl",
-    "name",
-    "turtleUsers",
-    "type",
-    "organization",
-    "curator",
-    "provider",
-    "apr"
-  ]).optional(),
-  sortOrder: import_zod2.z.enum(["asc", "desc"]).optional(),
-  // Filter by receipt token chain (comma-separated)
-  receiptTokenChainId: import_zod2.z.string().optional(),
-  // Comma-separated UUIDs
-  receiptTokenChainSlug: import_zod2.z.string().optional(),
-  // Comma-separated slugs
-  // Filter by deposit token
-  depositTokenGroup: import_zod2.z.string().optional(),
-  depositTokenSymbols: import_zod2.z.string().optional(),
-  // Comma-separated symbols
-  depositTokenChainId: import_zod2.z.string().optional(),
-  // Filter by tags (comma-separated)
-  tags: import_zod2.z.string().optional(),
-  // Filter by IDs (comma-separated UUIDs)
-  productId: import_zod2.z.string().optional(),
-  // Comma-separated UUIDs
-  curatorId: import_zod2.z.string().optional(),
-  // Comma-separated UUIDs
-  providerId: import_zod2.z.string().optional(),
-  // Comma-separated UUIDs
-  partnerId: import_zod2.z.string().optional(),
-  // Comma-separated UUIDs
-  lendingProtocolId: import_zod2.z.string().optional(),
-  // Comma-separated UUIDs
-  // Status filters
-  withdrawalDisabled: import_zod2.z.boolean().optional(),
-  depositDisabled: import_zod2.z.boolean().optional(),
-  status: import_zod2.z.string().optional(),
-  earnEnabled: import_zod2.z.boolean().optional(),
-  featured: import_zod2.z.boolean().optional(),
-  // TVL filters
-  tvlGreaterThan: import_zod2.z.number().optional(),
-  turtleTvlGreaterThan: import_zod2.z.number().optional(),
-  tvlMin: import_zod2.z.number().optional(),
-  tvlMax: import_zod2.z.number().optional(),
-  // APR filters
-  minApr: import_zod2.z.number().optional(),
-  maxApr: import_zod2.z.number().optional(),
-  // Chain IDs (comma-separated)
-  chainIds: import_zod2.z.string().optional(),
-  // Search
-  search: import_zod2.z.string().optional()
-});
-var paginationMetadataSchema2 = import_zod2.z.object({
-  page: import_zod2.z.number(),
-  limit: import_zod2.z.number(),
-  total: import_zod2.z.number(),
-  totalPages: import_zod2.z.number()
-});
-var getOpportunitiesPaginatedSchema = import_zod2.z.object({
-  opportunities: import_zod2.z.array(opportunitySchema),
-  pagination: paginationMetadataSchema2
+var LeaveOrganizationInputSchema = import_zod.z.object({
+  organizationId: import_zod.z.string().uuid()
 });
-var filterChainSchema = import_zod2.z.object({
-  id: import_zod2.z.string().uuid(),
-  name: import_zod2.z.string(),
-  slug: import_zod2.z.string(),
-  chainId: import_zod2.z.string(),
-  logoUrl: import_zod2.z.string(),
-  ecosystem: import_zod2.z.string(),
-  status: import_zod2.z.string(),
-  explorerUrl: import_zod2.z.string()
-});
-var filterOrganizationSchema = import_zod2.z.object({
-  id: import_zod2.z.string().uuid(),
-  name: import_zod2.z.string(),
-  description: import_zod2.z.string(),
-  landingUrl: import_zod2.z.string(),
-  iconUrl: import_zod2.z.string(),
-  organizationType: import_zod2.z.string(),
-  turtleRefCode: import_zod2.z.string(),
-  twitterHandle: import_zod2.z.string(),
-  status: import_zod2.z.string(),
-  featured: import_zod2.z.boolean()
-});
-var filterTagSchema = import_zod2.z.object({
-  id: import_zod2.z.string().uuid(),
-  code: import_zod2.z.string(),
-  name: import_zod2.z.string(),
-  description: import_zod2.z.string().optional().nullable(),
-  color: import_zod2.z.string().optional().nullable(),
-  type: import_zod2.z.string().optional().nullable()
-});
-var depositTokenSymbolSchema = import_zod2.z.object({
-  symbol: import_zod2.z.string(),
-  logoUrl: import_zod2.z.string()
-});
-var getOpportunitiesFilterOptionsSchema = import_zod2.z.object({
-  chains: import_zod2.z.array(filterChainSchema),
-  providers: import_zod2.z.array(filterOrganizationSchema),
-  curators: import_zod2.z.array(filterOrganizationSchema).optional().nullable(),
-  partners: import_zod2.z.array(filterOrganizationSchema).optional().nullable(),
-  tags: import_zod2.z.array(filterTagSchema).optional().nullable(),
-  lendingProtocols: import_zod2.z.array(filterOrganizationSchema),
-  depositTokenSymbols: import_zod2.z.array(depositTokenSymbolSchema).optional().nullable()
+var LeaveOrganizationOutputSchema = import_zod.z.object({
+  success: import_zod.z.boolean(),
+  error: import_zod.z.string().optional()
 });
 
-// src/v2/opportunities/api.ts
-async function getOpportunities(filters, options) {
-  const params = new URLSearchParams();
-  if (filters?.tokenId) params.append("tokenId", filters.tokenId);
-  if (filters?.chain) params.append("chain", filters.chain);
-  if (filters?.productId) params.append("productId", filters.productId);
-  const queryString = params.toString();
-  const endpoint = `/turtle/opportunities${queryString ? `?${queryString}` : ""}`;
+// src/v2/organizations/api.ts
+async function leaveOrganization(input) {
+  const endpoint = `/organization/${input.organizationId}/leave`;
   const data = await apiClient.fetch(endpoint, {
-    method: "GET",
-    debug: options?.debug
+    method: "POST"
   });
-  const result = opportunitiesResponseSchema.safeParse(data);
+  const result = LeaveOrganizationOutputSchema.safeParse(data);
   if (result.success === false) {
     console.log("[ZOD ERROR]", result.error);
-    throw new Error(`Failed to parse opportunities: ${result.error.message}`);
+    throw new Error(`Failed to parse leave organization response: ${result.error.message}`);
   }
   return result.data;
 }
-async function getOpportunityById(id, options) {
-  const data = await apiClient.fetch(`/turtle/opportunities/${id}`, {
-    method: "GET",
-    debug: options?.debug
+
+// src/v2/organizations/hooks.ts
+var import_react_query = require("@tanstack/react-query");
+function useLeaveOrganization(options) {
+  return (0, import_react_query.useMutation)({
+    mutationFn: leaveOrganization,
+    ...options
   });
-  const result = opportunitySchema.safeParse(data);
-  if (result.success === false) {
-    console.log("[ZOD ERROR]", result.error);
-    throw new Error(`Failed to parse opportunity: ${result.error.message}`);
-  }
-  return result.data;
 }
-async function getOpportunitiesPaginated(params, options) {
+
+// src/v2/organizations/queries.ts
+var organizationsMutations = {
+  leave: (input) => leaveOrganization(input)
+};
+
+// src/v2/schemas/shared.ts
+var vaultConfigSchema = import_zod2.z.object({
+  id: import_zod2.z.string().uuid().optional(),
+  infraProvider: organizationSchema.optional().nullable(),
+  curator: organizationSchema.optional().nullable(),
+  withdrawalCooldownSecs: import_zod2.z.number().int().min(0).optional().nullable(),
+  withdrawalContractAddress: import_zod2.z.string().optional().nullable(),
+  withdrawalDetails: import_zod2.z.any().optional().nullable(),
+  depositUrl: import_zod2.z.string().optional().nullable(),
+  providerMetadata: import_zod2.z.any().optional().nullable(),
+  performanceFee: import_zod2.z.number().min(0).max(100).optional().nullable(),
+  managementFee: import_zod2.z.number().min(0).max(100).optional().nullable(),
+  depositFee: import_zod2.z.number().min(0).max(100).optional().nullable(),
+  withdrawalFee: import_zod2.z.number().min(0).max(100).optional().nullable(),
+  minDepositAmount: import_zod2.z.number().optional().nullable(),
+  minDepositValueUSD: import_zod2.z.number().optional().nullable(),
+  depositCapAmount: import_zod2.z.number().optional().nullable(),
+  depositCapValueUSD: import_zod2.z.number().optional().nullable(),
+  depositFillSecs: import_zod2.z.number().int().optional().nullable(),
+  lockupPeriodSecs: import_zod2.z.number().int().optional().nullable(),
+  asyncDeposit: import_zod2.z.boolean().optional().nullable(),
+  asyncWithdraw: import_zod2.z.boolean().optional().nullable(),
+  secondaryOnly: import_zod2.z.boolean().optional().nullable(),
+  createdAt: import_zod2.z.string().datetime().optional(),
+  updatedAt: import_zod2.z.string().datetime().optional()
+});
+var lendingConfigSchema = import_zod2.z.object({
+  id: import_zod2.z.string().uuid().optional(),
+  protocol: import_zod2.z.object({ id: import_zod2.z.string() }),
+  marketAddress: import_zod2.z.string().min(1, "Market address is required"),
+  depositUrl: import_zod2.z.string().optional().nullable(),
+  providerMetadata: import_zod2.z.any().optional().nullable(),
+  createdAt: import_zod2.z.string().datetime().optional(),
+  updatedAt: import_zod2.z.string().datetime().optional()
+});
+var paginationMetadataSchema = import_zod2.z.object({
+  page: import_zod2.z.number().int().min(1).catch(1),
+  limit: import_zod2.z.number().int().min(1).max(100),
+  total: import_zod2.z.number().int().min(0),
+  total_pages: import_zod2.z.number().int().min(1),
+  has_next: import_zod2.z.boolean(),
+  has_previous: import_zod2.z.boolean()
+});
+
+// src/v2/supported-chains/schema.ts
+var chainSchema = import_zod3.z.object({
+  id: import_zod3.z.string().optional(),
+  name: import_zod3.z.string(),
+  slug: import_zod3.z.string().optional(),
+  chainId: import_zod3.z.string(),
+  logoUrl: import_zod3.z.string().optional(),
+  ecosystem: import_zod3.z.string().optional(),
+  status: import_zod3.z.string().optional(),
+  explorerUrl: import_zod3.z.string().optional()
+});
+var getSupportedChainsInputSchema = import_zod3.z.object({
+  page: import_zod3.z.number().min(1).default(1).optional(),
+  limit: import_zod3.z.number().min(1).max(100).default(50).optional(),
+  // Sorting
+  sortBy: import_zod3.z.enum(["name", "chainId", "ecosystem", "slug"]).optional(),
+  sortOrder: import_zod3.z.enum(["asc", "desc"]).optional(),
+  // Filters
+  ecosystem: import_zod3.z.string().optional(),
+  // Filter by ecosystem
+  status: import_zod3.z.string().optional(),
+  // Filter by status
+  chainId: import_zod3.z.string().optional(),
+  // Filter by specific chainId
+  slug: import_zod3.z.string().optional(),
+  // Filter by slug
+  search: import_zod3.z.string().optional()
+  // Search by name or slug
+});
+var supportedChainsResponseSchema = import_zod3.z.object({
+  chains: import_zod3.z.array(chainSchema),
+  pagination: paginationMetadataSchema.optional()
+});
+
+// src/v2/supported-chains/api.ts
+async function getSupportedChains(params, options) {
   const queryParams = new URLSearchParams();
   if (params) {
-    Object.entries(params).forEach(([key, value]) => {
-      if (value !== void 0 && value !== null) {
-        queryParams.append(key, String(value));
-      }
-    });
+    if (params.page !== void 0) queryParams.append("page", params.page.toString());
+    if (params.limit !== void 0) queryParams.append("limit", params.limit.toString());
+    if (params.sortBy) queryParams.append("sortBy", params.sortBy);
+    if (params.sortOrder) queryParams.append("sortOrder", params.sortOrder);
+    if (params.ecosystem) queryParams.append("ecosystem", params.ecosystem);
+    if (params.status) queryParams.append("status", params.status);
+    if (params.chainId) queryParams.append("chainId", params.chainId);
+    if (params.slug) queryParams.append("slug", params.slug);
+    if (params.search) queryParams.append("search", params.search);
   }
   const queryString = queryParams.toString();
-  const endpoint = `/turtle/opportunities-paginated${queryString ? `?${queryString}` : ""}`;
+  const endpoint = `/turtle/chains${queryString ? `?${queryString}` : ""}`;
   const data = await apiClient.fetch(endpoint, {
     method: "GET",
     debug: options?.debug
   });
-  const result = getOpportunitiesPaginatedSchema.safeParse(data);
+  const result = supportedChainsResponseSchema.safeParse(data);
   if (result.success === false) {
     console.log("[ZOD ERROR]", result.error);
-    throw new Error(`Failed to parse paginated opportunities: ${result.error.message}`);
+    throw new Error(`Failed to parse supported chains: ${result.error.message}`);
   }
   return result.data;
 }
-async function getOpportunitiesFilterOptions(options) {
-  const data = await apiClient.fetch("/turtle/opportunities-filter-options", {
+
+// src/v2/supported-chains/queries.ts
+var import_query_key_factory = require("@lukemorales/query-key-factory");
+var supportedChainsQueries = (0, import_query_key_factory.createQueryKeys)("supportedChains", {
+  all: (params, options) => ({
+    queryKey: [params],
+    queryFn: () => getSupportedChains(params, options)
+  })
+});
+
+// src/v2/supported-chains/hooks.ts
+var import_react_query2 = require("@tanstack/react-query");
+
+// src/v2/lib/query-config.ts
+var queryDefaults = {
+  staleTime: 5 * 60 * 1e3,
+  // 5 minutes - data is fresh
+  gcTime: 10 * 60 * 1e3,
+  // 10 minutes - cache garbage collection (formerly cacheTime)
+  retry: 1,
+  // Retry failed requests once
+  refetchOnWindowFocus: false
+  // Don't refetch on tab focus
+};
+function createQueryOptions(queryConfig, options) {
+  return {
+    ...queryDefaults,
+    ...queryConfig,
+    ...options
+  };
+}
+
+// src/v2/supported-chains/hooks.ts
+function useSupportedChains(options) {
+  const { debug, enabled = true, ...params } = options || {};
+  const { data, isLoading, error, refetch, isFetching } = (0, import_react_query2.useQuery)({
+    ...supportedChainsQueries.all(params, { debug }),
+    ...queryDefaults,
+    enabled
+  });
+  const chains = data?.chains ?? [];
+  const pagination = data?.pagination;
+  return {
+    chains,
+    pagination,
+    getChainByChainId: (chainId) => chains.find((chain) => chain.chainId === chainId),
+    getChainBySlug: (slug) => chains.find((chain) => chain.slug === slug),
+    getChainsByEcosystem: (ecosystem) => chains.filter((chain) => chain.ecosystem === ecosystem),
+    isLoading,
+    error: error ? error : null,
+    refetch,
+    isFetching
+  };
+}
+
+// src/v2/supported-tokens/schema.ts
+var tokenSchema = import_zod4.z.object({
+  id: import_zod4.z.string().optional(),
+  name: import_zod4.z.string(),
+  symbol: import_zod4.z.string(),
+  address: import_zod4.z.string(),
+  chain: chainSchema,
+  decimals: import_zod4.z.number(),
+  logoUrl: import_zod4.z.string().optional(),
+  isNative: import_zod4.z.boolean(),
+  priceUsd: import_zod4.z.number().optional(),
+  price: import_zod4.z.string().optional(),
+  amount: import_zod4.z.string().optional(),
+  rawAmount: import_zod4.z.string().optional()
+});
+var supportedTokenSchema = tokenSchema.extend({
+  active: import_zod4.z.boolean()
+});
+var supportedTokensResponseSchema = import_zod4.z.object({
+  tokens: import_zod4.z.array(supportedTokenSchema),
+  total: import_zod4.z.number().optional(),
+  limit: import_zod4.z.number().optional(),
+  page: import_zod4.z.number().optional()
+});
+
+// src/v2/supported-tokens/api.ts
+async function getSupportedTokens(filters, options) {
+  const params = new URLSearchParams();
+  if (filters?.page !== void 0) params.append("page", filters.page.toString());
+  if (filters?.limit !== void 0) params.append("limit", filters.limit.toString());
+  if (filters?.search) params.append("search", filters.search);
+  if (filters?.chainId) params.append("chainId", filters.chainId);
+  const queryString = params.toString();
+  const endpoint = `/turtle/tokens${queryString ? `?${queryString}` : ""}`;
+  const data = await apiClient.fetch(endpoint, {
     method: "GET",
     debug: options?.debug
   });
-  const result = getOpportunitiesFilterOptionsSchema.safeParse(data);
+  const result = supportedTokensResponseSchema.safeParse(data);
   if (result.success === false) {
     console.log("[ZOD ERROR]", result.error);
-    throw new Error(`Failed to parse opportunities filter options: ${result.error.message}`);
+    throw new Error(`Failed to parse supported tokens: ${result.error.message}`);
   }
   return result.data;
 }
 
-// src/v2/opportunities/queries.ts
-var opportunitiesQueries = (0, import_query_key_factory.createQueryKeys)("opportunities", {
-  // Get all opportunities (no filters)
-  all: {
-    queryKey: null,
-    queryFn: () => getOpportunities()
-  },
-  // Get opportunities with filters
+// src/v2/supported-tokens/queries.ts
+var import_query_key_factory2 = require("@lukemorales/query-key-factory");
+var supportedTokensQueries = (0, import_query_key_factory2.createQueryKeys)("supportedTokens", {
   list: (filters) => ({
-    queryKey: [{ filters }],
-    queryFn: () => getOpportunities(filters)
-  }),
-  // Get single opportunity by ID
-  byId: (id) => ({
-    queryKey: [id],
-    queryFn: () => getOpportunityById(id)
-  }),
-  // Get paginated opportunities
-  paginated: (params) => ({
-    queryKey: [{ params }],
-    queryFn: () => getOpportunitiesPaginated(params)
-  }),
-  // Get filter options for opportunities
-  filterOptions: {
-    queryKey: null,
+    queryKey: [filters],
+    queryFn: () => getSupportedTokens(filters)
+  })
+});
+
+// src/v2/supported-tokens/hooks.ts
+var import_react_query3 = require("@tanstack/react-query");
+var import_react = require("react");
+function useSupportedTokens({
+  page = 0,
+  limit = 20,
+  search,
+  chainId,
+  enabled = true
+} = {}) {
+  const { data, isLoading, error, refetch } = (0, import_react_query3.useQuery)({
+    ...supportedTokensQueries.list({ page, limit, search, chainId }),
+    ...queryDefaults,
+    staleTime: 5 * 60 * 1e3,
+    // 1 minutes
+    gcTime: 10 * 60 * 1e3,
+    // 10 minutes
+    refetchOnWindowFocus: false,
+    // Don't refetch on tab focus
+    enabled
+  });
+  const tokens = (0, import_react.useMemo)(() => {
+    if (!data?.tokens) return [];
+    return data.tokens;
+  }, [data?.tokens]);
+  return {
+    tokens,
+    total: data?.total ?? 0,
+    limit: data?.limit ?? limit,
+    page: data?.page ?? page,
+    isLoading,
+    error: error ? error : null,
+    refetch,
+    getTokenById: (id) => tokens.find((token) => token.id === id),
+    getToken: (address, chainId2) => tokens.find(
+      (token) => token.address.toLowerCase() === address.toLowerCase() && token.chain.chainId === chainId2
+    )
+  };
+}
+
+// src/v2/incentives/schema.ts
+var import_zod5 = require("zod");
+var incentiveSchema = import_zod5.z.object({
+  id: import_zod5.z.string().uuid(),
+  name: import_zod5.z.string(),
+  description: import_zod5.z.string(),
+  iconUrl: import_zod5.z.string(),
+  rewardType: import_zod5.z.string(),
+  rewardTypeName: import_zod5.z.string(),
+  boostPct: import_zod5.z.number().nullable(),
+  totalCapacity: import_zod5.z.number().nullable(),
+  maxCapacityPerLP: import_zod5.z.number().nullable(),
+  lockup: import_zod5.z.string().nullable(),
+  minCommitment: import_zod5.z.number().nullable(),
+  baseYieldTarget: import_zod5.z.number().nullable(),
+  baseYieldSource: import_zod5.z.string().nullable(),
+  incentiveYieldTarget: import_zod5.z.number().nullable(),
+  fdvEstimate: import_zod5.z.number().nullable(),
+  isIncentiveYieldGuaranteed: import_zod5.z.boolean().nullable(),
+  tokenSupplyAllocation: import_zod5.z.number().nullable(),
+  yield: import_zod5.z.number().nullable(),
+  indexed: import_zod5.z.boolean().nullable(),
+  minApr: import_zod5.z.number().nullable().optional(),
+  maxApr: import_zod5.z.number().nullable().optional()
+});
+var createIncentiveInputSchema = incentiveSchema.omit({
+  id: true
+});
+var updateIncentiveInputSchema = incentiveSchema.partial().extend({
+  id: import_zod5.z.string().uuid()
+});
+var incentivesResponseSchema = import_zod5.z.object({
+  incentives: import_zod5.z.array(incentiveSchema),
+  total: import_zod5.z.number().optional()
+});
+var uploadIncentiveIconRequestSchema = import_zod5.z.object({
+  file: import_zod5.z.object({
+    name: import_zod5.z.string(),
+    size: import_zod5.z.number().positive(),
+    type: import_zod5.z.string().refine((type) => type.startsWith("image/"), {
+      message: "File must be an image type"
+    }),
+    lastModified: import_zod5.z.number().optional()
+  }),
+  filename: import_zod5.z.string().optional(),
+  overwrite: import_zod5.z.boolean().optional()
+});
+var uploadIncentiveIconResponseSchema = import_zod5.z.object({
+  publicUrl: import_zod5.z.string().url()
+});
+
+// src/v2/products/schema.ts
+var import_zod6 = require("zod");
+var productTypeSchema = import_zod6.z.enum(["deal", "campaign"]);
+var productStatusSchema = import_zod6.z.enum(["draft", "active", "paused", "ended"]);
+var turtleOrganizationSchema = import_zod6.z.object({
+  id: import_zod6.z.string().uuid(),
+  name: import_zod6.z.string(),
+  iconUrl: import_zod6.z.string(),
+  landingUrl: import_zod6.z.string()
+});
+var productSchema = import_zod6.z.object({
+  id: import_zod6.z.string().uuid(),
+  name: import_zod6.z.string(),
+  title: import_zod6.z.string(),
+  subtitle: import_zod6.z.string(),
+  description: import_zod6.z.string(),
+  logoUrl: import_zod6.z.string(),
+  productUrl: import_zod6.z.string(),
+  startedAt: import_zod6.z.string().optional().nullable(),
+  endedAt: import_zod6.z.string().optional().nullable(),
+  status: productStatusSchema,
+  productType: productTypeSchema,
+  organization: turtleOrganizationSchema.nullable(),
+  opportunities: import_zod6.z.lazy(() => import_zod6.z.array(import_zod6.z.any())).nullish(),
+  createdAt: import_zod6.z.string()
+});
+var createProductInputSchema = import_zod6.z.object({
+  product: productSchema.omit({
+    id: true,
+    createdAt: true,
+    organization: true
+  }),
+  organizationId: import_zod6.z.string().uuid()
+});
+var updateProductInputSchema = import_zod6.z.object({
+  product: productSchema.partial().omit({
+    organization: true
+  })
+  // organizationId: z.string().uuid(),
+});
+var productsResponseSchema = import_zod6.z.object({
+  products: import_zod6.z.array(productSchema),
+  total: import_zod6.z.number().optional()
+});
+var productResponseSchema = import_zod6.z.object({
+  product: productSchema
+});
+var createProductResponseSchema = import_zod6.z.object({
+  id: import_zod6.z.string().uuid()
+});
+var updateProductResponseSchema = import_zod6.z.object({
+  success: import_zod6.z.boolean()
+});
+var fileSchema = import_zod6.z.any().refine((value) => {
+  if (!value) return false;
+  if (!(value instanceof File)) return false;
+  if (value.size > 10 * 1024 * 1024) return false;
+  return true;
+}, "Invalid file");
+var uploadProductLogoRequestSchema = import_zod6.z.object({
+  // Form data - file upload (required)
+  file: fileSchema,
+  // Form data - optional filename override
+  filename: import_zod6.z.string().optional()
+});
+var uploadProductLogoResponseSchema = import_zod6.z.object({
+  url: import_zod6.z.string().url(),
+  error: import_zod6.z.string().optional()
+});
+var productFiltersSchema = import_zod6.z.object({
+  organizationId: import_zod6.z.string().uuid().optional()
+});
+
+// src/v2/opportunities/schema.ts
+var opportunityTypeEnum = import_zod7.z.enum(["vault", "lending", "staking", "stablecoin", "draft", ""]);
+var opportunityStatusEnum = import_zod7.z.enum(["active", "paused", "deprecated", "draft", "ended"]);
+var opportunitySchema = import_zod7.z.object({
+  id: import_zod7.z.string().uuid().optional(),
+  name: import_zod7.z.string(),
+  shortName: import_zod7.z.string(),
+  type: opportunityTypeEnum,
+  description: import_zod7.z.string().optional().default(""),
+  curator: import_zod7.z.string().optional().default(""),
+  tvl: import_zod7.z.number().min(0, "TVL must be positive"),
+  featured: import_zod7.z.boolean().optional().default(false),
+  featuredOrder: import_zod7.z.number().int().optional().nullable(),
+  originalConfig: import_zod7.z.any().optional().nullable(),
+  exposures: import_zod7.z.array(import_zod7.z.string()).optional().default([]),
+  status: opportunityStatusEnum.optional().default("active"),
+  statusReason: import_zod7.z.string().optional().default(""),
+  depositDisabled: import_zod7.z.boolean().optional().default(false),
+  depositDisabledReason: import_zod7.z.string().optional().default(""),
+  withdrawalDisabled: import_zod7.z.boolean().optional().default(false),
+  withdrawalDisabledReason: import_zod7.z.string().optional().default(""),
+  docsUrl: import_zod7.z.string().optional().nullable(),
+  auditsUrl: import_zod7.z.string().optional().nullable(),
+  turtleTvl: import_zod7.z.number(),
+  turtleUsers: import_zod7.z.number(),
+  earnEnabled: import_zod7.z.boolean(),
+  createdAt: import_zod7.z.string().datetime().optional(),
+  updatedAt: import_zod7.z.string().datetime().optional(),
+  // Relationships
+  depositTokens: import_zod7.z.array(supportedTokenSchema),
+  baseTokens: supportedTokenSchema,
+  receiptToken: supportedTokenSchema,
+  incentives: import_zod7.z.array(incentiveSchema),
+  products: import_zod7.z.array(productSchema),
+  vaultConfig: vaultConfigSchema.optional().nullable(),
+  lendingConfig: lendingConfigSchema.optional().nullable(),
+  // Will be deprecated
+  exposure: import_zod7.z.array(import_zod7.z.string()),
+  explorerUrl: import_zod7.z.string().nullable()
+});
+var opportunityFiltersSchema = import_zod7.z.object({
+  tokenId: import_zod7.z.string().uuid().optional(),
+  chain: import_zod7.z.string().optional(),
+  productId: import_zod7.z.string().uuid().optional()
+});
+var opportunitiesResponseSchema = import_zod7.z.object({
+  opportunities: import_zod7.z.array(opportunitySchema),
+  total: import_zod7.z.number().optional()
+});
+var getOpportunitiesPaginatedInputSchema = import_zod7.z.object({
+  page: import_zod7.z.number().min(1).default(1),
+  limit: import_zod7.z.number().min(1).max(100).default(10),
+  // Sorting
+  sortBy: import_zod7.z.enum([
+    "turtleTvl",
+    "tvl",
+    "name",
+    "turtleUsers",
+    "type",
+    "organization",
+    "curator",
+    "provider",
+    "apr"
+  ]).optional(),
+  sortOrder: import_zod7.z.enum(["asc", "desc"]).optional(),
+  // Filter by receipt token chain (comma-separated)
+  receiptTokenChainId: import_zod7.z.string().optional(),
+  // Comma-separated UUIDs
+  receiptTokenChainSlug: import_zod7.z.string().optional(),
+  // Comma-separated slugs
+  // Filter by deposit token
+  depositTokenGroup: import_zod7.z.string().optional(),
+  depositTokenSymbols: import_zod7.z.string().optional(),
+  // Comma-separated symbols
+  depositTokenChainId: import_zod7.z.string().optional(),
+  // Filter by tags (comma-separated)
+  tags: import_zod7.z.string().optional(),
+  // Filter by IDs (comma-separated UUIDs)
+  productId: import_zod7.z.string().optional(),
+  // Comma-separated UUIDs
+  curatorId: import_zod7.z.string().optional(),
+  // Comma-separated UUIDs
+  providerId: import_zod7.z.string().optional(),
+  // Comma-separated UUIDs
+  partnerId: import_zod7.z.string().optional(),
+  // Comma-separated UUIDs
+  lendingProtocolId: import_zod7.z.string().optional(),
+  // Comma-separated UUIDs
+  // Status filters
+  withdrawalDisabled: import_zod7.z.boolean().optional(),
+  depositDisabled: import_zod7.z.boolean().optional(),
+  status: import_zod7.z.string().optional(),
+  earnEnabled: import_zod7.z.boolean().optional(),
+  featured: import_zod7.z.boolean().optional(),
+  // TVL filters
+  tvlGreaterThan: import_zod7.z.number().optional(),
+  turtleTvlGreaterThan: import_zod7.z.number().optional(),
+  tvlMin: import_zod7.z.number().optional(),
+  tvlMax: import_zod7.z.number().optional(),
+  // APR filters
+  minApr: import_zod7.z.number().optional(),
+  maxApr: import_zod7.z.number().optional(),
+  // Chain IDs (comma-separated)
+  chainIds: import_zod7.z.string().optional(),
+  // Search
+  search: import_zod7.z.string().optional()
+});
+var paginationMetadataSchema2 = import_zod7.z.object({
+  page: import_zod7.z.number(),
+  limit: import_zod7.z.number(),
+  total: import_zod7.z.number(),
+  totalPages: import_zod7.z.number()
+});
+var getOpportunitiesPaginatedSchema = import_zod7.z.object({
+  opportunities: import_zod7.z.array(opportunitySchema),
+  pagination: paginationMetadataSchema2
+});
+var filterChainSchema = import_zod7.z.object({
+  id: import_zod7.z.string().uuid(),
+  name: import_zod7.z.string(),
+  slug: import_zod7.z.string(),
+  chainId: import_zod7.z.string(),
+  logoUrl: import_zod7.z.string(),
+  ecosystem: import_zod7.z.string(),
+  status: import_zod7.z.string(),
+  explorerUrl: import_zod7.z.string()
+});
+var filterOrganizationSchema = import_zod7.z.object({
+  id: import_zod7.z.string().uuid(),
+  name: import_zod7.z.string(),
+  description: import_zod7.z.string(),
+  landingUrl: import_zod7.z.string(),
+  iconUrl: import_zod7.z.string(),
+  organizationType: import_zod7.z.string(),
+  turtleRefCode: import_zod7.z.string(),
+  twitterHandle: import_zod7.z.string(),
+  status: import_zod7.z.string(),
+  featured: import_zod7.z.boolean()
+});
+var filterTagSchema = import_zod7.z.object({
+  id: import_zod7.z.string().uuid(),
+  code: import_zod7.z.string(),
+  name: import_zod7.z.string(),
+  description: import_zod7.z.string().optional().nullable(),
+  color: import_zod7.z.string().optional().nullable(),
+  type: import_zod7.z.string().optional().nullable()
+});
+var depositTokenSymbolSchema = import_zod7.z.object({
+  symbol: import_zod7.z.string(),
+  logoUrl: import_zod7.z.string()
+});
+var getOpportunitiesFilterOptionsSchema = import_zod7.z.object({
+  chains: import_zod7.z.array(filterChainSchema),
+  providers: import_zod7.z.array(filterOrganizationSchema),
+  curators: import_zod7.z.array(filterOrganizationSchema).optional().nullable(),
+  partners: import_zod7.z.array(filterOrganizationSchema).optional().nullable(),
+  tags: import_zod7.z.array(filterTagSchema).optional().nullable(),
+  lendingProtocols: import_zod7.z.array(filterOrganizationSchema),
+  depositTokenSymbols: import_zod7.z.array(depositTokenSymbolSchema).optional().nullable()
+});
+
+// src/v2/opportunities/api.ts
+async function getOpportunities(filters, options) {
+  const params = new URLSearchParams();
+  if (filters?.tokenId) params.append("tokenId", filters.tokenId);
+  if (filters?.chain) params.append("chain", filters.chain);
+  if (filters?.productId) params.append("productId", filters.productId);
+  const queryString = params.toString();
+  const endpoint = `/turtle/opportunities${queryString ? `?${queryString}` : ""}`;
+  const data = await apiClient.fetch(endpoint, {
+    method: "GET",
+    debug: options?.debug
+  });
+  const result = opportunitiesResponseSchema.safeParse(data);
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to parse opportunities: ${result.error.message}`);
+  }
+  return result.data;
+}
+async function getOpportunityById(id, options) {
+  const data = await apiClient.fetch(`/turtle/opportunities/${id}`, {
+    method: "GET",
+    debug: options?.debug
+  });
+  const result = opportunitySchema.safeParse(data);
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to parse opportunity: ${result.error.message}`);
+  }
+  return result.data;
+}
+async function getOpportunitiesPaginated(params, options) {
+  const queryParams = new URLSearchParams();
+  if (params) {
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== void 0 && value !== null) {
+        queryParams.append(key, String(value));
+      }
+    });
+  }
+  const queryString = queryParams.toString();
+  const endpoint = `/turtle/opportunities-paginated${queryString ? `?${queryString}` : ""}`;
+  const data = await apiClient.fetch(endpoint, {
+    method: "GET",
+    debug: options?.debug
+  });
+  const result = getOpportunitiesPaginatedSchema.safeParse(data);
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to parse paginated opportunities: ${result.error.message}`);
+  }
+  return result.data;
+}
+async function getOpportunitiesFilterOptions(options) {
+  const data = await apiClient.fetch("/turtle/opportunities-filter-options", {
+    method: "GET",
+    debug: options?.debug
+  });
+  const result = getOpportunitiesFilterOptionsSchema.safeParse(data);
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to parse opportunities filter options: ${result.error.message}`);
+  }
+  return result.data;
+}
+
+// src/v2/opportunities/queries.ts
+var opportunitiesQueries = (0, import_query_key_factory3.createQueryKeys)("opportunities", {
+  // Get all opportunities (no filters)
+  all: {
+    queryKey: null,
+    queryFn: () => getOpportunities()
+  },
+  // Get opportunities with filters
+  list: (filters) => ({
+    queryKey: [{ filters }],
+    queryFn: () => getOpportunities(filters)
+  }),
+  // Get single opportunity by ID
+  byId: (id) => ({
+    queryKey: [id],
+    queryFn: () => getOpportunityById(id)
+  }),
+  // Get paginated opportunities
+  paginated: (params) => ({
+    queryKey: [{ params }],
+    queryFn: () => getOpportunitiesPaginated(params)
+  }),
+  // Get filter options for opportunities
+  filterOptions: {
+    queryKey: null,
     queryFn: () => getOpportunitiesFilterOptions()
   }
 });
 
 // src/v2/earn-opportunities/queries.ts
-var import_query_key_factory2 = require("@lukemorales/query-key-factory");
+var import_query_key_factory4 = require("@lukemorales/query-key-factory");
 
 // src/v2/earn-opportunities/schema.ts
-var import_zod3 = require("zod");
-var earnOpportunitySchema = import_zod3.z.object({
-  id: import_zod3.z.string().uuid(),
-  name: import_zod3.z.string(),
-  description: import_zod3.z.string(),
-  type: import_zod3.z.string(),
-  estimatedApr: import_zod3.z.number(),
-  tvl: import_zod3.z.number(),
-  featured: import_zod3.z.boolean(),
+var import_zod8 = require("zod");
+var earnOpportunitySchema = import_zod8.z.object({
+  id: import_zod8.z.string().uuid(),
+  name: import_zod8.z.string(),
+  description: import_zod8.z.string(),
+  type: import_zod8.z.string(),
+  estimatedApr: import_zod8.z.number(),
+  tvl: import_zod8.z.number(),
+  featured: import_zod8.z.boolean(),
   baseTokens: tokenSchema,
-  depositTokens: import_zod3.z.array(tokenSchema).nullable(),
+  depositTokens: import_zod8.z.array(tokenSchema).nullable(),
   receiptToken: tokenSchema
 });
-var earnOpportunitiesResponseSchema = import_zod3.z.object({
-  opportunities: import_zod3.z.array(earnOpportunitySchema).nullable(),
-  total: import_zod3.z.number().int()
+var earnOpportunitiesResponseSchema = import_zod8.z.object({
+  opportunities: import_zod8.z.array(earnOpportunitySchema).nullable(),
+  total: import_zod8.z.number().int()
 });
 
 // src/v2/earn-opportunities/api.ts
@@ -739,7 +1104,7 @@ async function getEarnOpportunities(context) {
 }
 
 // src/v2/earn-opportunities/queries.ts
-var earnOpportunitiesQueries = (0, import_query_key_factory2.createQueryKeys)("earnOpportunities", {
+var earnOpportunitiesQueries = (0, import_query_key_factory4.createQueryKeys)("earnOpportunities", {
   all: {
     queryKey: null,
     queryFn: (context) => getEarnOpportunities(context)
@@ -747,86 +1112,86 @@ var earnOpportunitiesQueries = (0, import_query_key_factory2.createQueryKeys)("e
 });
 
 // src/v2/earn-route/queries.ts
-var import_query_key_factory3 = require("@lukemorales/query-key-factory");
+var import_query_key_factory5 = require("@lukemorales/query-key-factory");
 
 // src/v2/earn-route/schema.ts
 var import_utils = require("@turtleclub/utils");
-var import_zod4 = require("zod");
-var assetImageData = import_zod4.z.object({
-  kind: import_zod4.z.literal("image"),
-  url: import_zod4.z.string(),
-  alt: import_zod4.z.string()
-});
-var assetERC20Data = import_zod4.z.object({
-  kind: import_zod4.z.literal("erc20"),
-  address: import_zod4.z.string(),
-  name: import_zod4.z.string(),
-  symbol: import_zod4.z.string(),
-  decimals: import_zod4.z.number()
-});
-var assetData = import_zod4.z.discriminatedUnion("kind", [assetImageData, assetERC20Data]);
-var asset = import_zod4.z.object({
-  id: import_zod4.z.string().uuid(),
-  name: import_zod4.z.string(),
-  slugs: import_zod4.z.array(import_zod4.z.string()),
-  tags: import_zod4.z.array(import_zod4.z.string()),
-  description: import_zod4.z.string().nullable(),
-  data: import_zod4.z.array(assetData)
-});
-var routeToken = import_zod4.z.object({
-  address: import_zod4.z.string(),
-  name: import_zod4.z.string(),
-  symbol: import_zod4.z.string(),
-  logos: import_zod4.z.array(import_zod4.z.string()),
-  decimals: import_zod4.z.number(),
-  chain: import_zod4.z.number(),
-  price: import_zod4.z.number().nullable().optional()
-});
-var swapSubstep = import_zod4.z.object({
-  kind: import_zod4.z.literal("swap"),
-  from: import_zod4.z.array(routeToken),
-  to: import_zod4.z.array(routeToken),
-  protocol: import_zod4.z.string(),
+var import_zod9 = require("zod");
+var assetImageData = import_zod9.z.object({
+  kind: import_zod9.z.literal("image"),
+  url: import_zod9.z.string(),
+  alt: import_zod9.z.string()
+});
+var assetERC20Data = import_zod9.z.object({
+  kind: import_zod9.z.literal("erc20"),
+  address: import_zod9.z.string(),
+  name: import_zod9.z.string(),
+  symbol: import_zod9.z.string(),
+  decimals: import_zod9.z.number()
+});
+var assetData = import_zod9.z.discriminatedUnion("kind", [assetImageData, assetERC20Data]);
+var asset = import_zod9.z.object({
+  id: import_zod9.z.string().uuid(),
+  name: import_zod9.z.string(),
+  slugs: import_zod9.z.array(import_zod9.z.string()),
+  tags: import_zod9.z.array(import_zod9.z.string()),
+  description: import_zod9.z.string().nullable(),
+  data: import_zod9.z.array(assetData)
+});
+var routeToken = import_zod9.z.object({
+  address: import_zod9.z.string(),
+  name: import_zod9.z.string(),
+  symbol: import_zod9.z.string(),
+  logos: import_zod9.z.array(import_zod9.z.string()),
+  decimals: import_zod9.z.number(),
+  chain: import_zod9.z.number(),
+  price: import_zod9.z.number().nullable().optional()
+});
+var swapSubstep = import_zod9.z.object({
+  kind: import_zod9.z.literal("swap"),
+  from: import_zod9.z.array(routeToken),
+  to: import_zod9.z.array(routeToken),
+  protocol: import_zod9.z.string(),
   protocol_asset: asset.nullable(),
-  price_impact: import_zod4.z.number().nullable()
-});
-var depositSubstep = import_zod4.z.object({
-  kind: import_zod4.z.literal("deposit"),
-  vault: import_zod4.z.string(),
-  from: import_zod4.z.array(routeToken),
-  to: import_zod4.z.array(routeToken),
-  amount: import_zod4.z.string(),
-  protocol: import_zod4.z.string(),
+  price_impact: import_zod9.z.number().nullable()
+});
+var depositSubstep = import_zod9.z.object({
+  kind: import_zod9.z.literal("deposit"),
+  vault: import_zod9.z.string(),
+  from: import_zod9.z.array(routeToken),
+  to: import_zod9.z.array(routeToken),
+  amount: import_zod9.z.string(),
+  protocol: import_zod9.z.string(),
   protocol_asset: asset.nullable(),
-  price_impact: import_zod4.z.number().nullable()
+  price_impact: import_zod9.z.number().nullable()
 });
-var routerSubstep = import_zod4.z.discriminatedUnion("kind", [swapSubstep, depositSubstep]);
-var stepTx = import_zod4.z.object({
+var routerSubstep = import_zod9.z.discriminatedUnion("kind", [swapSubstep, depositSubstep]);
+var stepTx = import_zod9.z.object({
   from: import_utils.ethz.address(),
   to: import_utils.ethz.address(),
   data: import_utils.ethz.hex(),
-  value: import_zod4.z.string(),
-  gas: import_zod4.z.number()
+  value: import_zod9.z.string(),
+  gas: import_zod9.z.number()
 });
-var approveStep = import_zod4.z.object({
-  kind: import_zod4.z.literal("approve"),
-  owner: import_zod4.z.string(),
-  spender: import_zod4.z.string(),
+var approveStep = import_zod9.z.object({
+  kind: import_zod9.z.literal("approve"),
+  owner: import_zod9.z.string(),
+  spender: import_zod9.z.string(),
   token: routeToken,
-  amount: import_zod4.z.string(),
+  amount: import_zod9.z.string(),
   tx: stepTx
 });
-var ensoStep = import_zod4.z.object({
-  kind: import_zod4.z.literal("enso"),
-  substeps: import_zod4.z.array(routerSubstep),
+var ensoStep = import_zod9.z.object({
+  kind: import_zod9.z.literal("enso"),
+  substeps: import_zod9.z.array(routerSubstep),
   tx: stepTx,
   asset: asset.nullable()
 });
-var routerStep = import_zod4.z.discriminatedUnion("kind", [approveStep, ensoStep]);
-var earnRouteResponseSchema = import_zod4.z.object({
-  steps: import_zod4.z.array(routerStep),
-  amount_out: import_zod4.z.string(),
-  price_impact: import_zod4.z.number().nullable()
+var routerStep = import_zod9.z.discriminatedUnion("kind", [approveStep, ensoStep]);
+var earnRouteResponseSchema = import_zod9.z.object({
+  steps: import_zod9.z.array(routerStep),
+  amount_out: import_zod9.z.string(),
+  price_impact: import_zod9.z.number().nullable()
 });
 
 // src/v2/earn-route/api.ts
@@ -857,7 +1222,7 @@ async function getEarnRoute(params, context) {
 }
 
 // src/v2/earn-route/queries.ts
-var earnRouteQueries = (0, import_query_key_factory3.createQueryKeys)("earnRoute", {
+var earnRouteQueries = (0, import_query_key_factory5.createQueryKeys)("earnRoute", {
   // Get earn route with specific parameters
   byParams: (params) => ({
     queryKey: [params],
@@ -866,33 +1231,33 @@ var earnRouteQueries = (0, import_query_key_factory3.createQueryKeys)("earnRoute
 });
 
 // src/v2/earn-membership/queries.ts
-var import_query_key_factory4 = require("@lukemorales/query-key-factory");
+var import_query_key_factory6 = require("@lukemorales/query-key-factory");
 
 // src/v2/earn-membership/schema.ts
-var import_zod5 = require("zod");
-var walletEcosystemEnum = import_zod5.z.enum(["evm", "solana", "ton"]);
-var checkMembershipResponseSchema = import_zod5.z.object({
-  isMember: import_zod5.z.boolean()
+var import_zod10 = require("zod");
+var walletEcosystemEnum = import_zod10.z.enum(["evm", "solana", "ton"]);
+var checkMembershipResponseSchema = import_zod10.z.object({
+  isMember: import_zod10.z.boolean()
 });
-var createAgreementRequestSchema = import_zod5.z.object({
-  address: import_zod5.z.string(),
+var createAgreementRequestSchema = import_zod10.z.object({
+  address: import_zod10.z.string(),
   walletEcosystem: walletEcosystemEnum,
-  url: import_zod5.z.string(),
-  chainId: import_zod5.z.string().default("1")
+  url: import_zod10.z.string(),
+  chainId: import_zod10.z.string().default("1")
 });
-var createAgreementResponseSchema = import_zod5.z.object({
-  message: import_zod5.z.string(),
-  nonce: import_zod5.z.string()
+var createAgreementResponseSchema = import_zod10.z.object({
+  message: import_zod10.z.string(),
+  nonce: import_zod10.z.string()
 });
-var createMembershipRequestSchema = import_zod5.z.object({
-  address: import_zod5.z.string(),
-  walletEcosystem: import_zod5.z.string(),
-  signature: import_zod5.z.string(),
-  nonce: import_zod5.z.string()
+var createMembershipRequestSchema = import_zod10.z.object({
+  address: import_zod10.z.string(),
+  walletEcosystem: import_zod10.z.string(),
+  signature: import_zod10.z.string(),
+  nonce: import_zod10.z.string()
 });
-var createMembershipResponseSchema = import_zod5.z.object({
-  isMember: import_zod5.z.boolean(),
-  error: import_zod5.z.string().optional()
+var createMembershipResponseSchema = import_zod10.z.object({
+  isMember: import_zod10.z.boolean(),
+  error: import_zod10.z.string().optional()
 });
 
 // src/v2/earn-membership/api.ts
@@ -941,7 +1306,7 @@ async function createMembership(request) {
 }
 
 // src/v2/earn-membership/queries.ts
-var earnMembershipQueries = (0, import_query_key_factory4.createQueryKeys)("earnMembership", {
+var earnMembershipQueries = (0, import_query_key_factory6.createQueryKeys)("earnMembership", {
   // Check membership status
   check: (params) => ({
     queryKey: [params],
@@ -950,26 +1315,26 @@ var earnMembershipQueries = (0, import_query_key_factory4.createQueryKeys)("earn
 });
 
 // src/v2/earn-deposits/queries.ts
-var import_query_key_factory5 = require("@lukemorales/query-key-factory");
+var import_query_key_factory7 = require("@lukemorales/query-key-factory");
 
 // src/v2/earn-deposits/schema.ts
-var import_zod6 = require("zod");
-var depositSchema = import_zod6.z.object({
-  chain: import_zod6.z.number().int(),
-  deposited_amount_usd: import_zod6.z.string(),
-  deposited_token_address: import_zod6.z.string(),
-  deposited_token_decimals: import_zod6.z.number().int(),
-  deposited_token_logo: import_zod6.z.string(),
-  deposited_token_name: import_zod6.z.string(),
-  deposited_token_symbol: import_zod6.z.string(),
-  deposited_value: import_zod6.z.string(),
-  depositor: import_zod6.z.string(),
-  target: import_zod6.z.string(),
-  timestamp: import_zod6.z.string(),
-  tx_hash: import_zod6.z.string()
-});
-var depositsResponseSchema = import_zod6.z.object({
-  deposits: import_zod6.z.array(depositSchema).nullable()
+var import_zod11 = require("zod");
+var depositSchema = import_zod11.z.object({
+  chain: import_zod11.z.number().int(),
+  deposited_amount_usd: import_zod11.z.string(),
+  deposited_token_address: import_zod11.z.string(),
+  deposited_token_decimals: import_zod11.z.number().int(),
+  deposited_token_logo: import_zod11.z.string(),
+  deposited_token_name: import_zod11.z.string(),
+  deposited_token_symbol: import_zod11.z.string(),
+  deposited_value: import_zod11.z.string(),
+  depositor: import_zod11.z.string(),
+  target: import_zod11.z.string(),
+  timestamp: import_zod11.z.string(),
+  tx_hash: import_zod11.z.string()
+});
+var depositsResponseSchema = import_zod11.z.object({
+  deposits: import_zod11.z.array(depositSchema).nullable()
 });
 
 // src/v2/earn-deposits/api.ts
@@ -996,7 +1361,7 @@ async function getDeposits(params, context) {
 }
 
 // src/v2/earn-deposits/queries.ts
-var earnDepositsQueries = (0, import_query_key_factory5.createQueryKeys)("earnDeposits", {
+var earnDepositsQueries = (0, import_query_key_factory7.createQueryKeys)("earnDeposits", {
   byParams: (params) => ({
     queryKey: [params],
     queryFn: (context) => getDeposits(params, context)
@@ -1004,88 +1369,15 @@ var earnDepositsQueries = (0, import_query_key_factory5.createQueryKeys)("earnDe
 });
 
 // src/v2/earn-actions/queries.ts
-var import_query_key_factory6 = require("@lukemorales/query-key-factory");
-var earnActionsQueries = (0, import_query_key_factory6.createQueryKeys)("earnActions", {
+var import_query_key_factory8 = require("@lukemorales/query-key-factory");
+var earnActionsQueries = (0, import_query_key_factory8.createQueryKeys)("earnActions", {
   // Placeholder for potential future GET endpoints
   // e.g., getting action history
 });
 var earnInteractionsQueries = earnActionsQueries;
 
 // src/v2/products/queries.ts
-var import_query_key_factory7 = require("@lukemorales/query-key-factory");
-
-// src/v2/products/schema.ts
-var import_zod7 = require("zod");
-var ProductTypeSchema = import_zod7.z.enum(["deal", "campaign"]);
-var ProductStatusSchema = import_zod7.z.enum(["draft", "active", "paused", "ended"]);
-var TurtleOrganizationSchema = import_zod7.z.object({
-  id: import_zod7.z.string().uuid(),
-  name: import_zod7.z.string(),
-  iconUrl: import_zod7.z.string(),
-  landingUrl: import_zod7.z.string()
-});
-var ProductSchema = import_zod7.z.object({
-  id: import_zod7.z.string().uuid(),
-  name: import_zod7.z.string(),
-  title: import_zod7.z.string(),
-  subtitle: import_zod7.z.string(),
-  description: import_zod7.z.string(),
-  logoUrl: import_zod7.z.string(),
-  productUrl: import_zod7.z.string(),
-  startedAt: import_zod7.z.string().optional().nullable(),
-  endedAt: import_zod7.z.string().optional().nullable(),
-  status: ProductStatusSchema,
-  productType: ProductTypeSchema,
-  organization: TurtleOrganizationSchema.nullable(),
-  opportunities: import_zod7.z.array(opportunitySchema).nullish(),
-  createdAt: import_zod7.z.string()
-});
-var CreateProductInputSchema = import_zod7.z.object({
-  product: ProductSchema.omit({
-    id: true,
-    createdAt: true,
-    organization: true
-  }),
-  organizationId: import_zod7.z.string().uuid()
-});
-var UpdateProductInputSchema = import_zod7.z.object({
-  product: ProductSchema.partial().omit({
-    organization: true
-  })
-  // organizationId: z.string().uuid(),
-});
-var ProductsResponseSchema = import_zod7.z.object({
-  products: import_zod7.z.array(ProductSchema),
-  total: import_zod7.z.number().optional()
-});
-var ProductResponseSchema = import_zod7.z.object({
-  product: ProductSchema
-});
-var CreateProductResponseSchema = import_zod7.z.object({
-  id: import_zod7.z.string().uuid()
-});
-var UpdateProductResponseSchema = import_zod7.z.object({
-  success: import_zod7.z.boolean()
-});
-var fileSchema = import_zod7.z.any().refine((value) => {
-  if (!value) return false;
-  if (!(value instanceof File)) return false;
-  if (value.size > 10 * 1024 * 1024) return false;
-  return true;
-}, "Invalid file");
-var UploadProductLogoRequestSchema = import_zod7.z.object({
-  // Form data - file upload (required)
-  file: fileSchema,
-  // Form data - optional filename override
-  filename: import_zod7.z.string().optional()
-});
-var UploadProductLogoResponseSchema = import_zod7.z.object({
-  url: import_zod7.z.string().url(),
-  error: import_zod7.z.string().optional()
-});
-var ProductFiltersSchema = import_zod7.z.object({
-  organizationId: import_zod7.z.string().uuid().optional()
-});
+var import_query_key_factory9 = require("@lukemorales/query-key-factory");
 
 // src/v2/products/api.ts
 async function getProducts(filters) {
@@ -1096,7 +1388,7 @@ async function getProducts(filters) {
   const data = await apiClient.fetch(endpoint, {
     method: "GET"
   });
-  const result = ProductsResponseSchema.safeParse(data);
+  const result = productsResponseSchema.safeParse(data);
   if (result.success === false) {
     console.log("[ZOD ERROR]", result.error);
     throw new Error(`Failed to parse products: ${result.error.message}`);
@@ -1108,7 +1400,7 @@ async function getProduct(id) {
   const data = await apiClient.fetch(endpoint, {
     method: "GET"
   });
-  const result = ProductResponseSchema.safeParse(data);
+  const result = productResponseSchema.safeParse(data);
   if (result.success === false) {
     console.log("[ZOD ERROR]", result.error);
     throw new Error(`Failed to parse product: ${result.error.message}`);
@@ -1121,7 +1413,7 @@ async function createProduct(input) {
     method: "POST",
     body: input
   });
-  const result = CreateProductResponseSchema.safeParse(data);
+  const result = createProductResponseSchema.safeParse(data);
   if (result.success === false) {
     console.log("[ZOD ERROR]", result.error);
     throw new Error(`Failed to create product: ${result.error.message}`);
@@ -1134,7 +1426,7 @@ async function updateProduct(input) {
     method: "PUT",
     body: input
   });
-  const result = UpdateProductResponseSchema.safeParse(data);
+  const result = updateProductResponseSchema.safeParse(data);
   if (result.success === false) {
     console.log("[ZOD ERROR]", result.error);
     throw new Error(`Failed to update product: ${result.error.message}`);
@@ -1146,7 +1438,7 @@ async function deleteProduct(id) {
   const data = await apiClient.fetch(endpoint, {
     method: "DELETE"
   });
-  const result = ProductResponseSchema.safeParse(data);
+  const result = productResponseSchema.safeParse(data);
   if (result.success === false) {
     console.log("[ZOD ERROR]", result.error);
     throw new Error(`Failed to delete product: ${result.error.message}`);
@@ -1163,7 +1455,7 @@ async function uploadProductLogo({
     method: "POST",
     body: formData
   });
-  const result = UploadProductLogoResponseSchema.safeParse(data);
+  const result = uploadProductLogoResponseSchema.safeParse(data);
   if (result.success === false) {
     console.log("[ZOD ERROR]", result.error);
     throw new Error(`Failed to upload product logo: ${result.error.message}`);
@@ -1172,7 +1464,7 @@ async function uploadProductLogo({
 }
 
 // src/v2/products/queries.ts
-var productsQueries = (0, import_query_key_factory7.createQueryKeys)("products", {
+var productsQueries = (0, import_query_key_factory9.createQueryKeys)("products", {
   // Get all products (no filters)
   all: () => ({
     queryKey: ["all"],
@@ -1189,25 +1481,25 @@ var productsQueries = (0, import_query_key_factory7.createQueryKeys)("products",
 });
 
 // src/v2/enso-balances/queries.ts
-var import_query_key_factory8 = require("@lukemorales/query-key-factory");
+var import_query_key_factory10 = require("@lukemorales/query-key-factory");
 
 // src/v2/enso-balances/schemas.ts
-var import_zod8 = require("zod");
-var balanceTokenSchema = import_zod8.z.object({
-  address: import_zod8.z.string(),
-  name: import_zod8.z.string(),
-  symbol: import_zod8.z.string(),
-  logos: import_zod8.z.array(import_zod8.z.string()),
-  decimals: import_zod8.z.number(),
-  chain: import_zod8.z.number(),
-  price: import_zod8.z.number().nullable().optional()
-});
-var walletBalanceSchema = import_zod8.z.object({
+var import_zod12 = require("zod");
+var balanceTokenSchema = import_zod12.z.object({
+  address: import_zod12.z.string(),
+  name: import_zod12.z.string(),
+  symbol: import_zod12.z.string(),
+  logos: import_zod12.z.array(import_zod12.z.string()),
+  decimals: import_zod12.z.number(),
+  chain: import_zod12.z.number(),
+  price: import_zod12.z.number().nullable().optional()
+});
+var walletBalanceSchema = import_zod12.z.object({
   token: balanceTokenSchema,
-  amount: import_zod8.z.string()
+  amount: import_zod12.z.string()
 });
-var walletBalancesResponseSchema = import_zod8.z.object({
-  balances: import_zod8.z.array(walletBalanceSchema)
+var walletBalancesResponseSchema = import_zod12.z.object({
+  balances: import_zod12.z.array(walletBalanceSchema)
 });
 
 // src/v2/enso-balances/api.ts
@@ -1232,7 +1524,7 @@ async function getWalletBalances(params, context) {
 }
 
 // src/v2/enso-balances/queries.ts
-var ensoBalancesQueries = (0, import_query_key_factory8.createQueryKeys)("ensoBalances", {
+var ensoBalancesQueries = (0, import_query_key_factory10.createQueryKeys)("ensoBalances", {
   byParams: (params) => ({
     queryKey: [params],
     queryFn: (context) => getWalletBalances(params, context)
@@ -1240,13 +1532,65 @@ var ensoBalancesQueries = (0, import_query_key_factory8.createQueryKeys)("ensoBa
 });
 
 // src/v2/widget/queries.ts
-var import_query_key_factory9 = require("@lukemorales/query-key-factory");
+var import_query_key_factory11 = require("@lukemorales/query-key-factory");
 
 // src/v2/widget/schema.ts
-var import_zod9 = require("zod");
-var widgetOpportunitiesResponseSchema = import_zod9.z.object({
-  opportunities: import_zod9.z.array(opportunitySchema).nullable(),
-  total: import_zod9.z.number().int()
+var import_zod13 = require("zod");
+
+// src/v2/opportunities/hooks.ts
+var import_react_query4 = require("@tanstack/react-query");
+function useOpportunities(options) {
+  return (0, import_react_query4.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_query4.useQuery)({
+    ...opportunitiesQueries.byId(id),
+    ...queryDefaults,
+    select: (data) => {
+      return {
+        ...data,
+        chain: data.receiptToken?.chain
+      };
+    }
+  });
+}
+function useOpportunitiesPaginated({
+  params,
+  enabled = true
+} = {}) {
+  return (0, import_react_query4.useQuery)({
+    ...opportunitiesQueries.paginated(params),
+    ...queryDefaults,
+    enabled
+  });
+}
+function useOpportunitiesFilterOptions({
+  enabled = true
+} = {}) {
+  return (0, import_react_query4.useQuery)({
+    ...opportunitiesQueries.filterOptions,
+    ...queryDefaults,
+    enabled
+  });
+}
+
+// src/v2/widget/schema.ts
+var widgetOpportunitiesResponseSchema = import_zod13.z.object({
+  opportunities: import_zod13.z.array(opportunitySchema).nullable(),
+  total: import_zod13.z.number().int()
 });
 
 // src/v2/widget/api.ts
@@ -1264,7 +1608,7 @@ async function getWidgetOpportunities(distributorId, context) {
 }
 
 // src/v2/widget/queries.ts
-var widgetQueries = (0, import_query_key_factory9.createQueryKeys)("widget", {
+var widgetQueries = (0, import_query_key_factory11.createQueryKeys)("widget", {
   opportunities: (distributorId) => ({
     queryKey: [distributorId],
     queryFn: (context) => getWidgetOpportunities(distributorId, context)
@@ -1272,245 +1616,245 @@ var widgetQueries = (0, import_query_key_factory9.createQueryKeys)("widget", {
 });
 
 // src/v2/streams/queries.ts
-var import_query_key_factory10 = require("@lukemorales/query-key-factory");
+var import_query_key_factory12 = require("@lukemorales/query-key-factory");
 
 // src/v2/streams/schemas.ts
-var import_zod10 = require("zod");
-var snapshotSchema = import_zod10.z.object({
-  amountBase: import_zod10.z.string(),
-  amountDistributed: import_zod10.z.string(),
-  createdAt: import_zod10.z.string().datetime(),
-  rootHash: import_zod10.z.string().nullable(),
-  timestamp: import_zod10.z.string().datetime(),
-  updatedAt: import_zod10.z.string().datetime(),
-  userCount: import_zod10.z.number().nullable().optional(),
-  tvl: import_zod10.z.string().nullable().optional(),
-  baseTvl: import_zod10.z.string().nullable().optional()
-});
-var streamPointSchema = import_zod10.z.object({
-  id: import_zod10.z.string(),
-  orgId: import_zod10.z.string().optional(),
-  symbol: import_zod10.z.string(),
-  name: import_zod10.z.string(),
-  decimals: import_zod10.z.coerce.number().optional(),
-  logoUrl: import_zod10.z.string().url().nullable().optional(),
-  createdAt: import_zod10.z.string().optional(),
-  updatedAt: import_zod10.z.string().optional(),
-  deletedAt: import_zod10.z.string().nullable().optional(),
+var import_zod14 = require("zod");
+var snapshotSchema = import_zod14.z.object({
+  amountBase: import_zod14.z.string(),
+  amountDistributed: import_zod14.z.string(),
+  createdAt: import_zod14.z.string().datetime(),
+  rootHash: import_zod14.z.string().nullable(),
+  timestamp: import_zod14.z.string().datetime(),
+  updatedAt: import_zod14.z.string().datetime(),
+  userCount: import_zod14.z.number().nullable().optional(),
+  tvl: import_zod14.z.string().nullable().optional(),
+  baseTvl: import_zod14.z.string().nullable().optional()
+});
+var streamPointSchema = import_zod14.z.object({
+  id: import_zod14.z.string(),
+  orgId: import_zod14.z.string().optional(),
+  symbol: import_zod14.z.string(),
+  name: import_zod14.z.string(),
+  decimals: import_zod14.z.coerce.number().optional(),
+  logoUrl: import_zod14.z.string().url().nullable().optional(),
+  createdAt: import_zod14.z.string().optional(),
+  updatedAt: import_zod14.z.string().optional(),
+  deletedAt: import_zod14.z.string().nullable().optional(),
   organization: organizationSchema.nullable().optional()
 });
-var customArgsTokensPerUsdSchema = import_zod10.z.object({
-  tokensPerUSD: import_zod10.z.string(),
-  targetChainId: import_zod10.z.number(),
-  targetTokenAddress: import_zod10.z.string()
-});
-var customArgsAprSchema = import_zod10.z.object({
-  apr: import_zod10.z.string(),
-  targetChainId: import_zod10.z.number(),
-  targetTokenAddress: import_zod10.z.string()
-});
-var chainSchema3 = import_zod10.z.object({
-  chainId: import_zod10.z.coerce.number(),
-  ecosystem: import_zod10.z.string(),
-  explorerUrl: import_zod10.z.string(),
-  id: import_zod10.z.string().uuid(),
-  isTestnet: import_zod10.z.boolean(),
-  logoUrl: import_zod10.z.string(),
-  name: import_zod10.z.string(),
-  slug: import_zod10.z.string(),
-  status: import_zod10.z.string()
-});
-var rewardTokenSchema = import_zod10.z.object({
-  active: import_zod10.z.boolean(),
-  address: import_zod10.z.string(),
-  canonicalAssetId: import_zod10.z.string().uuid(),
-  chain: chainSchema3,
-  decimals: import_zod10.z.number(),
-  id: import_zod10.z.string().uuid(),
-  isNative: import_zod10.z.boolean(),
-  logoUrl: import_zod10.z.string(),
-  name: import_zod10.z.string(),
-  priceUsd: import_zod10.z.number(),
-  symbol: import_zod10.z.string(),
-  streamsMinAmount: import_zod10.z.string().nullable().optional()
+var customArgsTokensPerUsdSchema = import_zod14.z.object({
+  tokensPerUSD: import_zod14.z.string(),
+  targetChainId: import_zod14.z.number(),
+  targetTokenAddress: import_zod14.z.string()
+});
+var customArgsAprSchema = import_zod14.z.object({
+  apr: import_zod14.z.string(),
+  targetChainId: import_zod14.z.number(),
+  targetTokenAddress: import_zod14.z.string()
+});
+var chainSchema2 = import_zod14.z.object({
+  chainId: import_zod14.z.coerce.number(),
+  ecosystem: import_zod14.z.string(),
+  explorerUrl: import_zod14.z.string(),
+  id: import_zod14.z.string().uuid(),
+  isTestnet: import_zod14.z.boolean(),
+  logoUrl: import_zod14.z.string(),
+  name: import_zod14.z.string(),
+  slug: import_zod14.z.string(),
+  status: import_zod14.z.string()
+});
+var rewardTokenSchema = import_zod14.z.object({
+  active: import_zod14.z.boolean(),
+  address: import_zod14.z.string(),
+  canonicalAssetId: import_zod14.z.string().uuid(),
+  chain: chainSchema2,
+  decimals: import_zod14.z.number(),
+  id: import_zod14.z.string().uuid(),
+  isNative: import_zod14.z.boolean(),
+  logoUrl: import_zod14.z.string(),
+  name: import_zod14.z.string(),
+  priceUsd: import_zod14.z.number(),
+  symbol: import_zod14.z.string(),
+  streamsMinAmount: import_zod14.z.string().nullable().optional()
 }).nullable();
-var adaptersSchema = import_zod10.z.array(
-  import_zod10.z.object({
-    type: import_zod10.z.string(),
-    params: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.number())
+var adaptersSchema = import_zod14.z.array(
+  import_zod14.z.object({
+    type: import_zod14.z.string(),
+    params: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.number())
   })
 );
-var feeTierSchema = import_zod10.z.object({
-  maxTVL: import_zod10.z.string().nullable(),
+var feeTierSchema = import_zod14.z.object({
+  maxTVL: import_zod14.z.string().nullable(),
   // represents a USD amount
-  feePct: import_zod10.z.string()
+  feePct: import_zod14.z.string()
   // represents a percentage (e.g. 0.15 means 15%)
 });
-var feeScheduleSchema = import_zod10.z.object({
-  feeTiers: import_zod10.z.array(feeTierSchema),
-  until: import_zod10.z.string().datetime().nullable()
+var feeScheduleSchema = import_zod14.z.object({
+  feeTiers: import_zod14.z.array(feeTierSchema),
+  until: import_zod14.z.string().datetime().nullable()
 });
-var feeSnapshotSchema = import_zod10.z.object({
-  timestamp: import_zod10.z.string().datetime(),
-  tvl: import_zod10.z.string().nullable(),
+var feeSnapshotSchema = import_zod14.z.object({
+  timestamp: import_zod14.z.string().datetime(),
+  tvl: import_zod14.z.string().nullable(),
   // means USD amount
-  accumulatedFee: import_zod10.z.string(),
+  accumulatedFee: import_zod14.z.string(),
   // means USD amount
-  createdAt: import_zod10.z.string().datetime(),
-  updatedAt: import_zod10.z.string().datetime()
-});
-var feeSchema = import_zod10.z.object({
-  managementFeeSchedules: import_zod10.z.array(feeScheduleSchema),
-  createdAt: import_zod10.z.string().datetime(),
-  updatedAt: import_zod10.z.string().datetime(),
-  lastFeeSnapshotTimestamp: import_zod10.z.string().datetime(),
-  feeComputationPaused: import_zod10.z.boolean(),
-  feeSnapshots: import_zod10.z.array(feeSnapshotSchema).optional(),
+  createdAt: import_zod14.z.string().datetime(),
+  updatedAt: import_zod14.z.string().datetime()
+});
+var feeSchema = import_zod14.z.object({
+  managementFeeSchedules: import_zod14.z.array(feeScheduleSchema),
+  createdAt: import_zod14.z.string().datetime(),
+  updatedAt: import_zod14.z.string().datetime(),
+  lastFeeSnapshotTimestamp: import_zod14.z.string().datetime(),
+  feeComputationPaused: import_zod14.z.boolean(),
+  feeSnapshots: import_zod14.z.array(feeSnapshotSchema).optional(),
   lastFeeSnapshot: feeSnapshotSchema.nullable()
 });
-var streamSchema = import_zod10.z.object({
+var streamSchema = import_zod14.z.object({
   adapters: adaptersSchema,
-  admin: import_zod10.z.string().nullable(),
-  chainId: import_zod10.z.number().nullable(),
-  chargedFee: import_zod10.z.string().nullable(),
-  claimPaused: import_zod10.z.boolean(),
-  contractAddress: import_zod10.z.string().nullable(),
-  createdAt: import_zod10.z.string().datetime(),
-  creationConfirmedAt: import_zod10.z.string().datetime().nullable(),
-  customArgs: import_zod10.z.union([customArgsTokensPerUsdSchema, customArgsAprSchema]),
-  endTimestamp: import_zod10.z.string().datetime().nullable(),
+  admin: import_zod14.z.string().nullable(),
+  chainId: import_zod14.z.number().nullable(),
+  chargedFee: import_zod14.z.string().nullable(),
+  claimPaused: import_zod14.z.boolean(),
+  contractAddress: import_zod14.z.string().nullable(),
+  createdAt: import_zod14.z.string().datetime(),
+  creationConfirmedAt: import_zod14.z.string().datetime().nullable(),
+  customArgs: import_zod14.z.union([customArgsTokensPerUsdSchema, customArgsAprSchema]),
+  endTimestamp: import_zod14.z.string().datetime().nullable(),
   fee: feeSchema.nullable(),
-  hashCommitmentPaused: import_zod10.z.boolean(),
-  id: import_zod10.z.string().uuid(),
+  hashCommitmentPaused: import_zod14.z.boolean(),
+  id: import_zod14.z.string().uuid(),
   lastSnapshot: snapshotSchema.nullable(),
-  merkleTreeComputationPaused: import_zod10.z.boolean(),
-  orgId: import_zod10.z.string().uuid(),
+  merkleTreeComputationPaused: import_zod14.z.boolean(),
+  orgId: import_zod14.z.string().uuid(),
   point: streamPointSchema.nullable().optional(),
   rewardToken: rewardTokenSchema,
-  snapshotComputationPaused: import_zod10.z.boolean(),
-  snapshots: import_zod10.z.array(snapshotSchema).optional(),
-  startTimestamp: import_zod10.z.string().datetime(),
-  strategy: import_zod10.z.string(),
-  totalAmount: import_zod10.z.string().nullable(),
-  type: import_zod10.z.number(),
-  updatedAt: import_zod10.z.string().datetime(),
-  userId: import_zod10.z.string().uuid()
-});
-var getStreamsOutputSchema = import_zod10.z.object({
-  streams: import_zod10.z.array(streamSchema)
-});
-var getStreamPointsOutputSchema = import_zod10.z.object({
-  points: import_zod10.z.array(streamPointSchema)
-});
-var createStreamPointBodySchema = import_zod10.z.object({
-  name: import_zod10.z.string(),
-  symbol: import_zod10.z.string(),
-  decimals: import_zod10.z.number().optional(),
-  logoUrl: import_zod10.z.string().url().nullable().optional()
-});
-var createStreamPointOutputSchema = import_zod10.z.object({
+  snapshotComputationPaused: import_zod14.z.boolean(),
+  snapshots: import_zod14.z.array(snapshotSchema).optional(),
+  startTimestamp: import_zod14.z.string().datetime(),
+  strategy: import_zod14.z.string(),
+  totalAmount: import_zod14.z.string().nullable(),
+  type: import_zod14.z.number(),
+  updatedAt: import_zod14.z.string().datetime(),
+  userId: import_zod14.z.string().uuid()
+});
+var getStreamsOutputSchema = import_zod14.z.object({
+  streams: import_zod14.z.array(streamSchema)
+});
+var getStreamPointsOutputSchema = import_zod14.z.object({
+  points: import_zod14.z.array(streamPointSchema)
+});
+var createStreamPointBodySchema = import_zod14.z.object({
+  name: import_zod14.z.string(),
+  symbol: import_zod14.z.string(),
+  decimals: import_zod14.z.number().optional(),
+  logoUrl: import_zod14.z.string().url().nullable().optional()
+});
+var createStreamPointOutputSchema = import_zod14.z.object({
   point: streamPointSchema
 });
-var getStreamsSupportedChainsOutputSchema = import_zod10.z.object({
-  success: import_zod10.z.boolean(),
-  chains: import_zod10.z.array(
-    import_zod10.z.object({
-      id: import_zod10.z.string(),
-      name: import_zod10.z.string(),
-      slug: import_zod10.z.string(),
-      chainId: import_zod10.z.number(),
-      logoUrl: import_zod10.z.string(),
-      ecosystem: import_zod10.z.string(),
-      status: import_zod10.z.string(),
-      explorerUrl: import_zod10.z.string(),
-      streamFactory: import_zod10.z.string()
+var getStreamsSupportedChainsOutputSchema = import_zod14.z.object({
+  success: import_zod14.z.boolean(),
+  chains: import_zod14.z.array(
+    import_zod14.z.object({
+      id: import_zod14.z.string(),
+      name: import_zod14.z.string(),
+      slug: import_zod14.z.string(),
+      chainId: import_zod14.z.number(),
+      logoUrl: import_zod14.z.string(),
+      ecosystem: import_zod14.z.string(),
+      status: import_zod14.z.string(),
+      explorerUrl: import_zod14.z.string(),
+      streamFactory: import_zod14.z.string()
       // Address as string
     })
   )
 });
-var streamSignatureRequestInputSchema = import_zod10.z.object({
+var streamSignatureRequestInputSchema = import_zod14.z.object({
   adapters: adaptersSchema,
-  chainId: import_zod10.z.number().nullable(),
-  customArgs: import_zod10.z.intersection(
-    import_zod10.z.object({
-      targetChainId: import_zod10.z.number(),
-      targetTokenAddress: import_zod10.z.string()
+  chainId: import_zod14.z.number().nullable(),
+  customArgs: import_zod14.z.intersection(
+    import_zod14.z.object({
+      targetChainId: import_zod14.z.number(),
+      targetTokenAddress: import_zod14.z.string()
     }),
-    import_zod10.z.union([import_zod10.z.object({ tokensPerUSD: import_zod10.z.string() }), import_zod10.z.object({ apr: import_zod10.z.string() })])
+    import_zod14.z.union([import_zod14.z.object({ tokensPerUSD: import_zod14.z.string() }), import_zod14.z.object({ apr: import_zod14.z.string() })])
   ),
-  endTimestamp: import_zod10.z.string().nullable(),
-  pointId: import_zod10.z.string().uuid().nullable(),
-  rewardToken: import_zod10.z.string().nullable(),
-  startTimestamp: import_zod10.z.string(),
-  totalAmount: import_zod10.z.string().nullable(),
-  type: import_zod10.z.number(),
-  walletAddress: import_zod10.z.string().nullable()
-});
-var streamSignatureRequestOutputSchema = import_zod10.z.object({
-  success: import_zod10.z.boolean(),
-  message: import_zod10.z.string(),
-  txParams: import_zod10.z.object({
-    chainId: import_zod10.z.number(),
-    sender: import_zod10.z.string(),
-    params: import_zod10.z.object({
-      deadline: import_zod10.z.number(),
-      params: import_zod10.z.object({
-        StreamId: import_zod10.z.array(import_zod10.z.number()),
-        RewardToken: import_zod10.z.string(),
-        NetTotalAmount: import_zod10.z.string(),
-        FeeAmount: import_zod10.z.string()
+  endTimestamp: import_zod14.z.string().nullable(),
+  pointId: import_zod14.z.string().uuid().nullable(),
+  rewardToken: import_zod14.z.string().nullable(),
+  startTimestamp: import_zod14.z.string(),
+  totalAmount: import_zod14.z.string().nullable(),
+  type: import_zod14.z.number(),
+  walletAddress: import_zod14.z.string().nullable()
+});
+var streamSignatureRequestOutputSchema = import_zod14.z.object({
+  success: import_zod14.z.boolean(),
+  message: import_zod14.z.string(),
+  txParams: import_zod14.z.object({
+    chainId: import_zod14.z.number(),
+    sender: import_zod14.z.string(),
+    params: import_zod14.z.object({
+      deadline: import_zod14.z.number(),
+      params: import_zod14.z.object({
+        StreamId: import_zod14.z.array(import_zod14.z.number()),
+        RewardToken: import_zod14.z.string(),
+        NetTotalAmount: import_zod14.z.string(),
+        FeeAmount: import_zod14.z.string()
       }),
-      signature: import_zod10.z.string()
+      signature: import_zod14.z.string()
     })
   }).nullable()
 });
-var getStreamsQuerySchema = import_zod10.z.object({
-  streamId: import_zod10.z.string().optional(),
-  userId: import_zod10.z.string().optional(),
-  organizationId: import_zod10.z.string().optional(),
-  withSnapshots: import_zod10.z.boolean().optional(),
-  usersCount: import_zod10.z.boolean().optional()
-});
-var getStreamPointsQuerySchema = import_zod10.z.object({
-  id: import_zod10.z.string().optional().nullable(),
-  organizationId: import_zod10.z.string().optional().nullable(),
-  symbol: import_zod10.z.string().optional().nullable(),
-  name: import_zod10.z.string().optional().nullable()
-});
-var streamWalletSnapshotSchema = import_zod10.z.object({
-  timestamp: import_zod10.z.string().datetime(),
-  rewardsAccumulated: import_zod10.z.string(),
-  rewardsAccumulatedBase: import_zod10.z.string(),
-  createdAt: import_zod10.z.string().datetime(),
-  updatedAt: import_zod10.z.string().datetime(),
-  tvl: import_zod10.z.string().nullable().optional()
-});
-var streamWalletSchema = import_zod10.z.object({
-  userAddress: import_zod10.z.string(),
+var getStreamsQuerySchema = import_zod14.z.object({
+  streamId: import_zod14.z.string().optional(),
+  userId: import_zod14.z.string().optional(),
+  organizationId: import_zod14.z.string().optional(),
+  withSnapshots: import_zod14.z.boolean().optional(),
+  usersCount: import_zod14.z.boolean().optional()
+});
+var getStreamPointsQuerySchema = import_zod14.z.object({
+  id: import_zod14.z.string().optional().nullable(),
+  organizationId: import_zod14.z.string().optional().nullable(),
+  symbol: import_zod14.z.string().optional().nullable(),
+  name: import_zod14.z.string().optional().nullable()
+});
+var streamWalletSnapshotSchema = import_zod14.z.object({
+  timestamp: import_zod14.z.string().datetime(),
+  rewardsAccumulated: import_zod14.z.string(),
+  rewardsAccumulatedBase: import_zod14.z.string(),
+  createdAt: import_zod14.z.string().datetime(),
+  updatedAt: import_zod14.z.string().datetime(),
+  tvl: import_zod14.z.string().nullable().optional()
+});
+var streamWalletSchema = import_zod14.z.object({
+  userAddress: import_zod14.z.string(),
   lastSnapshot: streamWalletSnapshotSchema
 });
-var paginationSchema = import_zod10.z.object({
-  limit: import_zod10.z.number(),
-  page: import_zod10.z.number(),
-  total: import_zod10.z.number(),
-  totalPages: import_zod10.z.number()
+var paginationSchema = import_zod14.z.object({
+  limit: import_zod14.z.number(),
+  page: import_zod14.z.number(),
+  total: import_zod14.z.number(),
+  totalPages: import_zod14.z.number()
 });
-var getStreamWalletsResponseSchema = import_zod10.z.object({
-  data: import_zod10.z.array(streamWalletSchema),
+var getStreamWalletsResponseSchema = import_zod14.z.object({
+  data: import_zod14.z.array(streamWalletSchema),
   pagination: paginationSchema
 });
-var getStreamWalletsQuerySchema = import_zod10.z.object({
-  streamId: import_zod10.z.string(),
-  page: import_zod10.z.number().optional(),
-  limit: import_zod10.z.number().optional()
+var getStreamWalletsQuerySchema = import_zod14.z.object({
+  streamId: import_zod14.z.string(),
+  page: import_zod14.z.number().optional(),
+  limit: import_zod14.z.number().optional()
 });
-var streamWalletDetailsSchema = import_zod10.z.object({
-  streamId: import_zod10.z.string(),
-  userAddress: import_zod10.z.string(),
-  snapshots: import_zod10.z.array(streamWalletSnapshotSchema),
+var streamWalletDetailsSchema = import_zod14.z.object({
+  streamId: import_zod14.z.string(),
+  userAddress: import_zod14.z.string(),
+  snapshots: import_zod14.z.array(streamWalletSnapshotSchema),
   stream: streamSchema
 });
-var getStreamWalletDetailsResponseSchema = import_zod10.z.object({
+var getStreamWalletDetailsResponseSchema = import_zod14.z.object({
   wallet: streamWalletDetailsSchema
 });
 
@@ -1619,7 +1963,7 @@ async function requestStreamSignature(organizationId, input) {
 }
 
 // src/v2/streams/queries.ts
-var streamsQueries = (0, import_query_key_factory10.createQueryKeys)("streams", {
+var streamsQueries = (0, import_query_key_factory12.createQueryKeys)("streams", {
   list: (query) => ({
     queryKey: [query ?? "all"],
     queryFn: () => getStreams(query)
@@ -1642,180 +1986,73 @@ var streamsQueries = (0, import_query_key_factory10.createQueryKeys)("streams",
   }
 });
 
-// src/v2/supported-chains/queries.ts
-var import_query_key_factory11 = require("@lukemorales/query-key-factory");
-
-// src/v2/supported-chains/schema.ts
-var import_zod11 = require("zod");
-var getSupportedChainsInputSchema = import_zod11.z.object({
-  page: import_zod11.z.number().min(1).default(1).optional(),
-  limit: import_zod11.z.number().min(1).max(100).default(50).optional(),
-  // Sorting
-  sortBy: import_zod11.z.enum(["name", "chainId", "ecosystem", "slug"]).optional(),
-  sortOrder: import_zod11.z.enum(["asc", "desc"]).optional(),
-  // Filters
-  ecosystem: import_zod11.z.string().optional(),
-  // Filter by ecosystem
-  status: import_zod11.z.string().optional(),
-  // Filter by status
-  chainId: import_zod11.z.string().optional(),
-  // Filter by specific chainId
-  slug: import_zod11.z.string().optional(),
-  // Filter by slug
-  search: import_zod11.z.string().optional()
-  // Search by name or slug
-});
-var supportedChainsResponseSchema = import_zod11.z.object({
-  chains: import_zod11.z.array(chainSchema),
-  pagination: paginationMetadataSchema.optional()
-});
-
-// src/v2/supported-chains/api.ts
-async function getSupportedChains(params, options) {
-  const queryParams = new URLSearchParams();
-  if (params) {
-    if (params.page !== void 0) queryParams.append("page", params.page.toString());
-    if (params.limit !== void 0) queryParams.append("limit", params.limit.toString());
-    if (params.sortBy) queryParams.append("sortBy", params.sortBy);
-    if (params.sortOrder) queryParams.append("sortOrder", params.sortOrder);
-    if (params.ecosystem) queryParams.append("ecosystem", params.ecosystem);
-    if (params.status) queryParams.append("status", params.status);
-    if (params.chainId) queryParams.append("chainId", params.chainId);
-    if (params.slug) queryParams.append("slug", params.slug);
-    if (params.search) queryParams.append("search", params.search);
-  }
-  const queryString = queryParams.toString();
-  const endpoint = `/turtle/chains${queryString ? `?${queryString}` : ""}`;
-  const data = await apiClient.fetch(endpoint, {
-    method: "GET",
-    debug: options?.debug
-  });
-  const result = supportedChainsResponseSchema.safeParse(data);
-  if (result.success === false) {
-    console.log("[ZOD ERROR]", result.error);
-    throw new Error(`Failed to parse supported chains: ${result.error.message}`);
-  }
-  return result.data;
-}
-
-// src/v2/supported-chains/queries.ts
-var supportedChainsQueries = (0, import_query_key_factory11.createQueryKeys)("supportedChains", {
-  all: (params, options) => ({
-    queryKey: [params],
-    queryFn: () => getSupportedChains(params, options)
-  })
-});
-
-// src/v2/supported-tokens/queries.ts
-var import_query_key_factory12 = require("@lukemorales/query-key-factory");
-
-// src/v2/supported-tokens/schema.ts
-var import_zod12 = require("zod");
-var supportedTokenSchema = tokenSchema.extend({
-  active: import_zod12.z.boolean()
-});
-var supportedTokensResponseSchema = import_zod12.z.object({
-  tokens: import_zod12.z.array(supportedTokenSchema),
-  total: import_zod12.z.number().optional(),
-  limit: import_zod12.z.number().optional(),
-  page: import_zod12.z.number().optional()
-});
-
-// src/v2/supported-tokens/api.ts
-async function getSupportedTokens(filters, options) {
-  const params = new URLSearchParams();
-  if (filters?.page !== void 0) params.append("page", filters.page.toString());
-  if (filters?.limit !== void 0) params.append("limit", filters.limit.toString());
-  if (filters?.search) params.append("search", filters.search);
-  const queryString = params.toString();
-  const endpoint = `/turtle/tokens${queryString ? `?${queryString}` : ""}`;
-  const data = await apiClient.fetch(endpoint, {
-    method: "GET",
-    debug: options?.debug
-  });
-  const result = supportedTokensResponseSchema.safeParse(data);
-  if (result.success === false) {
-    console.log("[ZOD ERROR]", result.error);
-    throw new Error(`Failed to parse supported tokens: ${result.error.message}`);
-  }
-  return result.data;
-}
-
-// src/v2/supported-tokens/queries.ts
-var supportedTokensQueries = (0, import_query_key_factory12.createQueryKeys)("supportedTokens", {
-  list: (filters) => ({
-    queryKey: [filters],
-    queryFn: () => getSupportedTokens(filters)
-  })
-});
-
 // src/v2/users/queries.ts
 var import_query_key_factory13 = require("@lukemorales/query-key-factory");
 
 // src/v2/users/schemas.ts
-var import_zod13 = require("zod");
-var walletDataSchema = import_zod13.z.object({
-  address: import_zod13.z.string(),
-  totalAmountInUSD: import_zod13.z.string(),
-  tokens: import_zod13.z.array(tokenSchema)
-});
-var holdingsDataSchema = import_zod13.z.object({
-  totalAmountInUSD: import_zod13.z.string(),
-  chains: import_zod13.z.array(chainSchema).nullish(),
-  wallets: import_zod13.z.array(walletDataSchema).nullish()
-});
-var userEarningsSchema = import_zod13.z.object({
-  productId: import_zod13.z.string().uuid(),
-  value: import_zod13.z.number(),
-  referralsEarnings: import_zod13.z.number().nullish(),
-  rewardName: import_zod13.z.string().nullish(),
-  rewardType: import_zod13.z.string().nullish()
-});
-var portfolioSchema = import_zod13.z.object({
-  productsEarnings: import_zod13.z.array(userEarningsSchema),
+var import_zod15 = require("zod");
+var walletDataSchema = import_zod15.z.object({
+  address: import_zod15.z.string(),
+  totalAmountInUSD: import_zod15.z.string(),
+  tokens: import_zod15.z.array(tokenSchema)
+});
+var holdingsDataSchema = import_zod15.z.object({
+  totalAmountInUSD: import_zod15.z.string(),
+  chains: import_zod15.z.array(chainSchema).nullish(),
+  wallets: import_zod15.z.array(walletDataSchema).nullish()
+});
+var userEarningsSchema = import_zod15.z.object({
+  productId: import_zod15.z.string().uuid(),
+  value: import_zod15.z.number(),
+  referralsEarnings: import_zod15.z.number().nullish(),
+  rewardName: import_zod15.z.string().nullish(),
+  rewardType: import_zod15.z.string().nullish()
+});
+var portfolioSchema = import_zod15.z.object({
+  productsEarnings: import_zod15.z.array(userEarningsSchema),
   holdings: holdingsDataSchema.nullish()
 });
-var holdingInfoSchema = import_zod13.z.object({
-  amount: import_zod13.z.number(),
-  usdValue: import_zod13.z.number(),
+var holdingInfoSchema = import_zod15.z.object({
+  amount: import_zod15.z.number(),
+  usdValue: import_zod15.z.number(),
   token: tokenSchema.nullish()
 });
-var walletInfoSchema = import_zod13.z.object({
-  address: import_zod13.z.string().nullish(),
-  ecosystem: import_zod13.z.string().nullish(),
-  isMain: import_zod13.z.boolean().nullish(),
-  holdings: import_zod13.z.array(holdingInfoSchema).nullish()
-});
-var userWithDetailsSchema = import_zod13.z.object({
-  id: import_zod13.z.string(),
-  email: import_zod13.z.string().nullable(),
-  username: import_zod13.z.string().nullish(),
-  firstName: import_zod13.z.string().nullish(),
-  lastName: import_zod13.z.string().nullish(),
-  avatarUrl: import_zod13.z.string().nullish(),
-  telegramHandle: import_zod13.z.string().nullish(),
-  xUsername: import_zod13.z.string().nullish(),
-  role: import_zod13.z.string(),
-  createdAt: import_zod13.z.string(),
-  updatedAt: import_zod13.z.string(),
-  tags: import_zod13.z.array(import_zod13.z.string()).nullish(),
-  wallets: import_zod13.z.array(walletInfoSchema).nullish()
-});
-var getUserTurtlePortfolioInputSchema = import_zod13.z.object({
-  userId: import_zod13.z.string().uuid()
-});
-var getUserTurtlePortfolioOutputSchema = import_zod13.z.object({
+var walletInfoSchema = import_zod15.z.object({
+  address: import_zod15.z.string().nullish(),
+  ecosystem: import_zod15.z.string().nullish(),
+  isMain: import_zod15.z.boolean().nullish(),
+  holdings: import_zod15.z.array(holdingInfoSchema).nullish()
+});
+var userWithDetailsSchema = import_zod15.z.object({
+  id: import_zod15.z.string(),
+  email: import_zod15.z.string().nullable(),
+  username: import_zod15.z.string().nullish(),
+  firstName: import_zod15.z.string().nullish(),
+  lastName: import_zod15.z.string().nullish(),
+  avatarUrl: import_zod15.z.string().nullish(),
+  telegramHandle: import_zod15.z.string().nullish(),
+  xUsername: import_zod15.z.string().nullish(),
+  role: import_zod15.z.string(),
+  createdAt: import_zod15.z.string(),
+  updatedAt: import_zod15.z.string(),
+  tags: import_zod15.z.array(import_zod15.z.string()).nullish(),
+  wallets: import_zod15.z.array(walletInfoSchema).nullish()
+});
+var getUserTurtlePortfolioInputSchema = import_zod15.z.object({
+  userId: import_zod15.z.string().uuid()
+});
+var getUserTurtlePortfolioOutputSchema = import_zod15.z.object({
   portfolio: portfolioSchema
 });
-var getUserTurtlePortfolioPathSchema = import_zod13.z.object({
-  userId: import_zod13.z.string().uuid()
+var getUserTurtlePortfolioPathSchema = import_zod15.z.object({
+  userId: import_zod15.z.string().uuid()
 });
-var getUserByIdInputSchema = import_zod13.z.object({
-  userId: import_zod13.z.string().uuid()
+var getUserByIdInputSchema = import_zod15.z.object({
+  userId: import_zod15.z.string().uuid()
 });
-var getUserByIdOutputSchema = import_zod13.z.object({
+var getUserByIdOutputSchema = import_zod15.z.object({
   user: userWithDetailsSchema.nullable(),
-  error: import_zod13.z.string().optional()
+  error: import_zod15.z.string().optional()
 });
 
 // src/v2/users/api.ts
@@ -1888,40 +2125,358 @@ var nftsQueries = (0, import_query_key_factory14.createQueryKeys)("nfts", {
   })
 });
 
-// src/v2/earn-opportunities/hooks.ts
-var import_react_query = require("@tanstack/react-query");
+// src/v2/balance/queries.ts
+var import_query_key_factory15 = require("@lukemorales/query-key-factory");
 
-// src/v2/lib/query-config.ts
-var queryDefaults = {
-  staleTime: 5 * 60 * 1e3,
-  // 5 minutes - data is fresh
-  gcTime: 10 * 60 * 1e3,
-  // 10 minutes - cache garbage collection (formerly cacheTime)
-  retry: 1,
-  // Retry failed requests once
-  refetchOnWindowFocus: false
-  // Don't refetch on tab focus
-};
-function createQueryOptions(queryConfig, options) {
-  return {
-    ...queryDefaults,
-    ...queryConfig,
-    ...options
-  };
+// src/v2/balance/schema.ts
+var import_zod16 = require("zod");
+var portfolioTokenSchema = import_zod16.z.object({
+  id: import_zod16.z.string(),
+  address: import_zod16.z.string(),
+  name: import_zod16.z.string(),
+  symbol: import_zod16.z.string(),
+  decimals: import_zod16.z.number(),
+  isNative: import_zod16.z.boolean(),
+  logoUrl: import_zod16.z.string().nullable(),
+  amount: import_zod16.z.string(),
+  // Portfolio-specific field (decimal format)
+  price: import_zod16.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_zod16.z.object({
+  id: import_zod16.z.string().optional(),
+  address: import_zod16.z.string(),
+  blockchain: import_zod16.z.string().optional(),
+  tokens: import_zod16.z.array(portfolioTokenSchema)
+});
+var portfolioHoldingsSchema = import_zod16.z.object({
+  wallets: import_zod16.z.array(portfolioWalletSchema)
+});
+var portfolioBalanceResponseSchema = import_zod16.z.object({
+  portfolio: import_zod16.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/deposits/queries.ts
+var import_query_key_factory16 = require("@lukemorales/query-key-factory");
+
+// src/v2/deposits/schemas.ts
+var import_zod17 = require("zod");
+var uuidSchema = import_zod17.z.string().uuid();
+var sortBySchema = import_zod17.z.enum(["date", "usd_value"]).optional();
+var sortOrderSchema = import_zod17.z.enum(["asc", "desc"]).optional();
+var getDepositsRequestSchema = import_zod17.z.object({
+  // Filter by product or opportunity (optional, not mutually exclusive)
+  product_id: import_zod17.z.string().uuid().optional(),
+  opportunity_id: import_zod17.z.string().uuid().optional(),
+  // Search query
+  search: import_zod17.z.string().optional(),
+  // Sorting options
+  sort_by: sortBySchema,
+  sort_order: sortOrderSchema,
+  // Additional filters
+  distributor_id: import_zod17.z.string().optional(),
+  depositor_address: import_zod17.z.string().optional(),
+  referral: import_zod17.z.string().optional(),
+  // Pagination
+  page: import_zod17.z.number().int().min(1).optional().default(1),
+  page_limit: import_zod17.z.number().int().min(1).max(100).optional().default(20)
+}).refine(
+  (data) => {
+    const hasProductId = !!data.product_id;
+    const hasOpportunityId = !!data.opportunity_id;
+    return hasProductId !== hasOpportunityId;
+  },
+  {
+    message: "Either product_id or opportunity_id must be provided (but not both)",
+    path: ["product_id", "opportunity_id"]
+  }
+);
+var depositResponseSchema = import_zod17.z.object({
+  id: uuidSchema,
+  opportunityId: uuidSchema,
+  walletId: uuidSchema.nullable().optional(),
+  crmWalletId: uuidSchema.nullable().optional(),
+  depositorAddress: import_zod17.z.string(),
+  amount: import_zod17.z.number(),
+  usdValue: import_zod17.z.number(),
+  depositTimestamp: import_zod17.z.string().datetime(),
+  // ISO 8601 format
+  txHash: import_zod17.z.string(),
+  verified: import_zod17.z.boolean().nullable().optional(),
+  distributorId: import_zod17.z.string().nullable().optional(),
+  referral: import_zod17.z.string().nullable().optional(),
+  explorerUrl: import_zod17.z.string().url().nullable().optional(),
+  createdAt: import_zod17.z.string().datetime(),
+  // ISO 8601 format
+  updatedAt: import_zod17.z.string().datetime()
+  // ISO 8601 format
+});
+var depositsMetadataSchema = import_zod17.z.object({
+  totalUsdValue: import_zod17.z.number().int().min(0)
+});
+var getDepositsResponseSchema = import_zod17.z.object({
+  deposits: import_zod17.z.array(depositResponseSchema),
+  pagination: paginationMetadataSchema.partial(),
+  metadata: depositsMetadataSchema
+});
+
+// src/v2/deposits/api.ts
+async function getDeposits2(filters) {
+  const params = new URLSearchParams();
+  if (filters.product_id) params.append("product_id", filters.product_id);
+  if (filters.opportunity_id) params.append("opportunity_id", filters.opportunity_id);
+  if (filters.search) params.append("search", filters.search);
+  if (filters.sort_by) params.append("sort_by", filters.sort_by);
+  if (filters.sort_order) params.append("sort_order", filters.sort_order);
+  if (filters.distributor_id) params.append("distributor_id", filters.distributor_id);
+  if (filters.depositor_address) params.append("depositor_address", filters.depositor_address);
+  if (filters.referral) params.append("referral", filters.referral);
+  if (filters.page) params.append("page", filters.page.toString());
+  if (filters.page_limit) params.append("page_limit", filters.page_limit.toString());
+  const queryString = params.toString();
+  const endpoint = `/turtle/deposits${queryString ? `?${queryString}` : ""}`;
+  const data = await apiClient.fetch(endpoint, {
+    method: "GET"
+  });
+  const result = getDepositsResponseSchema.safeParse(data);
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to parse deposits: ${result.error.message}`);
+  }
+  return result.data;
+}
+
+// src/v2/deposits/queries.ts
+var depositsQueries = (0, import_query_key_factory16.createQueryKeys)("deposits", {
+  list: (filters) => ({
+    queryKey: [{ filters }],
+    queryFn: () => getDeposits2(filters)
+  })
+});
+
+// src/v2/incentives/queries.ts
+var import_query_key_factory17 = require("@lukemorales/query-key-factory");
+
+// src/v2/incentives/api.ts
+async function getIncentives() {
+  const params = new URLSearchParams();
+  const queryString = params.toString();
+  const endpoint = `/turtle/incentives${queryString ? `?${queryString}` : ""}`;
+  const data = await apiClient.fetch(endpoint, {
+    method: "GET"
+  });
+  const result = incentivesResponseSchema.safeParse(data);
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to parse incentives: ${result.error.message}`);
+  }
+  return result.data;
+}
+async function getIncentive(id) {
+  const endpoint = `/admin/incentives/${id}`;
+  const data = await apiClient.fetch(endpoint, {
+    method: "GET"
+  });
+  const result = incentiveSchema.safeParse(data);
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to parse incentive: ${result.error.message}`);
+  }
+  return result.data;
+}
+async function createIncentive(input) {
+  const endpoint = `/admin/incentives`;
+  const data = await apiClient.fetch(endpoint, {
+    method: "POST",
+    body: JSON.stringify(input),
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  const result = incentiveSchema.safeParse(data);
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to create incentive: ${result.error.message}`);
+  }
+  return result.data;
+}
+async function updateIncentive(input) {
+  const endpoint = `/admin/incentives/${input.id}`;
+  const data = await apiClient.fetch(endpoint, {
+    method: "PUT",
+    body: JSON.stringify({ incentive: input }),
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  const result = incentiveSchema.safeParse(data);
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to update incentive: ${result.error.message}`);
+  }
+  return result.data;
+}
+async function deleteIncentive(id) {
+  const endpoint = `/admin/incentives/${id}`;
+  const data = await apiClient.fetch(endpoint, {
+    method: "DELETE",
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+  const result = incentiveSchema.safeParse(data);
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to delete incentive: ${result.error.message}`);
+  }
+}
+async function uploadIncentiveIcon({
+  file,
+  filename,
+  overwrite
+}) {
+  const endpoint = `/admin/products/upload-logo`;
+  const formData = new FormData();
+  formData.append("file", file, filename || file.name);
+  if (overwrite) {
+    formData.append("overwrite", "true");
+  }
+  if (filename) {
+    formData.append("filename", filename);
+  }
+  const data = await apiClient.fetch(endpoint, {
+    method: "POST",
+    body: formData
+    // Don't set Content-Type header - let the browser set it with boundary for multipart/form-data
+  });
+  const result = uploadIncentiveIconResponseSchema.safeParse(data);
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to upload incentive icon: ${result.error.message}`);
+  }
+  return result.data;
+}
+
+// src/v2/incentives/queries.ts
+var incentivesQueries = (0, import_query_key_factory17.createQueryKeys)("incentives", {
+  // Get all incentives (no filters)
+  all: {
+    queryKey: null,
+    queryFn: () => getIncentives()
+  },
+  byId: (id) => ({
+    queryKey: [id],
+    queryFn: () => getIncentive(id)
+  })
+});
+
+// src/v2/liquidity-providers/queries.ts
+var import_query_key_factory18 = require("@lukemorales/query-key-factory");
+
+// src/v2/liquidity-providers/schema.ts
+var import_zod18 = require("zod");
+var sortBySchema2 = import_zod18.z.enum(["username", "telegram", "total_tvl", "active_tvl", "first_deposit", "wallet_count"]).optional();
+var sortOrderSchema2 = import_zod18.z.enum(["asc", "desc"]).optional();
+var getLiquidityProvidersInputSchema = import_zod18.z.object({
+  organizationId: import_zod18.z.string().uuid().optional(),
+  productId: import_zod18.z.string().uuid().optional(),
+  opportunityId: import_zod18.z.string().uuid().optional(),
+  sortBy: sortBySchema2,
+  sortOrder: sortOrderSchema2,
+  limit: import_zod18.z.number().int().min(1).max(100).optional().default(20),
+  offset: import_zod18.z.number().int().min(0).optional().default(0)
+});
+var liquidityProviderSchema = import_zod18.z.object({
+  username: import_zod18.z.string(),
+  totalTvl: import_zod18.z.number(),
+  activeTvl: import_zod18.z.number(),
+  opportunities: import_zod18.z.array(import_zod18.z.string().uuid()),
+  telegram: import_zod18.z.string(),
+  firstDeposit: import_zod18.z.string().datetime(),
+  // ISO 8601 format (time.Time in Go)
+  walletCount: import_zod18.z.number().int()
+});
+var GetLiquidityProvidersResponseSchema = import_zod18.z.object({
+  liquidityProviders: import_zod18.z.array(liquidityProviderSchema),
+  pagination: paginationMetadataSchema
+});
+
+// src/v2/liquidity-providers/api.ts
+async function getLiquidityProviders(input) {
+  const params = new URLSearchParams();
+  if (input.organizationId) params.append("organization_id", input.organizationId);
+  if (input.productId) params.append("product_id", input.productId);
+  if (input.opportunityId) params.append("opportunity_id", input.opportunityId);
+  if (input.sortBy) params.append("sort_by", input.sortBy);
+  if (input.sortOrder) params.append("sort_order", input.sortOrder);
+  if (input.limit !== void 0) params.append("limit", input.limit.toString());
+  if (input.offset !== void 0) params.append("offset", input.offset.toString());
+  const queryString = params.toString();
+  const endpoint = `/admin/deposits/liquidity-providers${queryString ? `?${queryString}` : ""}`;
+  const data = await apiClient.fetch(endpoint, {
+    method: "GET"
+  });
+  const result = GetLiquidityProvidersResponseSchema.safeParse(data);
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to parse liquidity providers: ${result.error.message}`);
+  }
+  return result.data;
 }
 
+// src/v2/liquidity-providers/queries.ts
+var liquidityProvidersQueries = (0, import_query_key_factory18.createQueryKeys)(
+  "liquidityProviders",
+  {
+    // Get liquidity providers with filters
+    list: (input) => ({
+      queryKey: [{ input }],
+      queryFn: () => getLiquidityProviders(input)
+    })
+  }
+);
+
 // src/v2/earn-opportunities/hooks.ts
+var import_react_query5 = require("@tanstack/react-query");
 function useEarnOpportunities() {
-  return (0, import_react_query.useQuery)({
+  return (0, import_react_query5.useQuery)({
     ...earnOpportunitiesQueries.all,
     ...queryDefaults
   });
 }
 
 // src/v2/earn-route/hooks.ts
-var import_react_query2 = require("@tanstack/react-query");
+var import_react_query6 = require("@tanstack/react-query");
 function useEarnRoute({ params, enabled = true }) {
-  return (0, import_react_query2.useQuery)({
+  return (0, import_react_query6.useQuery)({
     // Null assertion is safe because the query is enable only if params is provided
     ...earnRouteQueries.byParams(params),
     ...queryDefaults,
@@ -1930,25 +2485,25 @@ function useEarnRoute({ params, enabled = true }) {
 }
 
 // src/v2/earn-membership/hooks.ts
-var import_react_query3 = require("@tanstack/react-query");
+var import_react_query7 = require("@tanstack/react-query");
 function useCheckMembership({
   params,
   enabled = true
 }) {
-  return (0, import_react_query3.useQuery)({
+  return (0, import_react_query7.useQuery)({
     ...earnMembershipQueries.check(params),
     ...queryDefaults,
     enabled
   });
 }
 function useCreateMembershipAgreement() {
-  return (0, import_react_query3.useMutation)({
+  return (0, import_react_query7.useMutation)({
     mutationFn: (request) => createMembershipAgreement(request)
   });
 }
 function useCreateMembership() {
-  const queryClient = (0, import_react_query3.useQueryClient)();
-  return (0, import_react_query3.useMutation)({
+  const queryClient = (0, import_react_query7.useQueryClient)();
+  return (0, import_react_query7.useMutation)({
     mutationFn: (request) => createMembership(request),
     onSuccess: (data, variables) => {
       queryClient.invalidateQueries({
@@ -1962,10 +2517,10 @@ function useCreateMembership() {
 }
 
 // src/v2/earn-deposits/hooks.ts
-var import_react_query9 = require("@tanstack/react-query");
+var import_react_query11 = require("@tanstack/react-query");
 
 // src/v2/earn-deposits/hooks/useDepositValidation.ts
-var import_react = require("react");
+var import_react2 = require("react");
 var import_viem = require("viem");
 function calculateUsdValue(amount, token) {
   if (!token.priceUsd) return null;
@@ -1980,7 +2535,7 @@ function useDepositValidation({
   isConfirming = false,
   walletChainId
 }) {
-  return (0, import_react.useMemo)(() => {
+  return (0, import_react2.useMemo)(() => {
     if (!opportunity) {
       return {
         canDeposit: false,
@@ -2126,10 +2681,10 @@ function useDepositValidation({
 }
 
 // src/v2/earn-deposits/hooks/useDepositSelection.ts
-var import_react3 = require("react");
+var import_react4 = require("react");
 
 // src/v2/balance/hooks/useTokenBalance.ts
-var import_react2 = require("react");
+var import_react3 = require("react");
 var import_viem2 = require("viem");
 var import_utils2 = require("@turtleclub/utils");
 function checkInsufficientBalance(tokenBalance, amount) {
@@ -2145,20 +2700,20 @@ function checkInsufficientBalance(tokenBalance, amount) {
 }
 function useTokenBalance({ tokenBalance, amount, setAmount }) {
   const token = tokenBalance?.token;
-  const usdValue = (0, import_react2.useMemo)(
+  const usdValue = (0, import_react3.useMemo)(
     () => (0, import_utils2.calculateUsdValue)(amount, token?.priceUsd),
     [amount, token?.priceUsd]
   );
-  const hasInsufficientBalance = (0, import_react2.useMemo)(
+  const hasInsufficientBalance = (0, import_react3.useMemo)(
     () => checkInsufficientBalance(tokenBalance, amount),
     [tokenBalance, amount]
   );
-  const handleMaxClick = (0, import_react2.useCallback)(() => {
+  const handleMaxClick = (0, import_react3.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)(() => {
+  const amountBigInt = (0, import_react3.useMemo)(() => {
     if (!token || !amount) return void 0;
     try {
       return (0, import_viem2.parseUnits)(amount, token.decimals);
@@ -2179,13 +2734,13 @@ function useDepositSelection({
   balances,
   opportunityId
 }) {
-  const [selectedTokenAddress, setSelectedTokenAddress] = (0, import_react3.useState)();
-  const [amount, setAmount] = (0, import_react3.useState)();
-  (0, import_react3.useEffect)(() => {
+  const [selectedTokenAddress, setSelectedTokenAddress] = (0, import_react4.useState)();
+  const [amount, setAmount] = (0, import_react4.useState)();
+  (0, import_react4.useEffect)(() => {
     setSelectedTokenAddress(void 0);
     setAmount(void 0);
   }, [opportunityId]);
-  (0, import_react3.useEffect)(() => {
+  (0, import_react4.useEffect)(() => {
     if (balances.length === 0) return;
     const tokenExistsInBalances = balances.some(
       (b) => b.token.address === selectedTokenAddress
@@ -2194,7 +2749,7 @@ function useDepositSelection({
       setSelectedTokenAddress(balances[0].token.address);
     }
   }, [selectedTokenAddress, balances]);
-  const selectedTokenBalance = (0, import_react3.useMemo)(
+  const selectedTokenBalance = (0, import_react4.useMemo)(
     () => balances.find((b) => b.token.address === selectedTokenAddress) ?? null,
     [balances, selectedTokenAddress]
   );
@@ -2203,7 +2758,7 @@ function useDepositSelection({
     amount,
     setAmount
   });
-  const reset = (0, import_react3.useCallback)(() => {
+  const reset = (0, import_react4.useCallback)(() => {
     setSelectedTokenAddress(void 0);
     setAmount(void 0);
   }, []);
@@ -2222,55 +2777,55 @@ function useDepositSelection({
 }
 
 // src/v2/earn-deposits/hooks/useDepositFlow.ts
-var import_react5 = require("react");
+var import_react6 = require("react");
 
 // src/v2/earn-actions/useEarnDeposit.ts
-var import_react4 = require("react");
-var import_react_query5 = require("@tanstack/react-query");
+var import_react5 = require("react");
+var import_react_query9 = require("@tanstack/react-query");
 
 // src/v2/earn-actions/hooks.ts
-var import_react_query4 = require("@tanstack/react-query");
+var import_react_query8 = require("@tanstack/react-query");
 
 // src/v2/earn-actions/schema.ts
-var import_zod14 = require("zod");
-var transactionSchema = import_zod14.z.object({
-  chainId: import_zod14.z.number().int(),
-  data: import_zod14.z.string(),
-  to: import_zod14.z.string(),
-  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(),
+var import_zod19 = require("zod");
+var transactionSchema = import_zod19.z.object({
+  chainId: import_zod19.z.number().int(),
+  data: import_zod19.z.string(),
+  to: import_zod19.z.string(),
+  value: import_zod19.z.string(),
+  gasLimit: import_zod19.z.string().optional()
+});
+var routeTokenSchema = import_zod19.z.object({
+  address: import_zod19.z.string(),
+  symbol: import_zod19.z.string(),
+  decimals: import_zod19.z.number().int(),
+  logoUrl: import_zod19.z.string()
+});
+var routeStepSchema = import_zod19.z.object({
+  action: import_zod19.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 routeMetadataSchema = import_zod19.z.object({
+  provider: import_zod19.z.string(),
+  providerImg: import_zod19.z.string(),
+  amountOut: import_zod19.z.string(),
+  gas: import_zod19.z.string(),
+  route: import_zod19.z.array(routeStepSchema)
 });
-var txResponseItemSchema = import_zod14.z.object({
-  type: import_zod14.z.string().optional(),
-  description: import_zod14.z.string().optional(),
+var txResponseItemSchema = import_zod19.z.object({
+  type: import_zod19.z.string().optional(),
+  description: import_zod19.z.string().optional(),
   transaction: transactionSchema,
   metadata: routeMetadataSchema.optional()
 });
-var actionResponseSchema = import_zod14.z.object({
-  actionId: import_zod14.z.string().uuid().optional(),
-  transactions: import_zod14.z.array(txResponseItemSchema).nullable()
+var actionResponseSchema = import_zod19.z.object({
+  actionId: import_zod19.z.string().uuid().optional(),
+  transactions: import_zod19.z.array(txResponseItemSchema).nullable()
 });
-var attributeActionResponseSchema = import_zod14.z.object({
-  success: import_zod14.z.boolean(),
-  message: import_zod14.z.string().optional()
+var attributeActionResponseSchema = import_zod19.z.object({
+  success: import_zod19.z.boolean(),
+  message: import_zod19.z.string().optional()
 });
 
 // src/v2/earn-actions/api.ts
@@ -2339,7 +2894,7 @@ var createClaimWithdrawInteraction = createClaimWithdrawAction;
 // src/v2/earn-actions/hooks.ts
 function createActionHook(mutationFn) {
   return function useAction(options) {
-    return (0, import_react_query4.useMutation)({
+    return (0, import_react_query8.useMutation)({
       mutationFn,
       ...options
     });
@@ -2352,7 +2907,7 @@ var useClaimDepositAction = createActionHook(createClaimDepositAction);
 var useCancelDepositAction = createActionHook(createCancelDepositAction);
 var useCancelWithdrawAction = createActionHook(createCancelWithdrawAction);
 function useAttributeAction(options) {
-  return (0, import_react_query4.useMutation)({
+  return (0, import_react_query8.useMutation)({
     mutationFn: attributeAction,
     ...options
   });
@@ -2361,65 +2916,6 @@ 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) {
@@ -2432,14 +2928,14 @@ function useEarnDeposit(options) {
     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 queryClient = (0, import_react_query9.useQueryClient)();
+  const [isConfirming, setIsConfirming] = (0, import_react5.useState)(false);
+  const [error, setError] = (0, import_react5.useState)(null);
+  const [metadata, setMetadata] = (0, import_react5.useState)(null);
+  const [hasApprove, setHasApprove] = (0, import_react5.useState)(false);
   const depositAction = useDepositAction();
   const attributeAction2 = useAttributeAction();
-  const toTransactionRequest = (0, import_react4.useCallback)((txItem) => {
+  const toTransactionRequest = (0, import_react5.useCallback)((txItem) => {
     return {
       to: txItem.transaction.to,
       data: txItem.transaction.data,
@@ -2448,7 +2944,7 @@ function useEarnDeposit(options) {
       type: txItem.type
     };
   }, []);
-  const executeTransactionsSequentially = (0, import_react4.useCallback)(
+  const executeTransactionsSequentially = (0, import_react5.useCallback)(
     async (transactions) => {
       let lastTxHash;
       for (const txItem of transactions) {
@@ -2463,7 +2959,7 @@ function useEarnDeposit(options) {
     },
     [executeTransactionAndWait, toTransactionRequest]
   );
-  const attributeTransactionSafely = (0, import_react4.useCallback)(
+  const attributeTransactionSafely = (0, import_react5.useCallback)(
     async (actionId, txHash) => {
       try {
         await attributeAction2.mutateAsync({ actionId, txHash });
@@ -2473,7 +2969,7 @@ function useEarnDeposit(options) {
     },
     [attributeAction2]
   );
-  const deposit = (0, import_react4.useCallback)(
+  const deposit = (0, import_react5.useCallback)(
     async (amount, tokenAddress, slippage = DEFAULT_SLIPPAGE_BPS) => {
       setError(null);
       if (!opportunity?.id) {
@@ -2544,7 +3040,7 @@ function useEarnDeposit(options) {
       onSuccess
     ]
   );
-  const resetMetadata = (0, import_react4.useCallback)(() => {
+  const resetMetadata = (0, import_react5.useCallback)(() => {
     setMetadata(null);
     setHasApprove(false);
   }, []);
@@ -2606,7 +3102,7 @@ function useDepositFlow({
     isConfirming,
     walletChainId
   });
-  const execute = (0, import_react5.useCallback)(async () => {
+  const execute = (0, import_react6.useCallback)(async () => {
     if (!selection.amountBigInt || !selection.selectedTokenAddress) {
       return void 0;
     }
@@ -2634,7 +3130,7 @@ var import_react10 = require("react");
 // src/v2/balance/hooks/useGetOnChainBalance.ts
 var import_wagmi = require("wagmi");
 var import_viem3 = require("viem");
-var import_react6 = require("react");
+var import_react7 = require("react");
 var NATIVE_TOKEN_ADDRESSES = [
   "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
   "0x0000000000000000000000000000000000000000"
@@ -2649,7 +3145,7 @@ function useGetOnChainBalance({
   address,
   enabled = true
 }) {
-  const { nativeTokens, erc20Tokens } = (0, import_react6.useMemo)(() => {
+  const { nativeTokens, erc20Tokens } = (0, import_react7.useMemo)(() => {
     const native = [];
     const erc20 = [];
     for (const token of tokens) {
@@ -2677,7 +3173,7 @@ function useGetOnChainBalance({
       refetchOnWindowFocus: true
     }
   });
-  const contracts = (0, import_react6.useMemo)(() => {
+  const contracts = (0, import_react7.useMemo)(() => {
     if (!address || !enabled) return [];
     return erc20Tokens.map(
       (token) => ({
@@ -2703,7 +3199,7 @@ function useGetOnChainBalance({
       refetchOnWindowFocus: true
     }
   });
-  const balances = (0, import_react6.useMemo)(() => {
+  const balances = (0, import_react7.useMemo)(() => {
     const result = [];
     if (nativeToken && nativeBalanceData) {
       result.push({
@@ -2730,7 +3226,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_react6.useCallback)(() => {
+  const refetch = (0, import_react7.useCallback)(() => {
     if (nativeTokens.length > 0) {
       refetchNative();
     }
@@ -2750,73 +3246,8 @@ function useGetOnChainBalance({
 var import_react9 = require("react");
 
 // src/v2/balance/hooks/usePortfolioBalance.ts
-var import_react_query8 = require("@tanstack/react-query");
+var import_react_query10 = require("@tanstack/react-query");
 var import_react8 = require("react");
-
-// src/v2/supported-chains/hooks.ts
-var import_react_query6 = require("@tanstack/react-query");
-function useSupportedChains(options) {
-  const { debug, enabled = true, ...params } = options || {};
-  const { data, isLoading, error, refetch, isFetching } = (0, import_react_query6.useQuery)({
-    ...supportedChainsQueries.all(params, { debug }),
-    ...queryDefaults,
-    enabled
-  });
-  const chains = data?.chains ?? [];
-  const pagination = data?.pagination;
-  return {
-    chains,
-    pagination,
-    getChainByChainId: (chainId) => chains.find((chain) => chain.chainId === chainId),
-    getChainBySlug: (slug) => chains.find((chain) => chain.slug === slug),
-    getChainsByEcosystem: (ecosystem) => chains.filter((chain) => chain.ecosystem === ecosystem),
-    isLoading,
-    error: error ? error : null,
-    refetch,
-    isFetching
-  };
-}
-
-// src/v2/supported-tokens/hooks.ts
-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_query7.useQuery)({
-    ...supportedTokensQueries.list({ page, limit, search }),
-    ...queryDefaults,
-    staleTime: 5 * 60 * 1e3,
-    // 1 minutes
-    gcTime: 10 * 60 * 1e3,
-    // 10 minutes
-    refetchOnWindowFocus: false,
-    // Don't refetch on tab focus
-    enabled
-  });
-  const tokens = (0, import_react7.useMemo)(() => {
-    if (!data?.tokens) return [];
-    return data.tokens.map(({ active, ...token }) => token);
-  }, [data?.tokens]);
-  return {
-    tokens,
-    total: data?.total ?? 0,
-    limit: data?.limit ?? limit,
-    page: data?.page ?? page,
-    isLoading,
-    error: error ? error : null,
-    refetch,
-    getTokenById: (id) => tokens.find((token) => token.id === id),
-    getToken: (address, chainId) => tokens.find(
-      (token) => token.address.toLowerCase() === address.toLowerCase() && token.chain.chainId === chainId
-    )
-  };
-}
-
-// src/v2/balance/hooks/usePortfolioBalance.ts
 var import_viem4 = require("viem");
 function usePortfolioBalance({
   address
@@ -2828,7 +3259,7 @@ function usePortfolioBalance({
     isLoading,
     error,
     refetch
-  } = (0, import_react_query8.useQuery)({
+  } = (0, import_react_query10.useQuery)({
     ...balanceQueries.portfolio(address || ""),
     ...queryDefaults,
     enabled: !!address,
@@ -3108,7 +3539,7 @@ function useActionsDefaultParams({
 
 // src/v2/earn-deposits/hooks.ts
 function useDeposits({ params, enabled = true }) {
-  return (0, import_react_query9.useQuery)({
+  return (0, import_react_query11.useQuery)({
     ...earnDepositsQueries.byParams(params),
     ...queryDefaults,
     enabled
@@ -3117,12 +3548,12 @@ function useDeposits({ params, enabled = true }) {
 
 // src/v2/enso-balances/hooks.ts
 var import_react11 = require("react");
-var import_react_query10 = require("@tanstack/react-query");
+var import_react_query12 = require("@tanstack/react-query");
 function useMultiChainBalances({
   chainIds,
   address
 }) {
-  const queries2 = (0, import_react_query10.useQueries)({
+  const queries2 = (0, import_react_query12.useQueries)({
     queries: chainIds.map((chainId) => ({
       ...ensoBalancesQueries.byParams({ user: address || "", chain: chainId }),
       enabled: !!address,
@@ -3157,92 +3588,42 @@ function useMultiChainBalances({
   };
 }
 
-// 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");
+var import_react_query13 = require("@tanstack/react-query");
 function useProducts({ filters, enabled = true }) {
-  return (0, import_react_query12.useQuery)({
+  return (0, import_react_query13.useQuery)({
     ...productsQueries.list(filters),
     ...queryDefaults,
     enabled
   });
 }
 function useProduct({ id, enabled = true }) {
-  return (0, import_react_query12.useQuery)({
+  return (0, import_react_query13.useQuery)({
     ...productsQueries.byId(id),
     ...queryDefaults,
     enabled
   });
 }
 function useCreateProduct(options) {
-  return (0, import_react_query12.useMutation)({
+  return (0, import_react_query13.useMutation)({
     mutationFn: (input) => createProduct(input),
     ...options
   });
 }
 function useUpdateProduct(options) {
-  return (0, import_react_query12.useMutation)({
+  return (0, import_react_query13.useMutation)({
     mutationFn: (input) => updateProduct(input),
     ...options
   });
 }
 function useDeleteProduct(options) {
-  return (0, import_react_query12.useMutation)({
+  return (0, import_react_query13.useMutation)({
     mutationFn: (id) => deleteProduct(id),
     ...options
   });
 }
 function useUploadProductLogo(options) {
-  return (0, import_react_query12.useMutation)({
+  return (0, import_react_query13.useMutation)({
     mutationFn: (request) => uploadProductLogo(request),
     ...options
   });
@@ -3290,9 +3671,9 @@ function useEnsoBalances({
 }
 
 // src/v2/widget/hooks.ts
-var import_react_query13 = require("@tanstack/react-query");
+var import_react_query14 = require("@tanstack/react-query");
 function useWidgetOpportunities(distributorId) {
-  return (0, import_react_query13.useQuery)({
+  return (0, import_react_query14.useQuery)({
     ...widgetQueries.opportunities(distributorId),
     ...queryDefaults,
     select: (data) => {
@@ -3316,7 +3697,7 @@ function useWidgetOpportunities(distributorId) {
 }
 
 // src/v2/geocheck/useGeocheck.ts
-var import_react_query14 = require("@tanstack/react-query");
+var import_react_query15 = require("@tanstack/react-query");
 var INDEXER_ENDPOINT = "https://api.turtle.xyz";
 async function fetchGeocheck() {
   const url = `${INDEXER_ENDPOINT}/turtle/geocheck`;
@@ -3332,13 +3713,13 @@ async function fetchGeocheck() {
   }
   return data;
 }
-var geocheckQueryOptions = () => (0, import_react_query14.queryOptions)({
+var geocheckQueryOptions = () => (0, import_react_query15.queryOptions)({
   queryKey: ["geocheck"],
   queryFn: fetchGeocheck
 });
 function useGeocheck(options = {}) {
   const { enabled = true, staleTime, gcTime } = options;
-  return (0, import_react_query14.useQuery)({
+  return (0, import_react_query15.useQuery)({
     ...geocheckQueryOptions(),
     enabled,
     staleTime: staleTime ?? 5 * 60 * 1e3,
@@ -3351,35 +3732,35 @@ function useGeocheck(options = {}) {
 }
 
 // src/v2/streams/hooks.ts
-var import_react_query15 = require("@tanstack/react-query");
+var import_react_query16 = require("@tanstack/react-query");
 function useStreams({
   query,
   options
 } = {}) {
-  return (0, import_react_query15.useQuery)(createQueryOptions(streamsQueries.list(query), options));
+  return (0, import_react_query16.useQuery)(createQueryOptions(streamsQueries.list(query), options));
 }
 function useStreamPoints({
   query,
   options
 } = {}) {
-  return (0, import_react_query15.useQuery)(createQueryOptions(streamsQueries.points(query), options));
+  return (0, import_react_query16.useQuery)(createQueryOptions(streamsQueries.points(query), options));
 }
 function useStreamWallets({
   query,
   options
 }) {
-  return (0, import_react_query15.useQuery)(createQueryOptions(streamsQueries.wallets(query), options));
+  return (0, import_react_query16.useQuery)(createQueryOptions(streamsQueries.wallets(query), options));
 }
 function useStreamWalletDetails({
   query,
   options
 }) {
-  return (0, import_react_query15.useQuery)(createQueryOptions(streamsQueries.walletDetails(query), options));
+  return (0, import_react_query16.useQuery)(createQueryOptions(streamsQueries.walletDetails(query), options));
 }
 function useStreamSupportedChains({
   options
 } = {}) {
-  return (0, import_react_query15.useQuery)(createQueryOptions(streamsQueries.supportedChains, options));
+  return (0, import_react_query16.useQuery)(createQueryOptions(streamsQueries.supportedChains, options));
 }
 
 // src/v2/swap/useSwapRoute.ts
@@ -3481,9 +3862,9 @@ function useSwapRoute(isEnabled, userAddress, distributorId, options, referralCo
 }
 
 // src/v2/users/hooks.ts
-var import_react_query16 = require("@tanstack/react-query");
+var import_react_query17 = require("@tanstack/react-query");
 function useUserById({ userId, enabled = true }) {
-  return (0, import_react_query16.useQuery)({
+  return (0, import_react_query17.useQuery)({
     ...usersQueries.byId({ userId }),
     ...queryDefaults,
     enabled
@@ -3491,7 +3872,7 @@ function useUserById({ userId, enabled = true }) {
 }
 function useUserPortfolio({ userId, enabled = true }) {
   const input = { userId };
-  return (0, import_react_query16.useQuery)({
+  return (0, import_react_query17.useQuery)({
     ...usersQueries.portfolio(input),
     ...queryDefaults,
     enabled
@@ -3499,30 +3880,30 @@ function useUserPortfolio({ userId, enabled = true }) {
 }
 
 // src/v2/nfts/hooks.ts
-var import_react_query17 = require("@tanstack/react-query");
+var import_react_query18 = require("@tanstack/react-query");
 function useUserNfts({ userAddress, chain, tokenAddress }) {
-  return (0, import_react_query17.useQuery)(
+  return (0, import_react_query18.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_query17.skipToken }
+    }) : { queryKey: ["nfts", "byUser", "skip"], queryFn: import_react_query18.skipToken }
   );
 }
 
 // src/v2/covers/hooks.ts
-var import_react_query18 = require("@tanstack/react-query");
+var import_react_query19 = require("@tanstack/react-query");
 
 // src/v2/covers/schema.ts
-var import_zod16 = require("zod");
-var coverRequestDataSchema = import_zod16.z.object({
-  protocolName: import_zod16.z.string(),
-  coverageAmount: import_zod16.z.string(),
-  periodDays: import_zod16.z.number(),
-  desiredApySacrifice: import_zod16.z.string(),
-  calculatedEstimatedPremium: import_zod16.z.string(),
-  tokenSymbol: import_zod16.z.string()
-});
-var submitCoverRequestResponseSchema = import_zod16.z.object({
-  success: import_zod16.z.boolean()
+var import_zod20 = require("zod");
+var coverRequestDataSchema = import_zod20.z.object({
+  protocolName: import_zod20.z.string(),
+  coverageAmount: import_zod20.z.string(),
+  periodDays: import_zod20.z.number(),
+  desiredApySacrifice: import_zod20.z.string(),
+  calculatedEstimatedPremium: import_zod20.z.string(),
+  tokenSymbol: import_zod20.z.string()
+});
+var submitCoverRequestResponseSchema = import_zod20.z.object({
+  success: import_zod20.z.boolean()
 });
 
 // src/v2/covers/api.ts
@@ -3541,7 +3922,7 @@ async function submitCoverRequest(data) {
 
 // src/v2/covers/hooks.ts
 function useSubmitCoverRequest(options) {
-  return (0, import_react_query18.useMutation)({
+  return (0, import_react_query19.useMutation)({
     mutationFn: submitCoverRequest,
     onSuccess: () => {
       options?.onSuccess?.("Cover request submitted successfully!");
@@ -3671,43 +4052,95 @@ var useTurtleMembershipFlow = ({
   };
 };
 
-// src/v2/organizations/schema.ts
-var import_zod17 = require("zod");
-var LeaveOrganizationInputSchema = import_zod17.z.object({
-  organizationId: import_zod17.z.string().uuid()
+// src/v2/incentives/hooks.ts
+var import_react_query20 = require("@tanstack/react-query");
+function useIncentives({ enabled = true }) {
+  return (0, import_react_query20.useQuery)({
+    ...incentivesQueries.all,
+    ...queryDefaults,
+    enabled
+  });
+}
+function useIncentive({ id, enabled = true }) {
+  return (0, import_react_query20.useQuery)({
+    ...incentivesQueries.byId(id),
+    ...queryDefaults,
+    enabled
+  });
+}
+function useCreateIncentive(options) {
+  return (0, import_react_query20.useMutation)({
+    mutationFn: createIncentive,
+    ...options
+  });
+}
+function useUpdateIncentive(options) {
+  return (0, import_react_query20.useMutation)({
+    mutationFn: updateIncentive,
+    ...options
+  });
+}
+function useDeleteIncentive(options) {
+  return (0, import_react_query20.useMutation)({
+    mutationFn: deleteIncentive,
+    ...options
+  });
+}
+function useUploadIncentiveIcon(options) {
+  return (0, import_react_query20.useMutation)({
+    mutationFn: uploadIncentiveIcon,
+    ...options
+  });
+}
+
+// src/v2/distributors/hooks.ts
+var import_react_query21 = require("@tanstack/react-query");
+
+// src/v2/distributors/schema.ts
+var import_zod21 = require("zod");
+var updateDistributorEarnDetailsInputSchema = import_zod21.z.object({
+  organizationId: import_zod21.z.string().uuid(),
+  distributorId: import_zod21.z.string().uuid(),
+  earnDetails: import_zod21.z.any()
+  // JSONB value - using any for now as requested
 });
-var LeaveOrganizationOutputSchema = import_zod17.z.object({
-  success: import_zod17.z.boolean(),
-  error: import_zod17.z.string().optional()
+var updateDistributorEarnDetailsResponseSchema = import_zod21.z.object({
+  success: import_zod21.z.boolean()
 });
 
-// src/v2/organizations/api.ts
-async function leaveOrganization(input) {
-  const endpoint = `/organization/${input.organizationId}/leave`;
+// src/v2/distributors/api.ts
+async function updateDistributorEarnDetails(input) {
+  const { organizationId, distributorId, earnDetails } = input;
+  const endpoint = `/organization/${organizationId}/distributors/${distributorId}/earn-details`;
   const data = await apiClient.fetch(endpoint, {
-    method: "POST"
+    method: "PUT",
+    body: JSON.stringify({ earnDetails })
   });
-  const result = LeaveOrganizationOutputSchema.safeParse(data);
+  const result = updateDistributorEarnDetailsResponseSchema.safeParse(data);
   if (result.success === false) {
     console.log("[ZOD ERROR]", result.error);
-    throw new Error(`Failed to parse leave organization response: ${result.error.message}`);
+    throw new Error(`Failed to update distributor earn details: ${result.error.message}`);
   }
   return result.data;
 }
 
-// src/v2/organizations/hooks.ts
-var import_react_query19 = require("@tanstack/react-query");
-function useLeaveOrganization(options) {
-  return (0, import_react_query19.useMutation)({
-    mutationFn: leaveOrganization,
+// src/v2/distributors/hooks.ts
+function useUpdateDistributorEarnDetails(options) {
+  return (0, import_react_query21.useMutation)({
+    mutationFn: updateDistributorEarnDetails,
     ...options
   });
 }
 
-// src/v2/organizations/queries.ts
-var organizationsMutations = {
-  leave: (input) => leaveOrganization(input)
-};
+// src/v2/liquidity-providers/hooks.ts
+var import_react_query22 = require("@tanstack/react-query");
+function useLiquidityProviders({ input, enabled = true }) {
+  return (0, import_react_query22.useQuery)({
+    ...liquidityProvidersQueries.list(input),
+    ...queryDefaults,
+    enabled
+  });
+}
 
 // src/v2/lib/turtle-provider.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
@@ -3723,7 +4156,7 @@ function TurtleHooksProvider({
 }
 
 // src/v2/index.ts
-var queries = (0, import_query_key_factory16.mergeQueryKeys)(
+var queries = (0, import_query_key_factory19.mergeQueryKeys)(
   opportunitiesQueries,
   earnOpportunitiesQueries,
   earnRouteQueries,
@@ -3737,12 +4170,17 @@ var queries = (0, import_query_key_factory16.mergeQueryKeys)(
   supportedChainsQueries,
   supportedTokensQueries,
   usersQueries,
-  nftsQueries
+  nftsQueries,
+  balanceQueries,
+  depositsQueries,
+  incentivesQueries,
+  liquidityProvidersQueries
 );
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ApiError,
   BalanceSourcePriority,
+  GetLiquidityProvidersResponseSchema,
   LeaveOrganizationInputSchema,
   LeaveOrganizationOutputSchema,
   TurtleHooksProvider,
@@ -3770,15 +4208,22 @@ var queries = (0, import_query_key_factory16.mergeQueryKeys)(
   createClaimWithdrawInteraction,
   createDepositAction,
   createDepositInteraction,
+  createIncentive,
+  createIncentiveInputSchema,
   createMembership,
   createMembershipAgreement,
   createMembershipRequestSchema,
   createMembershipResponseSchema,
+  createProduct,
+  createProductInputSchema,
+  createProductResponseSchema,
   createStreamPoint,
   createStreamPointBodySchema,
   createStreamPointOutputSchema,
   createWithdrawAction,
   createWithdrawInteraction,
+  deleteIncentive,
+  deleteProduct,
   depositSchema,
   depositSubstep,
   depositsResponseSchema,
@@ -3803,6 +4248,10 @@ var queries = (0, import_query_key_factory16.mergeQueryKeys)(
   getDeposits,
   getEarnOpportunities,
   getEarnRoute,
+  getIncentive,
+  getIncentives,
+  getLiquidityProviders,
+  getLiquidityProvidersInputSchema,
   getOpportunities,
   getOpportunitiesFilterOptions,
   getOpportunitiesFilterOptionsSchema,
@@ -3811,6 +4260,7 @@ var queries = (0, import_query_key_factory16.mergeQueryKeys)(
   getOpportunitiesPaginatedSchema,
   getOpportunityById,
   getPortfolioBalance,
+  getProduct,
   getProducts,
   getSourcePriority,
   getStreamPoints,
@@ -3840,8 +4290,12 @@ var queries = (0, import_query_key_factory16.mergeQueryKeys)(
   getWidgetOpportunities,
   holdingsDataSchema,
   incentiveSchema,
+  incentivesQueries,
+  incentivesResponseSchema,
   leaveOrganization,
   lendingConfigSchema,
+  liquidityProviderSchema,
+  liquidityProvidersQueries,
   mergeBalancesByPriority,
   nftsQueries,
   opportunitiesQueries,
@@ -3858,8 +4312,11 @@ var queries = (0, import_query_key_factory16.mergeQueryKeys)(
   portfolioTokenSchema,
   portfolioWalletSchema,
   processRouteDetails,
+  productFiltersSchema,
+  productResponseSchema,
   productSchema,
   productsQueries,
+  productsResponseSchema,
   queries,
   requestStreamSignature,
   routeMetadataSchema,
@@ -3889,6 +4346,18 @@ var queries = (0, import_query_key_factory16.mergeQueryKeys)(
   tokenSchema,
   transactionSchema,
   txResponseItemSchema,
+  updateDistributorEarnDetails,
+  updateIncentive,
+  updateIncentiveInputSchema,
+  updateProduct,
+  updateProductInputSchema,
+  updateProductResponseSchema,
+  uploadIncentiveIcon,
+  uploadIncentiveIconRequestSchema,
+  uploadIncentiveIconResponseSchema,
+  uploadProductLogo,
+  uploadProductLogoRequestSchema,
+  uploadProductLogoResponseSchema,
   useActionsDefaultParams,
   useAttributeAction,
   useBalance,
@@ -3899,10 +4368,12 @@ var queries = (0, import_query_key_factory16.mergeQueryKeys)(
   useClaimWithdrawAction,
   useCreateClaimWithdrawInteraction,
   useCreateDepositInteraction,
+  useCreateIncentive,
   useCreateMembership,
   useCreateMembershipAgreement,
   useCreateProduct,
   useCreateWithdrawInteraction,
+  useDeleteIncentive,
   useDeleteProduct,
   useDepositAction,
   useDepositFlow,
@@ -3915,7 +4386,10 @@ var queries = (0, import_query_key_factory16.mergeQueryKeys)(
   useEnsoBalances,
   useGeocheck,
   useGetOnChainBalance,
+  useIncentive,
+  useIncentives,
   useLeaveOrganization,
+  useLiquidityProviders,
   useMultiChainBalances,
   useOpportunities,
   useOpportunitiesFilterOptions,
@@ -3935,7 +4409,10 @@ var queries = (0, import_query_key_factory16.mergeQueryKeys)(
   useSwapRoute,
   useTokenBalance,
   useTurtleMembershipFlow,
+  useUpdateDistributorEarnDetails,
+  useUpdateIncentive,
   useUpdateProduct,
+  useUploadIncentiveIcon,
   useUploadProductLogo,
   useUserById,
   useUserNfts,