@turtleclub/hooks 0.5.0-beta.53 → 0.5.0-beta.55

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,6 +50,8 @@ __export(index_exports, {
   createClaimWithdrawInteraction: () => createClaimWithdrawInteraction,
   createDepositAction: () => createDepositAction,
   createDepositInteraction: () => createDepositInteraction,
+  createIncentive: () => createIncentive,
+  createIncentiveInputSchema: () => createIncentiveInputSchema,
   createMembership: () => createMembership,
   createMembershipAgreement: () => createMembershipAgreement,
   createMembershipRequestSchema: () => createMembershipRequestSchema,
@@ -61,6 +64,7 @@ __export(index_exports, {
   createStreamPointOutputSchema: () => createStreamPointOutputSchema,
   createWithdrawAction: () => createWithdrawAction,
   createWithdrawInteraction: () => createWithdrawInteraction,
+  deleteIncentive: () => deleteIncentive,
   deleteProduct: () => deleteProduct,
   depositSchema: () => depositSchema,
   depositSubstep: () => depositSubstep,
@@ -86,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,
@@ -123,8 +131,13 @@ __export(index_exports, {
   getWalletBalances: () => getWalletBalances,
   getWidgetOpportunities: () => getWidgetOpportunities,
   holdingsDataSchema: () => holdingsDataSchema,
+  incentiveSchema: () => incentiveSchema,
+  incentivesQueries: () => incentivesQueries,
+  incentivesResponseSchema: () => incentivesResponseSchema,
   leaveOrganization: () => leaveOrganization,
   lendingConfigSchema: () => lendingConfigSchema,
+  liquidityProviderSchema: () => liquidityProviderSchema,
+  liquidityProvidersQueries: () => liquidityProvidersQueries,
   mergeBalancesByPriority: () => mergeBalancesByPriority,
   nftsQueries: () => nftsQueries,
   opportunitiesQueries: () => opportunitiesQueries,
@@ -175,9 +188,15 @@ __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,
@@ -191,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,
@@ -207,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,
@@ -227,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,
@@ -248,7 +275,7 @@ __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_factory3 = require("@lukemorales/query-key-factory");
@@ -479,7 +506,7 @@ var getSupportedChainsInputSchema = import_zod3.z.object({
 });
 var supportedChainsResponseSchema = import_zod3.z.object({
   chains: import_zod3.z.array(chainSchema),
-  pagination: paginationMetadataSchema.optional()
+  pagination: paginationMetadataSchema.partial().optional()
 });
 
 // src/v2/supported-chains/api.ts
@@ -580,7 +607,7 @@ var tokenSchema = import_zod4.z.object({
   rawAmount: import_zod4.z.string().optional()
 });
 var supportedTokenSchema = tokenSchema.extend({
-  active: import_zod4.z.boolean()
+  active: import_zod4.z.boolean().optional()
 });
 var supportedTokensResponseSchema = import_zod4.z.object({
   tokens: import_zod4.z.array(supportedTokenSchema),
@@ -2098,6 +2125,345 @@ var nftsQueries = (0, import_query_key_factory14.createQueryKeys)("nfts", {
   })
 });
 
+// src/v2/balance/queries.ts
+var import_query_key_factory15 = require("@lukemorales/query-key-factory");
+
+// 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() {
@@ -2421,45 +2787,45 @@ var import_react_query9 = require("@tanstack/react-query");
 var import_react_query8 = require("@tanstack/react-query");
 
 // src/v2/earn-actions/schema.ts
-var import_zod16 = require("zod");
-var transactionSchema = import_zod16.z.object({
-  chainId: import_zod16.z.number().int(),
-  data: import_zod16.z.string(),
-  to: import_zod16.z.string(),
-  value: import_zod16.z.string(),
-  gasLimit: import_zod16.z.string().optional()
-});
-var routeTokenSchema = import_zod16.z.object({
-  address: import_zod16.z.string(),
-  symbol: import_zod16.z.string(),
-  decimals: import_zod16.z.number().int(),
-  logoUrl: import_zod16.z.string()
-});
-var routeStepSchema = import_zod16.z.object({
-  action: import_zod16.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_zod16.z.object({
-  provider: import_zod16.z.string(),
-  providerImg: import_zod16.z.string(),
-  amountOut: import_zod16.z.string(),
-  gas: import_zod16.z.string(),
-  route: import_zod16.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_zod16.z.object({
-  type: import_zod16.z.string().optional(),
-  description: import_zod16.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_zod16.z.object({
-  actionId: import_zod16.z.string().uuid().optional(),
-  transactions: import_zod16.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_zod16.z.object({
-  success: import_zod16.z.boolean(),
-  message: import_zod16.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
@@ -2550,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_zod17 = require("zod");
-var portfolioTokenSchema = import_zod17.z.object({
-  id: import_zod17.z.string(),
-  address: import_zod17.z.string(),
-  name: import_zod17.z.string(),
-  symbol: import_zod17.z.string(),
-  decimals: import_zod17.z.number(),
-  isNative: import_zod17.z.boolean(),
-  logoUrl: import_zod17.z.string().nullable(),
-  amount: import_zod17.z.string(),
-  // Portfolio-specific field (decimal format)
-  price: import_zod17.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_zod17.z.object({
-  id: import_zod17.z.string().optional(),
-  address: import_zod17.z.string(),
-  blockchain: import_zod17.z.string().optional(),
-  tokens: import_zod17.z.array(portfolioTokenSchema)
-});
-var portfolioHoldingsSchema = import_zod17.z.object({
-  wallets: import_zod17.z.array(portfolioWalletSchema)
-});
-var portfolioBalanceResponseSchema = import_zod17.z.object({
-  portfolio: import_zod17.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) {
@@ -3586,17 +3893,17 @@ function useUserNfts({ userAddress, chain, tokenAddress }) {
 var import_react_query19 = require("@tanstack/react-query");
 
 // src/v2/covers/schema.ts
-var import_zod18 = require("zod");
-var coverRequestDataSchema = import_zod18.z.object({
-  protocolName: import_zod18.z.string(),
-  coverageAmount: import_zod18.z.string(),
-  periodDays: import_zod18.z.number(),
-  desiredApySacrifice: import_zod18.z.string(),
-  calculatedEstimatedPremium: import_zod18.z.string(),
-  tokenSymbol: import_zod18.z.string()
-});
-var submitCoverRequestResponseSchema = import_zod18.z.object({
-  success: import_zod18.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
@@ -3745,6 +4052,96 @@ var useTurtleMembershipFlow = ({
   };
 };
 
+// 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 updateDistributorEarnDetailsResponseSchema = import_zod21.z.object({
+  success: import_zod21.z.boolean()
+});
+
+// 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: "PUT",
+    body: JSON.stringify({ earnDetails })
+  });
+  const result = updateDistributorEarnDetailsResponseSchema.safeParse(data);
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to update distributor earn details: ${result.error.message}`);
+  }
+  return result.data;
+}
+
+// src/v2/distributors/hooks.ts
+function useUpdateDistributorEarnDetails(options) {
+  return (0, import_react_query21.useMutation)({
+    mutationFn: updateDistributorEarnDetails,
+    ...options
+  });
+}
+
+// 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");
 function TurtleHooksProvider({
@@ -3759,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,
@@ -3773,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,
@@ -3806,6 +4208,8 @@ var queries = (0, import_query_key_factory16.mergeQueryKeys)(
   createClaimWithdrawInteraction,
   createDepositAction,
   createDepositInteraction,
+  createIncentive,
+  createIncentiveInputSchema,
   createMembership,
   createMembershipAgreement,
   createMembershipRequestSchema,
@@ -3818,6 +4222,7 @@ var queries = (0, import_query_key_factory16.mergeQueryKeys)(
   createStreamPointOutputSchema,
   createWithdrawAction,
   createWithdrawInteraction,
+  deleteIncentive,
   deleteProduct,
   depositSchema,
   depositSubstep,
@@ -3843,6 +4248,10 @@ var queries = (0, import_query_key_factory16.mergeQueryKeys)(
   getDeposits,
   getEarnOpportunities,
   getEarnRoute,
+  getIncentive,
+  getIncentives,
+  getLiquidityProviders,
+  getLiquidityProvidersInputSchema,
   getOpportunities,
   getOpportunitiesFilterOptions,
   getOpportunitiesFilterOptionsSchema,
@@ -3880,8 +4289,13 @@ var queries = (0, import_query_key_factory16.mergeQueryKeys)(
   getWalletBalances,
   getWidgetOpportunities,
   holdingsDataSchema,
+  incentiveSchema,
+  incentivesQueries,
+  incentivesResponseSchema,
   leaveOrganization,
   lendingConfigSchema,
+  liquidityProviderSchema,
+  liquidityProvidersQueries,
   mergeBalancesByPriority,
   nftsQueries,
   opportunitiesQueries,
@@ -3932,9 +4346,15 @@ var queries = (0, import_query_key_factory16.mergeQueryKeys)(
   tokenSchema,
   transactionSchema,
   txResponseItemSchema,
+  updateDistributorEarnDetails,
+  updateIncentive,
+  updateIncentiveInputSchema,
   updateProduct,
   updateProductInputSchema,
   updateProductResponseSchema,
+  uploadIncentiveIcon,
+  uploadIncentiveIconRequestSchema,
+  uploadIncentiveIconResponseSchema,
   uploadProductLogo,
   uploadProductLogoRequestSchema,
   uploadProductLogoResponseSchema,
@@ -3948,10 +4368,12 @@ var queries = (0, import_query_key_factory16.mergeQueryKeys)(
   useClaimWithdrawAction,
   useCreateClaimWithdrawInteraction,
   useCreateDepositInteraction,
+  useCreateIncentive,
   useCreateMembership,
   useCreateMembershipAgreement,
   useCreateProduct,
   useCreateWithdrawInteraction,
+  useDeleteIncentive,
   useDeleteProduct,
   useDepositAction,
   useDepositFlow,
@@ -3964,7 +4386,10 @@ var queries = (0, import_query_key_factory16.mergeQueryKeys)(
   useEnsoBalances,
   useGeocheck,
   useGetOnChainBalance,
+  useIncentive,
+  useIncentives,
   useLeaveOrganization,
+  useLiquidityProviders,
   useMultiChainBalances,
   useOpportunities,
   useOpportunitiesFilterOptions,
@@ -3984,7 +4409,10 @@ var queries = (0, import_query_key_factory16.mergeQueryKeys)(
   useSwapRoute,
   useTokenBalance,
   useTurtleMembershipFlow,
+  useUpdateDistributorEarnDetails,
+  useUpdateIncentive,
   useUpdateProduct,
+  useUploadIncentiveIcon,
   useUploadProductLogo,
   useUserById,
   useUserNfts,