@turtleclub/hooks 0.5.0-beta.87 → 0.5.0-beta.89

package/dist/index.cjs

@@ -108,6 +108,9 @@ __export(index_exports, {
   getOpportunitiesPaginatedSchema: () => getOpportunitiesPaginatedSchema,
   getOpportunityById: () => getOpportunityById,
   getOpportunityByIdInputSchema: () => getOpportunityByIdInputSchema,
+  getOrgLeaderboard: () => getOrgLeaderboard,
+  getOrgLeaderboardParamsSchema: () => getOrgLeaderboardParamsSchema,
+  getOrgUserLeaderboard: () => getOrgUserLeaderboard,
   getPortfolioBalance: () => getPortfolioBalance,
   getProduct: () => getProduct,
   getProducts: () => getProducts,
@@ -151,9 +154,15 @@ __export(index_exports, {
   opportunitiesResponseSchema: () => opportunitiesResponseSchema,
   opportunityFiltersSchema: () => opportunityFiltersSchema,
   opportunitySchema: () => opportunitySchema,
+  orgLeaderboardQueries: () => orgLeaderboardQueries,
+  orgLeaderboardResponseSchema: () => orgLeaderboardResponseSchema,
+  orgLeaderboardRowSchema: () => orgLeaderboardRowSchema,
+  orgLeaderboardSortBySchema: () => orgLeaderboardSortBySchema,
+  orgLeaderboardSortOrderSchema: () => orgLeaderboardSortOrderSchema,
+  orgUserLeaderboardInfoSchema: () => orgUserLeaderboardInfoSchema,
+  orgUserLeaderboardResponseSchema: () => orgUserLeaderboardResponseSchema,
   organizationSchema: () => organizationSchema,
   organizationsMutations: () => organizationsMutations,
-  paginationMetadataSchema: () => paginationMetadataSchema,
   paginationSchema: () => paginationSchema,
   portfolioBalanceResponseSchema: () => portfolioBalanceResponseSchema,
   portfolioHoldingsSchema: () => portfolioHoldingsSchema,
@@ -253,6 +262,8 @@ __export(index_exports, {
   useOpportunitiesFilterOptions: () => useOpportunitiesFilterOptions,
   useOpportunitiesPaginated: () => useOpportunitiesPaginated,
   useOpportunity: () => useOpportunity,
+  useOrgLeaderboard: () => useOrgLeaderboard,
+  useOrgUserLeaderboard: () => useOrgUserLeaderboard,
   usePortfolioBalance: () => usePortfolioBalance,
   useProduct: () => useProduct,
   useProducts: () => useProducts,
@@ -294,7 +305,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/v2/index.ts
-var import_query_key_factory21 = require("@lukemorales/query-key-factory");
+var import_query_key_factory22 = require("@lukemorales/query-key-factory");
 
 // src/v2/opportunities/queries.ts
 var import_query_key_factory4 = require("@lukemorales/query-key-factory");
@@ -392,155 +403,59 @@ var ApiClient = class _ApiClient {
 var apiClient = ApiClient.getInstance();
 
 // src/v2/opportunities/schema.ts
-var import_zod8 = require("zod");
+var import_zod9 = 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
+// src/v2/supported-chains/schema.ts
 var import_zod2 = require("zod");
 
-// src/v2/organizations/schema.ts
+// src/v2/schemas/pagination.ts
 var import_zod = require("zod");
-var organizationSchema = import_zod.z.object({
-  id: import_zod.z.string(),
-  name: import_zod.z.string(),
-  description: import_zod.z.string().optional().nullable(),
-  landingUrl: import_zod.z.string().optional().nullable(),
-  iconUrl: import_zod.z.string().optional().nullable(),
-  organizationType: import_zod.z.string().optional().nullable(),
-  turtleRefCode: import_zod.z.string().optional().nullable(),
-  twitterHandle: import_zod.z.string().optional().nullable(),
-  status: import_zod.z.string().optional().nullable(),
-  featured: import_zod.z.boolean().optional().nullable()
-});
-var LeaveOrganizationInputSchema = import_zod.z.object({
-  organizationId: import_zod.z.string().uuid()
-});
-var LeaveOrganizationOutputSchema = import_zod.z.object({
-  success: import_zod.z.boolean(),
-  error: import_zod.z.string().optional()
-});
-
-// src/v2/organizations/api.ts
-async function leaveOrganization(input) {
-  const endpoint = `/organization/${input.organizationId}/leave`;
-  const data = await apiClient.fetch(endpoint, {
-    method: "POST"
-  });
-  const result = LeaveOrganizationOutputSchema.safeParse(data);
-  if (result.success === false) {
-    console.log("[ZOD ERROR]", result.error);
-    throw new Error(`Failed to parse leave organization response: ${result.error.message}`);
-  }
-  return result.data;
-}
-
-// 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
-  });
-}
-
-// 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(),
-  protocol: organizationSchema.optional(),
-  curator: organizationSchema.optional(),
-  marketAddress: import_zod2.z.string().optional(),
-  depositUrl: import_zod2.z.string().optional().nullable(),
-  providerMetadata: import_zod2.z.any().optional(),
-  createdAt: import_zod2.z.string().datetime(),
-  updatedAt: import_zod2.z.string().datetime()
-});
-var stakingConfigSchema = import_zod2.z.object({
-  id: import_zod2.z.string().uuid(),
-  protocol: organizationSchema.optional(),
-  chainId: import_zod2.z.string().uuid().optional(),
-  chain: chainSchema.optional(),
-  stakingContractAddress: import_zod2.z.string().optional(),
-  createdAt: import_zod2.z.string().datetime(),
-  updatedAt: import_zod2.z.string().datetime()
-});
-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).optional(),
-  has_next: import_zod2.z.boolean().optional(),
-  has_previous: import_zod2.z.boolean().optional()
+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).optional(),
+  has_next: import_zod.z.boolean().optional(),
+  has_previous: import_zod.z.boolean().optional()
 });
 
 // src/v2/supported-chains/schema.ts
-var supportedChainEcosystemSchema = import_zod3.z.enum(["evm", "solana"]);
-var supportedChainStatusSchema = import_zod3.z.enum(["active", "inactive"]);
-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(),
-  isTestnet: import_zod3.z.boolean().optional(),
-  logoUrl: import_zod3.z.string().optional(),
+var supportedChainEcosystemSchema = import_zod2.z.enum(["evm", "solana"]);
+var supportedChainStatusSchema = import_zod2.z.enum(["active", "inactive"]);
+var chainSchema = import_zod2.z.object({
+  id: import_zod2.z.string().optional(),
+  name: import_zod2.z.string(),
+  slug: import_zod2.z.string().optional(),
+  chainId: import_zod2.z.string(),
+  isTestnet: import_zod2.z.boolean().optional(),
+  logoUrl: import_zod2.z.string().optional(),
   ecosystem: supportedChainEcosystemSchema.optional(),
   status: supportedChainStatusSchema.optional(),
-  explorerUrl: import_zod3.z.string().optional()
+  explorerUrl: import_zod2.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(),
+var getSupportedChainsInputSchema = import_zod2.z.object({
+  page: import_zod2.z.number().min(1).default(1).optional(),
+  limit: import_zod2.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(),
+  sortBy: import_zod2.z.enum(["name", "chainId", "ecosystem", "slug"]).optional(),
+  sortOrder: import_zod2.z.enum(["asc", "desc"]).optional(),
   // Filters
-  ecosystem: import_zod3.z.string().optional(),
+  ecosystem: import_zod2.z.string().optional(),
   // Filter by ecosystem
-  status: import_zod3.z.string().optional(),
+  status: import_zod2.z.string().optional(),
   // Filter by status
-  chainId: import_zod3.z.string().optional(),
+  chainId: import_zod2.z.string().optional(),
   // Filter by specific chainId
-  slug: import_zod3.z.string().optional(),
+  slug: import_zod2.z.string().optional(),
   // Filter by slug
-  search: import_zod3.z.string().optional()
+  search: import_zod2.z.string().optional()
   // Search by name or slug
 });
-var supportedChainsResponseSchema = import_zod3.z.object({
-  chains: import_zod3.z.array(chainSchema),
+var supportedChainsResponseSchema = import_zod2.z.object({
+  chains: import_zod2.z.array(chainSchema),
   pagination: paginationMetadataSchema.optional()
 });
 
@@ -582,7 +497,7 @@ var supportedChainsQueries = (0, import_query_key_factory.createQueryKeys)("supp
 });
 
 // src/v2/supported-chains/hooks.ts
-var import_react_query2 = require("@tanstack/react-query");
+var import_react_query = require("@tanstack/react-query");
 
 // src/v2/lib/query-config.ts
 var queryDefaults = {
@@ -606,7 +521,7 @@ function createQueryOptions(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)({
+  const { data, isLoading, error, refetch, isFetching } = (0, import_react_query.useQuery)({
     ...supportedChainsQueries.all(params, { debug }),
     ...queryDefaults,
     enabled
@@ -627,32 +542,32 @@ function useSupportedChains(options) {
 }
 
 // src/v2/supported-tokens/schema.ts
-var uuidSchema = import_zod4.z.string().uuid();
-var tokenSchema = import_zod4.z.object({
+var uuidSchema = import_zod3.z.string().uuid();
+var tokenSchema = import_zod3.z.object({
   id: uuidSchema,
-  address: import_zod4.z.string(),
-  name: import_zod4.z.string(),
-  symbol: import_zod4.z.string(),
-  decimals: import_zod4.z.number().int().nonnegative(),
-  isNative: import_zod4.z.boolean(),
-  logoUrl: import_zod4.z.string().optional(),
+  address: import_zod3.z.string(),
+  name: import_zod3.z.string(),
+  symbol: import_zod3.z.string(),
+  decimals: import_zod3.z.number().int().nonnegative(),
+  isNative: import_zod3.z.boolean(),
+  logoUrl: import_zod3.z.string().optional(),
   chain: chainSchema,
-  priceUsd: import_zod4.z.number().optional(),
+  priceUsd: import_zod3.z.number().optional(),
   canonicalAssetId: uuidSchema.optional(),
-  streamsMinAmount: import_zod4.z.string().nullable().optional(),
-  totalTurtleTvl: import_zod4.z.number().optional(),
-  price: import_zod4.z.string().optional(),
-  amount: import_zod4.z.string().optional(),
-  rawAmount: import_zod4.z.string().optional()
+  streamsMinAmount: import_zod3.z.string().nullable().optional(),
+  totalTurtleTvl: import_zod3.z.number().optional(),
+  price: import_zod3.z.string().optional(),
+  amount: import_zod3.z.string().optional(),
+  rawAmount: import_zod3.z.string().optional()
 });
 var supportedTokenSchema = tokenSchema.extend({
-  active: import_zod4.z.boolean()
+  active: import_zod3.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(),
-  offset: import_zod4.z.number().optional()
+var supportedTokensResponseSchema = import_zod3.z.object({
+  tokens: import_zod3.z.array(supportedTokenSchema),
+  total: import_zod3.z.number().optional(),
+  limit: import_zod3.z.number().optional(),
+  offset: import_zod3.z.number().optional()
 });
 
 // src/v2/supported-tokens/api.ts
@@ -692,7 +607,7 @@ var supportedTokensQueries = (0, import_query_key_factory2.createQueryKeys)("sup
 });
 
 // src/v2/supported-tokens/hooks.ts
-var import_react_query3 = require("@tanstack/react-query");
+var import_react_query2 = require("@tanstack/react-query");
 var import_react = require("react");
 function useSupportedTokens({
   offset = 0,
@@ -703,7 +618,7 @@ function useSupportedTokens({
   enabled = true,
   ids = []
 } = {}) {
-  const { data, isLoading, error, refetch } = (0, import_react_query3.useQuery)({
+  const { data, isLoading, error, refetch } = (0, import_react_query2.useQuery)({
     ...supportedTokensQueries.list({ offset, limit, search, chainId, withStreamsMinAmount, ids }),
     ...queryDefaults,
     staleTime: 5 * 60 * 1e3,
@@ -734,131 +649,230 @@ function useSupportedTokens({
 }
 
 // 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 import_zod4 = require("zod");
+var incentiveSchema = import_zod4.z.object({
+  id: import_zod4.z.string().uuid(),
+  name: import_zod4.z.string(),
+  description: import_zod4.z.string(),
+  iconUrl: import_zod4.z.string(),
+  rewardType: import_zod4.z.string(),
+  rewardTypeName: import_zod4.z.string(),
+  boostPct: import_zod4.z.number().nullable(),
+  totalCapacity: import_zod4.z.number().nullable(),
+  maxCapacityPerLP: import_zod4.z.number().nullable(),
+  lockup: import_zod4.z.string().nullable(),
+  minCommitment: import_zod4.z.number().nullable(),
+  baseYieldTarget: import_zod4.z.number().nullable(),
+  baseYieldSource: import_zod4.z.string().nullable(),
+  incentiveYieldTarget: import_zod4.z.number().nullable(),
+  fdvEstimate: import_zod4.z.number().nullable(),
+  isIncentiveYieldGuaranteed: import_zod4.z.boolean().nullable(),
+  tokenSupplyAllocation: import_zod4.z.number().nullable(),
+  yield: import_zod4.z.number().nullable(),
+  indexed: import_zod4.z.boolean().nullable(),
+  minApr: import_zod4.z.number().nullable().optional(),
+  maxApr: import_zod4.z.number().nullable().optional()
 });
 var createIncentiveInputSchema = incentiveSchema.omit({
   id: true
 });
 var updateIncentiveInputSchema = incentiveSchema.partial().extend({
-  id: import_zod5.z.string().uuid()
+  id: import_zod4.z.string().uuid()
 });
-var incentivesResponseSchema = import_zod5.z.object({
-  incentives: import_zod5.z.array(incentiveSchema),
-  total: import_zod5.z.number().optional()
+var incentivesResponseSchema = import_zod4.z.object({
+  incentives: import_zod4.z.array(incentiveSchema),
+  total: import_zod4.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/"), {
+var uploadIncentiveIconRequestSchema = import_zod4.z.object({
+  file: import_zod4.z.object({
+    name: import_zod4.z.string(),
+    size: import_zod4.z.number().positive(),
+    type: import_zod4.z.string().refine((type) => type.startsWith("image/"), {
       message: "File must be an image type"
     }),
-    lastModified: import_zod5.z.number().optional()
+    lastModified: import_zod4.z.number().optional()
   }),
-  filename: import_zod5.z.string().optional(),
-  overwrite: import_zod5.z.boolean().optional()
+  filename: import_zod4.z.string().optional(),
+  overwrite: import_zod4.z.boolean().optional()
 });
-var uploadIncentiveIconResponseSchema = import_zod5.z.object({
-  publicUrl: import_zod5.z.string().url()
+var uploadIncentiveIconResponseSchema = import_zod4.z.object({
+  publicUrl: import_zod4.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 import_zod5 = require("zod");
+var productTypeSchema = import_zod5.z.enum(["deal", "campaign"]);
+var productStatusSchema = import_zod5.z.enum(["draft", "active", "paused", "ended"]);
+var turtleOrganizationSchema = import_zod5.z.object({
+  id: import_zod5.z.string().uuid(),
+  name: import_zod5.z.string(),
+  iconUrl: import_zod5.z.string(),
+  landingUrl: import_zod5.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(),
+var productSchema = import_zod5.z.object({
+  id: import_zod5.z.string().uuid(),
+  name: import_zod5.z.string(),
+  title: import_zod5.z.string(),
+  subtitle: import_zod5.z.string(),
+  description: import_zod5.z.string(),
+  logoUrl: import_zod5.z.string(),
+  productUrl: import_zod5.z.string(),
+  startedAt: import_zod5.z.string().optional().nullable(),
+  endedAt: import_zod5.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()
+  opportunities: import_zod5.z.lazy(() => import_zod5.z.array(import_zod5.z.any())).nullish(),
+  createdAt: import_zod5.z.string()
 });
-var createProductInputSchema = import_zod6.z.object({
+var createProductInputSchema = import_zod5.z.object({
   product: productSchema.omit({
     id: true,
     createdAt: true,
     organization: true
   }),
-  organizationId: import_zod6.z.string().uuid()
+  organizationId: import_zod5.z.string().uuid()
 });
-var updateProductInputSchema = import_zod6.z.object({
+var updateProductInputSchema = import_zod5.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 productsResponseSchema = import_zod5.z.object({
+  products: import_zod5.z.array(productSchema),
+  total: import_zod5.z.number().optional()
 });
-var productResponseSchema = import_zod6.z.object({
+var productResponseSchema = import_zod5.z.object({
   product: productSchema,
-  stats: import_zod6.z.object({
-    totalUsers: import_zod6.z.number(),
-    activeUsers: import_zod6.z.number()
+  stats: import_zod5.z.object({
+    totalUsers: import_zod5.z.number(),
+    activeUsers: import_zod5.z.number()
   }).optional()
 });
-var createProductResponseSchema = import_zod6.z.object({
-  id: import_zod6.z.string().uuid()
+var createProductResponseSchema = import_zod5.z.object({
+  id: import_zod5.z.string().uuid()
 });
-var updateProductResponseSchema = import_zod6.z.object({
-  success: import_zod6.z.boolean()
+var updateProductResponseSchema = import_zod5.z.object({
+  success: import_zod5.z.boolean()
 });
-var fileSchema = import_zod6.z.any().refine((value) => {
+var fileSchema = import_zod5.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({
+var uploadProductLogoRequestSchema = import_zod5.z.object({
   // Form data - file upload (required)
   file: fileSchema,
   // Form data - optional filename override
-  filename: import_zod6.z.string().optional()
+  filename: import_zod5.z.string().optional()
+});
+var uploadProductLogoResponseSchema = import_zod5.z.object({
+  url: import_zod5.z.string().url(),
+  error: import_zod5.z.string().optional()
+});
+var productFiltersSchema = import_zod5.z.object({
+  organizationId: import_zod5.z.string().uuid().optional()
+});
+
+// src/v2/schemas/shared.ts
+var import_zod7 = require("zod");
+
+// src/v2/organizations/schema.ts
+var import_zod6 = require("zod");
+var organizationSchema = import_zod6.z.object({
+  id: import_zod6.z.string(),
+  name: import_zod6.z.string(),
+  description: import_zod6.z.string().optional().nullable(),
+  landingUrl: import_zod6.z.string().optional().nullable(),
+  iconUrl: import_zod6.z.string().optional().nullable(),
+  organizationType: import_zod6.z.string().optional().nullable(),
+  turtleRefCode: import_zod6.z.string().optional().nullable(),
+  twitterHandle: import_zod6.z.string().optional().nullable(),
+  status: import_zod6.z.string().optional().nullable(),
+  featured: import_zod6.z.boolean().optional().nullable()
+});
+var LeaveOrganizationInputSchema = import_zod6.z.object({
+  organizationId: import_zod6.z.string().uuid()
 });
-var uploadProductLogoResponseSchema = import_zod6.z.object({
-  url: import_zod6.z.string().url(),
+var LeaveOrganizationOutputSchema = import_zod6.z.object({
+  success: import_zod6.z.boolean(),
   error: import_zod6.z.string().optional()
 });
-var productFiltersSchema = import_zod6.z.object({
-  organizationId: import_zod6.z.string().uuid().optional()
+
+// src/v2/organizations/api.ts
+async function leaveOrganization(input) {
+  const endpoint = `/organization/${input.organizationId}/leave`;
+  const data = await apiClient.fetch(endpoint, {
+    method: "POST"
+  });
+  const result = LeaveOrganizationOutputSchema.safeParse(data);
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to parse leave organization response: ${result.error.message}`);
+  }
+  return result.data;
+}
+
+// src/v2/organizations/hooks.ts
+var import_react_query3 = require("@tanstack/react-query");
+function useLeaveOrganization(options) {
+  return (0, import_react_query3.useMutation)({
+    mutationFn: leaveOrganization,
+    ...options
+  });
+}
+
+// src/v2/organizations/queries.ts
+var organizationsMutations = {
+  leave: (input) => leaveOrganization(input)
+};
+
+// src/v2/schemas/shared.ts
+var vaultConfigSchema = import_zod7.z.object({
+  id: import_zod7.z.string().uuid().optional(),
+  infraProvider: organizationSchema.optional().nullable(),
+  curator: organizationSchema.optional().nullable(),
+  withdrawalCooldownSecs: import_zod7.z.number().int().min(0).optional().nullable(),
+  withdrawalContractAddress: import_zod7.z.string().optional().nullable(),
+  withdrawalDetails: import_zod7.z.any().optional().nullable(),
+  depositUrl: import_zod7.z.string().optional().nullable(),
+  providerMetadata: import_zod7.z.any().optional().nullable(),
+  performanceFee: import_zod7.z.number().min(0).max(100).optional().nullable(),
+  managementFee: import_zod7.z.number().min(0).max(100).optional().nullable(),
+  depositFee: import_zod7.z.number().min(0).max(100).optional().nullable(),
+  withdrawalFee: import_zod7.z.number().min(0).max(100).optional().nullable(),
+  minDepositAmount: import_zod7.z.number().optional().nullable(),
+  minDepositValueUSD: import_zod7.z.number().optional().nullable(),
+  depositCapAmount: import_zod7.z.number().optional().nullable(),
+  depositCapValueUSD: import_zod7.z.number().optional().nullable(),
+  depositFillSecs: import_zod7.z.number().int().optional().nullable(),
+  lockupPeriodSecs: import_zod7.z.number().int().optional().nullable(),
+  asyncDeposit: import_zod7.z.boolean().optional().nullable(),
+  asyncWithdraw: import_zod7.z.boolean().optional().nullable(),
+  secondaryOnly: import_zod7.z.boolean().optional().nullable(),
+  createdAt: import_zod7.z.string().datetime().optional(),
+  updatedAt: import_zod7.z.string().datetime().optional()
+});
+var lendingConfigSchema = import_zod7.z.object({
+  id: import_zod7.z.string().uuid(),
+  protocol: organizationSchema.optional(),
+  curator: organizationSchema.optional(),
+  marketAddress: import_zod7.z.string().optional(),
+  depositUrl: import_zod7.z.string().optional().nullable(),
+  providerMetadata: import_zod7.z.any().optional(),
+  createdAt: import_zod7.z.string().datetime(),
+  updatedAt: import_zod7.z.string().datetime()
+});
+var stakingConfigSchema = import_zod7.z.object({
+  id: import_zod7.z.string().uuid(),
+  protocol: organizationSchema.optional(),
+  chainId: import_zod7.z.string().uuid().optional(),
+  chain: chainSchema.optional(),
+  stakingContractAddress: import_zod7.z.string().optional(),
+  createdAt: import_zod7.z.string().datetime(),
+  updatedAt: import_zod7.z.string().datetime()
 });
 
 // src/v2/streams/hooks.ts
@@ -868,264 +882,264 @@ var import_react_query4 = require("@tanstack/react-query");
 var import_query_key_factory3 = require("@lukemorales/query-key-factory");
 
 // src/v2/streams/schemas.ts
-var import_zod7 = require("zod");
-var customArgsTokensPerUsdSchema = import_zod7.z.object({
-  tokensPerUSD: import_zod7.z.string(),
-  targetChainId: import_zod7.z.number(),
-  targetTokenAddress: import_zod7.z.string()
-});
-var customArgsAprSchema = import_zod7.z.object({
-  apr: import_zod7.z.string(),
-  targetChainId: import_zod7.z.number(),
-  targetTokenAddress: import_zod7.z.string()
-});
-var customArgsTokensPerDaySchema = import_zod7.z.object({
-  tokensPerDay: import_zod7.z.string(),
-  targetChainId: import_zod7.z.number(),
-  targetTokenAddress: import_zod7.z.string()
-});
-var snapshotSchema = import_zod7.z.object({
-  amountBase: import_zod7.z.string(),
-  amountDistributed: import_zod7.z.string(),
-  createdAt: import_zod7.z.string().datetime(),
-  rootHash: import_zod7.z.string().nullable(),
-  timestamp: import_zod7.z.string().datetime(),
-  updatedAt: import_zod7.z.string().datetime(),
-  userCount: import_zod7.z.number().nullable().optional(),
-  activeUserCount: import_zod7.z.number().optional(),
-  tvl: import_zod7.z.string().nullable().optional(),
-  baseTvl: import_zod7.z.string().nullable().optional(),
-  netTvl: import_zod7.z.string().nullable().optional(),
-  turtleTvl: import_zod7.z.string().nullable().optional(),
-  turtleNetTvl: import_zod7.z.string().nullable().optional(),
-  customMetrics: import_zod7.z.record(import_zod7.z.unknown()).optional(),
-  customArgs: import_zod7.z.union([customArgsTokensPerUsdSchema, customArgsAprSchema, customArgsTokensPerDaySchema]).optional()
-});
-var streamPointSchema = import_zod7.z.object({
-  id: import_zod7.z.string(),
-  orgId: import_zod7.z.string().optional(),
-  symbol: import_zod7.z.string(),
-  name: import_zod7.z.string(),
-  decimals: import_zod7.z.coerce.number().optional(),
-  logoUrl: import_zod7.z.string().url().nullable().optional(),
-  createdAt: import_zod7.z.string().optional(),
-  updatedAt: import_zod7.z.string().optional(),
-  deletedAt: import_zod7.z.string().nullable().optional(),
+var import_zod8 = require("zod");
+var customArgsTokensPerUsdSchema = import_zod8.z.object({
+  tokensPerUSD: import_zod8.z.string(),
+  targetChainId: import_zod8.z.number(),
+  targetTokenAddress: import_zod8.z.string()
+});
+var customArgsAprSchema = import_zod8.z.object({
+  apr: import_zod8.z.string(),
+  targetChainId: import_zod8.z.number(),
+  targetTokenAddress: import_zod8.z.string()
+});
+var customArgsTokensPerDaySchema = import_zod8.z.object({
+  tokensPerDay: import_zod8.z.string(),
+  targetChainId: import_zod8.z.number(),
+  targetTokenAddress: import_zod8.z.string()
+});
+var snapshotSchema = import_zod8.z.object({
+  amountBase: import_zod8.z.string(),
+  amountDistributed: import_zod8.z.string(),
+  createdAt: import_zod8.z.string().datetime(),
+  rootHash: import_zod8.z.string().nullable(),
+  timestamp: import_zod8.z.string().datetime(),
+  updatedAt: import_zod8.z.string().datetime(),
+  userCount: import_zod8.z.number().nullable().optional(),
+  activeUserCount: import_zod8.z.number().optional(),
+  tvl: import_zod8.z.string().nullable().optional(),
+  baseTvl: import_zod8.z.string().nullable().optional(),
+  netTvl: import_zod8.z.string().nullable().optional(),
+  turtleTvl: import_zod8.z.string().nullable().optional(),
+  turtleNetTvl: import_zod8.z.string().nullable().optional(),
+  customMetrics: import_zod8.z.record(import_zod8.z.unknown()).optional(),
+  customArgs: import_zod8.z.union([customArgsTokensPerUsdSchema, customArgsAprSchema, customArgsTokensPerDaySchema]).optional()
+});
+var streamPointSchema = import_zod8.z.object({
+  id: import_zod8.z.string(),
+  orgId: import_zod8.z.string().optional(),
+  symbol: import_zod8.z.string(),
+  name: import_zod8.z.string(),
+  decimals: import_zod8.z.coerce.number().optional(),
+  logoUrl: import_zod8.z.string().url().nullable().optional(),
+  createdAt: import_zod8.z.string().optional(),
+  updatedAt: import_zod8.z.string().optional(),
+  deletedAt: import_zod8.z.string().nullable().optional(),
   organization: organizationSchema.nullable().optional()
 });
-var chainSchema2 = import_zod7.z.object({
-  chainId: import_zod7.z.coerce.number(),
-  ecosystem: import_zod7.z.string(),
-  explorerUrl: import_zod7.z.string(),
-  id: import_zod7.z.string().uuid(),
-  isTestnet: import_zod7.z.boolean(),
-  logoUrl: import_zod7.z.string(),
-  name: import_zod7.z.string(),
-  slug: import_zod7.z.string(),
-  status: import_zod7.z.string()
-});
-var rewardTokenSchema = import_zod7.z.object({
-  active: import_zod7.z.boolean(),
-  address: import_zod7.z.string(),
-  canonicalAssetId: import_zod7.z.string().uuid(),
+var chainSchema2 = import_zod8.z.object({
+  chainId: import_zod8.z.coerce.number(),
+  ecosystem: import_zod8.z.string(),
+  explorerUrl: import_zod8.z.string(),
+  id: import_zod8.z.string().uuid(),
+  isTestnet: import_zod8.z.boolean(),
+  logoUrl: import_zod8.z.string(),
+  name: import_zod8.z.string(),
+  slug: import_zod8.z.string(),
+  status: import_zod8.z.string()
+});
+var rewardTokenSchema = import_zod8.z.object({
+  active: import_zod8.z.boolean(),
+  address: import_zod8.z.string(),
+  canonicalAssetId: import_zod8.z.string().uuid(),
   chain: chainSchema2,
-  decimals: import_zod7.z.number(),
-  id: import_zod7.z.string().uuid(),
-  isNative: import_zod7.z.boolean(),
-  logoUrl: import_zod7.z.string(),
-  name: import_zod7.z.string(),
-  priceUsd: import_zod7.z.number(),
-  symbol: import_zod7.z.string(),
-  streamsMinAmount: import_zod7.z.string().nullable().optional()
+  decimals: import_zod8.z.number(),
+  id: import_zod8.z.string().uuid(),
+  isNative: import_zod8.z.boolean(),
+  logoUrl: import_zod8.z.string(),
+  name: import_zod8.z.string(),
+  priceUsd: import_zod8.z.number(),
+  symbol: import_zod8.z.string(),
+  streamsMinAmount: import_zod8.z.string().nullable().optional()
 }).nullable();
-var adaptersSchema = import_zod7.z.array(
-  import_zod7.z.object({
-    type: import_zod7.z.string(),
-    params: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.number())
+var adaptersSchema = import_zod8.z.array(
+  import_zod8.z.object({
+    type: import_zod8.z.string(),
+    params: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.number())
   })
 );
-var feeTierSchema = import_zod7.z.object({
-  maxTVL: import_zod7.z.string().nullable(),
+var feeTierSchema = import_zod8.z.object({
+  maxTVL: import_zod8.z.string().nullable(),
   // represents a USD amount
-  feePct: import_zod7.z.string()
+  feePct: import_zod8.z.string()
   // represents a percentage (e.g. 0.15 means 15%)
 });
-var feeScheduleSchema = import_zod7.z.object({
-  feeTiers: import_zod7.z.array(feeTierSchema),
-  until: import_zod7.z.string().datetime().nullable()
+var feeScheduleSchema = import_zod8.z.object({
+  feeTiers: import_zod8.z.array(feeTierSchema),
+  until: import_zod8.z.string().datetime().nullable()
 });
-var feeSnapshotSchema = import_zod7.z.object({
-  timestamp: import_zod7.z.string().datetime(),
-  tvl: import_zod7.z.string().nullable(),
+var feeSnapshotSchema = import_zod8.z.object({
+  timestamp: import_zod8.z.string().datetime(),
+  tvl: import_zod8.z.string().nullable(),
   // means USD amount
-  accumulatedFee: import_zod7.z.string(),
+  accumulatedFee: import_zod8.z.string(),
   // means USD amount
-  createdAt: import_zod7.z.string().datetime(),
-  updatedAt: import_zod7.z.string().datetime()
-});
-var feeSchema = import_zod7.z.object({
-  managementFeeSchedules: import_zod7.z.array(feeScheduleSchema),
-  createdAt: import_zod7.z.string().datetime(),
-  updatedAt: import_zod7.z.string().datetime(),
-  lastFeeSnapshotTimestamp: import_zod7.z.string().datetime(),
-  feeComputationPaused: import_zod7.z.boolean(),
-  feeSnapshots: import_zod7.z.array(feeSnapshotSchema).optional(),
+  createdAt: import_zod8.z.string().datetime(),
+  updatedAt: import_zod8.z.string().datetime()
+});
+var feeSchema = import_zod8.z.object({
+  managementFeeSchedules: import_zod8.z.array(feeScheduleSchema),
+  createdAt: import_zod8.z.string().datetime(),
+  updatedAt: import_zod8.z.string().datetime(),
+  lastFeeSnapshotTimestamp: import_zod8.z.string().datetime(),
+  feeComputationPaused: import_zod8.z.boolean(),
+  feeSnapshots: import_zod8.z.array(feeSnapshotSchema).optional(),
   lastFeeSnapshot: feeSnapshotSchema.nullable()
 });
-var streamSchema = import_zod7.z.object({
+var streamSchema = import_zod8.z.object({
   adapters: adaptersSchema,
-  admin: import_zod7.z.string().nullable(),
-  chainId: import_zod7.z.number().nullable(),
-  chargedFee: import_zod7.z.string().nullable(),
-  claimPaused: import_zod7.z.boolean(),
+  admin: import_zod8.z.string().nullable(),
+  chainId: import_zod8.z.number().nullable(),
+  chargedFee: import_zod8.z.string().nullable(),
+  claimPaused: import_zod8.z.boolean(),
   committedSnapshot: snapshotSchema.nullable(),
-  contractAddress: import_zod7.z.string().nullable(),
-  createdAt: import_zod7.z.string().datetime(),
-  creationConfirmedAt: import_zod7.z.string().datetime().nullable(),
-  customArgs: import_zod7.z.union([
+  contractAddress: import_zod8.z.string().nullable(),
+  createdAt: import_zod8.z.string().datetime(),
+  creationConfirmedAt: import_zod8.z.string().datetime().nullable(),
+  customArgs: import_zod8.z.union([
     customArgsTokensPerUsdSchema,
     customArgsAprSchema,
     customArgsTokensPerDaySchema
   ]),
-  endTimestamp: import_zod7.z.string().datetime().nullable(),
+  endTimestamp: import_zod8.z.string().datetime().nullable(),
   fee: feeSchema.nullable(),
-  hashCommitmentPaused: import_zod7.z.boolean(),
-  id: import_zod7.z.string().uuid(),
+  hashCommitmentPaused: import_zod8.z.boolean(),
+  id: import_zod8.z.string().uuid(),
   lastSnapshot: snapshotSchema.nullable(),
-  merkleTreeComputationPaused: import_zod7.z.boolean(),
-  orgId: import_zod7.z.string().uuid(),
+  merkleTreeComputationPaused: import_zod8.z.boolean(),
+  orgId: import_zod8.z.string().uuid(),
   point: streamPointSchema.nullable().optional(),
   rewardToken: rewardTokenSchema,
-  snapshotComputationPaused: import_zod7.z.boolean(),
-  snapshots: import_zod7.z.array(snapshotSchema).optional(),
-  startTimestamp: import_zod7.z.string().datetime(),
-  strategy: import_zod7.z.string(),
-  targetTokenId: import_zod7.z.string().uuid(),
-  totalAmount: import_zod7.z.string().nullable(),
-  type: import_zod7.z.number(),
-  updatedAt: import_zod7.z.string().datetime(),
-  userId: import_zod7.z.string().uuid()
-});
-var getStreamsOutputSchema = import_zod7.z.object({
-  streams: import_zod7.z.array(streamSchema)
-});
-var getStreamPointsOutputSchema = import_zod7.z.object({
-  points: import_zod7.z.array(streamPointSchema)
-});
-var createStreamPointBodySchema = import_zod7.z.object({
-  name: import_zod7.z.string(),
-  symbol: import_zod7.z.string(),
-  decimals: import_zod7.z.number().optional(),
-  logoUrl: import_zod7.z.string().url().nullable().optional()
-});
-var createStreamPointOutputSchema = import_zod7.z.object({
+  snapshotComputationPaused: import_zod8.z.boolean(),
+  snapshots: import_zod8.z.array(snapshotSchema).optional(),
+  startTimestamp: import_zod8.z.string().datetime(),
+  strategy: import_zod8.z.string(),
+  targetTokenId: import_zod8.z.string().uuid(),
+  totalAmount: import_zod8.z.string().nullable(),
+  type: import_zod8.z.number(),
+  updatedAt: import_zod8.z.string().datetime(),
+  userId: import_zod8.z.string().uuid()
+});
+var getStreamsOutputSchema = import_zod8.z.object({
+  streams: import_zod8.z.array(streamSchema)
+});
+var getStreamPointsOutputSchema = import_zod8.z.object({
+  points: import_zod8.z.array(streamPointSchema)
+});
+var createStreamPointBodySchema = import_zod8.z.object({
+  name: import_zod8.z.string(),
+  symbol: import_zod8.z.string(),
+  decimals: import_zod8.z.number().optional(),
+  logoUrl: import_zod8.z.string().url().nullable().optional()
+});
+var createStreamPointOutputSchema = import_zod8.z.object({
   point: streamPointSchema
 });
-var getStreamsSupportedChainsOutputSchema = import_zod7.z.object({
-  success: import_zod7.z.boolean(),
-  chains: import_zod7.z.array(
-    import_zod7.z.object({
-      id: import_zod7.z.string(),
-      name: import_zod7.z.string(),
-      slug: import_zod7.z.string(),
-      chainId: import_zod7.z.number(),
-      logoUrl: import_zod7.z.string(),
-      ecosystem: import_zod7.z.string(),
-      status: import_zod7.z.string(),
-      explorerUrl: import_zod7.z.string(),
-      streamFactory: import_zod7.z.string()
+var getStreamsSupportedChainsOutputSchema = import_zod8.z.object({
+  success: import_zod8.z.boolean(),
+  chains: import_zod8.z.array(
+    import_zod8.z.object({
+      id: import_zod8.z.string(),
+      name: import_zod8.z.string(),
+      slug: import_zod8.z.string(),
+      chainId: import_zod8.z.number(),
+      logoUrl: import_zod8.z.string(),
+      ecosystem: import_zod8.z.string(),
+      status: import_zod8.z.string(),
+      explorerUrl: import_zod8.z.string(),
+      streamFactory: import_zod8.z.string()
       // Address as string
     })
   )
 });
-var streamSignatureRequestInputSchema = import_zod7.z.object({
+var streamSignatureRequestInputSchema = import_zod8.z.object({
   adapters: adaptersSchema,
-  chainId: import_zod7.z.number().nullable(),
-  customArgs: import_zod7.z.intersection(
-    import_zod7.z.object({
-      targetChainId: import_zod7.z.number(),
-      targetTokenAddress: import_zod7.z.string()
+  chainId: import_zod8.z.number().nullable(),
+  customArgs: import_zod8.z.intersection(
+    import_zod8.z.object({
+      targetChainId: import_zod8.z.number(),
+      targetTokenAddress: import_zod8.z.string()
     }),
-    import_zod7.z.union([
-      import_zod7.z.object({ tokensPerUSD: import_zod7.z.string() }),
-      import_zod7.z.object({ apr: import_zod7.z.string() }),
-      import_zod7.z.object({ tokensPerDay: import_zod7.z.string() })
+    import_zod8.z.union([
+      import_zod8.z.object({ tokensPerUSD: import_zod8.z.string() }),
+      import_zod8.z.object({ apr: import_zod8.z.string() }),
+      import_zod8.z.object({ tokensPerDay: import_zod8.z.string() })
     ])
   ),
-  endTimestamp: import_zod7.z.string().nullable(),
-  pointId: import_zod7.z.string().uuid().nullable(),
-  rewardToken: import_zod7.z.string().nullable(),
-  startTimestamp: import_zod7.z.string(),
-  totalAmount: import_zod7.z.string().nullable(),
-  type: import_zod7.z.number(),
-  walletAddress: import_zod7.z.string().nullable()
-});
-var streamSignatureRequestOutputSchema = import_zod7.z.object({
-  success: import_zod7.z.boolean(),
-  message: import_zod7.z.string(),
-  txParams: import_zod7.z.object({
-    chainId: import_zod7.z.number(),
-    sender: import_zod7.z.string(),
-    params: import_zod7.z.object({
-      deadline: import_zod7.z.number(),
-      params: import_zod7.z.object({
-        StreamId: import_zod7.z.array(import_zod7.z.number()),
-        RewardToken: import_zod7.z.string(),
-        NetTotalAmount: import_zod7.z.string(),
-        FeeAmount: import_zod7.z.string()
+  endTimestamp: import_zod8.z.string().nullable(),
+  pointId: import_zod8.z.string().uuid().nullable(),
+  rewardToken: import_zod8.z.string().nullable(),
+  startTimestamp: import_zod8.z.string(),
+  totalAmount: import_zod8.z.string().nullable(),
+  type: import_zod8.z.number(),
+  walletAddress: import_zod8.z.string().nullable()
+});
+var streamSignatureRequestOutputSchema = import_zod8.z.object({
+  success: import_zod8.z.boolean(),
+  message: import_zod8.z.string(),
+  txParams: import_zod8.z.object({
+    chainId: import_zod8.z.number(),
+    sender: import_zod8.z.string(),
+    params: import_zod8.z.object({
+      deadline: import_zod8.z.number(),
+      params: import_zod8.z.object({
+        StreamId: import_zod8.z.array(import_zod8.z.number()),
+        RewardToken: import_zod8.z.string(),
+        NetTotalAmount: import_zod8.z.string(),
+        FeeAmount: import_zod8.z.string()
       }),
-      signature: import_zod7.z.string()
+      signature: import_zod8.z.string()
     })
   }).nullable()
 });
-var getStreamsQuerySchema = import_zod7.z.object({
-  streamId: import_zod7.z.string().optional(),
-  userId: import_zod7.z.string().optional(),
-  organizationId: import_zod7.z.string().optional(),
-  withSnapshots: import_zod7.z.boolean().optional(),
-  withFeeSnapshots: import_zod7.z.boolean().optional(),
-  usersCount: import_zod7.z.boolean().optional()
-});
-var getStreamPointsQuerySchema = import_zod7.z.object({
-  id: import_zod7.z.string().optional().nullable(),
-  organizationId: import_zod7.z.string().optional().nullable(),
-  symbol: import_zod7.z.string().optional().nullable(),
-  name: import_zod7.z.string().optional().nullable()
-});
-var streamWalletSnapshotSchema = import_zod7.z.object({
-  timestamp: import_zod7.z.string().datetime(),
-  rewardsAccumulated: import_zod7.z.string(),
-  rewardsAccumulatedBase: import_zod7.z.string(),
-  createdAt: import_zod7.z.string().datetime(),
-  updatedAt: import_zod7.z.string().datetime(),
-  tvl: import_zod7.z.string().nullable().optional()
-});
-var streamWalletSchema = import_zod7.z.object({
-  userAddress: import_zod7.z.string(),
+var getStreamsQuerySchema = import_zod8.z.object({
+  streamId: import_zod8.z.string().optional(),
+  userId: import_zod8.z.string().optional(),
+  organizationId: import_zod8.z.string().optional(),
+  withSnapshots: import_zod8.z.boolean().optional(),
+  withFeeSnapshots: import_zod8.z.boolean().optional(),
+  usersCount: import_zod8.z.boolean().optional()
+});
+var getStreamPointsQuerySchema = import_zod8.z.object({
+  id: import_zod8.z.string().optional().nullable(),
+  organizationId: import_zod8.z.string().optional().nullable(),
+  symbol: import_zod8.z.string().optional().nullable(),
+  name: import_zod8.z.string().optional().nullable()
+});
+var streamWalletSnapshotSchema = import_zod8.z.object({
+  timestamp: import_zod8.z.string().datetime(),
+  rewardsAccumulated: import_zod8.z.string(),
+  rewardsAccumulatedBase: import_zod8.z.string(),
+  createdAt: import_zod8.z.string().datetime(),
+  updatedAt: import_zod8.z.string().datetime(),
+  tvl: import_zod8.z.string().nullable().optional()
+});
+var streamWalletSchema = import_zod8.z.object({
+  userAddress: import_zod8.z.string(),
   lastSnapshot: streamWalletSnapshotSchema
 });
-var paginationSchema = import_zod7.z.object({
-  limit: import_zod7.z.number(),
-  page: import_zod7.z.number(),
-  total: import_zod7.z.number(),
-  totalPages: import_zod7.z.number()
+var paginationSchema = import_zod8.z.object({
+  limit: import_zod8.z.number(),
+  page: import_zod8.z.number(),
+  total: import_zod8.z.number(),
+  totalPages: import_zod8.z.number()
 });
-var getStreamWalletsResponseSchema = import_zod7.z.object({
-  data: import_zod7.z.array(streamWalletSchema),
+var getStreamWalletsResponseSchema = import_zod8.z.object({
+  data: import_zod8.z.array(streamWalletSchema),
   pagination: paginationSchema
 });
-var getStreamWalletsQuerySchema = import_zod7.z.object({
-  streamId: import_zod7.z.string(),
-  page: import_zod7.z.number().optional(),
-  limit: import_zod7.z.number().optional()
+var getStreamWalletsQuerySchema = import_zod8.z.object({
+  streamId: import_zod8.z.string(),
+  page: import_zod8.z.number().optional(),
+  limit: import_zod8.z.number().optional()
 });
-var streamWalletDetailsSchema = import_zod7.z.object({
-  streamId: import_zod7.z.string(),
-  userAddress: import_zod7.z.string(),
-  snapshots: import_zod7.z.array(streamWalletSnapshotSchema),
+var streamWalletDetailsSchema = import_zod8.z.object({
+  streamId: import_zod8.z.string(),
+  userAddress: import_zod8.z.string(),
+  snapshots: import_zod8.z.array(streamWalletSnapshotSchema),
   stream: streamSchema
 });
-var getStreamWalletDetailsResponseSchema = import_zod7.z.object({
+var getStreamWalletDetailsResponseSchema = import_zod8.z.object({
   wallet: streamWalletDetailsSchema
 });
 
@@ -1290,68 +1304,68 @@ function useStreamSupportedChains({
 }
 
 // src/v2/opportunities/schema.ts
-var opportunityTypeEnum = import_zod8.z.enum(["vault", "lending", "staking", "stablecoin", "draft", ""]);
-var opportunityStatusEnum = import_zod8.z.enum(["active", "paused", "deprecated", "draft", "ended"]);
-var opportunitySchema = import_zod8.z.object({
-  id: import_zod8.z.string().uuid().optional(),
-  name: import_zod8.z.string(),
-  shortName: import_zod8.z.string(),
+var opportunityTypeEnum = import_zod9.z.enum(["vault", "lending", "staking", "stablecoin", "draft", ""]);
+var opportunityStatusEnum = import_zod9.z.enum(["active", "paused", "deprecated", "draft", "ended"]);
+var opportunitySchema = import_zod9.z.object({
+  id: import_zod9.z.string().uuid().optional(),
+  name: import_zod9.z.string(),
+  shortName: import_zod9.z.string(),
   type: opportunityTypeEnum,
-  description: import_zod8.z.string().optional().default(""),
-  curator: import_zod8.z.string().optional().default(""),
-  tvl: import_zod8.z.number().min(0, "TVL must be positive"),
-  featured: import_zod8.z.boolean().optional().default(false),
-  featuredOrder: import_zod8.z.number().int().optional().nullable(),
-  originalConfig: import_zod8.z.any().optional().nullable(),
-  exposures: import_zod8.z.array(import_zod8.z.string()).optional().default([]),
-  tags: import_zod8.z.array(import_zod8.z.any()).optional().default([]),
+  description: import_zod9.z.string().optional().default(""),
+  curator: import_zod9.z.string().optional().default(""),
+  tvl: import_zod9.z.number().min(0, "TVL must be positive"),
+  featured: import_zod9.z.boolean().optional().default(false),
+  featuredOrder: import_zod9.z.number().int().optional().nullable(),
+  originalConfig: import_zod9.z.any().optional().nullable(),
+  exposures: import_zod9.z.array(import_zod9.z.string()).optional().default([]),
+  tags: import_zod9.z.array(import_zod9.z.any()).optional().default([]),
   status: opportunityStatusEnum.optional().default("active"),
-  statusReason: import_zod8.z.string().optional().default(""),
-  depositDisabled: import_zod8.z.boolean().optional().default(false),
-  depositDisabledReason: import_zod8.z.string().optional().default(""),
-  withdrawalDisabled: import_zod8.z.boolean().optional().default(false),
-  withdrawalDisabledReason: import_zod8.z.string().optional().default(""),
-  docsUrl: import_zod8.z.string().optional().nullable(),
-  auditsUrl: import_zod8.z.string().optional().nullable(),
-  turtleTvl: import_zod8.z.number(),
-  turtleUsers: import_zod8.z.number(),
-  earnEnabled: import_zod8.z.boolean(),
-  swapDirectEnabled: import_zod8.z.boolean().optional().default(true),
-  swapRouteEnabled: import_zod8.z.boolean().optional().default(false),
-  createdAt: import_zod8.z.string().datetime().optional(),
-  updatedAt: import_zod8.z.string().datetime().optional(),
-  mainStreamId: import_zod8.z.string().optional(),
+  statusReason: import_zod9.z.string().optional().default(""),
+  depositDisabled: import_zod9.z.boolean().optional().default(false),
+  depositDisabledReason: import_zod9.z.string().optional().default(""),
+  withdrawalDisabled: import_zod9.z.boolean().optional().default(false),
+  withdrawalDisabledReason: import_zod9.z.string().optional().default(""),
+  docsUrl: import_zod9.z.string().optional().nullable(),
+  auditsUrl: import_zod9.z.string().optional().nullable(),
+  turtleTvl: import_zod9.z.number(),
+  turtleUsers: import_zod9.z.number(),
+  earnEnabled: import_zod9.z.boolean(),
+  swapDirectEnabled: import_zod9.z.boolean().optional().default(true),
+  swapRouteEnabled: import_zod9.z.boolean().optional().default(false),
+  createdAt: import_zod9.z.string().datetime().optional(),
+  updatedAt: import_zod9.z.string().datetime().optional(),
+  mainStreamId: import_zod9.z.string().optional(),
   // Relationships
-  depositTokens: import_zod8.z.array(tokenSchema),
-  withdrawTokens: import_zod8.z.array(tokenSchema).optional().default([]),
+  depositTokens: import_zod9.z.array(tokenSchema),
+  withdrawTokens: import_zod9.z.array(tokenSchema).optional().default([]),
   baseTokens: tokenSchema,
   receiptToken: tokenSchema,
-  incentives: import_zod8.z.array(incentiveSchema),
-  products: import_zod8.z.array(productSchema),
+  incentives: import_zod9.z.array(incentiveSchema),
+  products: import_zod9.z.array(productSchema),
   vaultConfig: vaultConfigSchema.optional().nullable(),
   lendingConfig: lendingConfigSchema.optional().nullable(),
   stakingConfig: stakingConfigSchema.optional().nullable(),
   mainStream: streamSchema.optional().nullable(),
   // Will be deprecated
-  exposure: import_zod8.z.array(import_zod8.z.string()),
-  explorerUrl: import_zod8.z.string().nullable()
-});
-var opportunityFiltersSchema = import_zod8.z.object({
-  tokenId: import_zod8.z.string().uuid().optional(),
-  chain: import_zod8.z.string().optional(),
-  productId: import_zod8.z.string().uuid().optional(),
-  tags: import_zod8.z.string().optional(),
-  withMainStream: import_zod8.z.boolean().optional()
-});
-var opportunitiesResponseSchema = import_zod8.z.object({
-  opportunities: import_zod8.z.array(opportunitySchema),
-  total: import_zod8.z.number().optional()
-});
-var getOpportunitiesPaginatedInputSchema = import_zod8.z.object({
-  page: import_zod8.z.number().min(1).default(1),
-  limit: import_zod8.z.number().min(1).max(100).default(10),
+  exposure: import_zod9.z.array(import_zod9.z.string()),
+  explorerUrl: import_zod9.z.string().nullable()
+});
+var opportunityFiltersSchema = import_zod9.z.object({
+  tokenId: import_zod9.z.string().uuid().optional(),
+  chain: import_zod9.z.string().optional(),
+  productId: import_zod9.z.string().uuid().optional(),
+  tags: import_zod9.z.string().optional(),
+  withMainStream: import_zod9.z.boolean().optional()
+});
+var opportunitiesResponseSchema = import_zod9.z.object({
+  opportunities: import_zod9.z.array(opportunitySchema),
+  total: import_zod9.z.number().optional()
+});
+var getOpportunitiesPaginatedInputSchema = import_zod9.z.object({
+  page: import_zod9.z.number().min(1).default(1),
+  limit: import_zod9.z.number().min(1).max(100).default(10),
   // Sorting
-  sortBy: import_zod8.z.enum([
+  sortBy: import_zod9.z.enum([
     "turtleTvl",
     "tvl",
     "name",
@@ -1362,105 +1376,105 @@ var getOpportunitiesPaginatedInputSchema = import_zod8.z.object({
     "provider",
     "apr"
   ]).optional(),
-  sortOrder: import_zod8.z.enum(["asc", "desc"]).optional(),
+  sortOrder: import_zod9.z.enum(["asc", "desc"]).optional(),
   // Filter by receipt token chain (comma-separated)
-  receiptTokenChainId: import_zod8.z.string().optional(),
+  receiptTokenChainId: import_zod9.z.string().optional(),
   // Comma-separated UUIDs
-  receiptTokenChainSlug: import_zod8.z.string().optional(),
+  receiptTokenChainSlug: import_zod9.z.string().optional(),
   // Comma-separated slugs
   // Filter by deposit token
-  depositTokenGroup: import_zod8.z.string().optional(),
-  depositTokenSymbols: import_zod8.z.string().optional(),
+  depositTokenGroup: import_zod9.z.string().optional(),
+  depositTokenSymbols: import_zod9.z.string().optional(),
   // Comma-separated symbols
-  depositTokenChainId: import_zod8.z.string().optional(),
+  depositTokenChainId: import_zod9.z.string().optional(),
   // Filter by tags (comma-separated)
-  tags: import_zod8.z.string().optional(),
+  tags: import_zod9.z.string().optional(),
   // Filter by IDs (comma-separated UUIDs)
-  productId: import_zod8.z.string().optional(),
+  productId: import_zod9.z.string().optional(),
   // Comma-separated UUIDs
-  curatorId: import_zod8.z.string().optional(),
+  curatorId: import_zod9.z.string().optional(),
   // Comma-separated UUIDs
-  providerId: import_zod8.z.string().optional(),
+  providerId: import_zod9.z.string().optional(),
   // Comma-separated UUIDs
-  partnerId: import_zod8.z.string().optional(),
+  partnerId: import_zod9.z.string().optional(),
   // Comma-separated UUIDs
-  lendingProtocolId: import_zod8.z.string().optional(),
+  lendingProtocolId: import_zod9.z.string().optional(),
   // Comma-separated UUIDs
   // Status filters
-  withdrawalDisabled: import_zod8.z.boolean().optional(),
-  depositDisabled: import_zod8.z.boolean().optional(),
-  status: import_zod8.z.string().optional(),
-  earnEnabled: import_zod8.z.boolean().optional(),
-  featured: import_zod8.z.boolean().optional(),
+  withdrawalDisabled: import_zod9.z.boolean().optional(),
+  depositDisabled: import_zod9.z.boolean().optional(),
+  status: import_zod9.z.string().optional(),
+  earnEnabled: import_zod9.z.boolean().optional(),
+  featured: import_zod9.z.boolean().optional(),
   // TVL filters
-  tvlGreaterThan: import_zod8.z.number().optional(),
-  turtleTvlGreaterThan: import_zod8.z.number().optional(),
-  tvlMin: import_zod8.z.number().optional(),
-  tvlMax: import_zod8.z.number().optional(),
+  tvlGreaterThan: import_zod9.z.number().optional(),
+  turtleTvlGreaterThan: import_zod9.z.number().optional(),
+  tvlMin: import_zod9.z.number().optional(),
+  tvlMax: import_zod9.z.number().optional(),
   // APR filters
-  minApr: import_zod8.z.number().optional(),
-  maxApr: import_zod8.z.number().optional(),
+  minApr: import_zod9.z.number().optional(),
+  maxApr: import_zod9.z.number().optional(),
   // Chain IDs (comma-separated)
-  chainIds: import_zod8.z.string().optional(),
+  chainIds: import_zod9.z.string().optional(),
   // Search
-  search: import_zod8.z.string().optional(),
-  withMainStream: import_zod8.z.boolean().optional()
+  search: import_zod9.z.string().optional(),
+  withMainStream: import_zod9.z.boolean().optional()
 });
-var paginationMetadataSchema2 = import_zod8.z.object({
-  page: import_zod8.z.number(),
-  limit: import_zod8.z.number(),
-  total: import_zod8.z.number(),
-  totalPages: import_zod8.z.number()
+var paginationMetadataSchema2 = import_zod9.z.object({
+  page: import_zod9.z.number(),
+  limit: import_zod9.z.number(),
+  total: import_zod9.z.number(),
+  totalPages: import_zod9.z.number()
 });
-var getOpportunitiesPaginatedSchema = import_zod8.z.object({
-  opportunities: import_zod8.z.array(opportunitySchema),
+var getOpportunitiesPaginatedSchema = import_zod9.z.object({
+  opportunities: import_zod9.z.array(opportunitySchema),
   pagination: paginationMetadataSchema2
 });
-var filterChainSchema = import_zod8.z.object({
-  id: import_zod8.z.string().uuid(),
-  name: import_zod8.z.string(),
-  slug: import_zod8.z.string(),
-  chainId: import_zod8.z.string(),
-  logoUrl: import_zod8.z.string(),
-  ecosystem: import_zod8.z.string(),
-  status: import_zod8.z.string(),
-  explorerUrl: import_zod8.z.string()
-});
-var filterOrganizationSchema = import_zod8.z.object({
-  id: import_zod8.z.string().uuid(),
-  name: import_zod8.z.string(),
-  description: import_zod8.z.string(),
-  landingUrl: import_zod8.z.string(),
-  iconUrl: import_zod8.z.string(),
-  organizationType: import_zod8.z.string(),
-  turtleRefCode: import_zod8.z.string(),
-  twitterHandle: import_zod8.z.string(),
-  status: import_zod8.z.string(),
-  featured: import_zod8.z.boolean()
-});
-var filterTagSchema = import_zod8.z.object({
-  id: import_zod8.z.string().uuid(),
-  code: import_zod8.z.string(),
-  name: import_zod8.z.string(),
-  description: import_zod8.z.string().optional().nullable(),
-  color: import_zod8.z.string().optional().nullable(),
-  type: import_zod8.z.string().optional().nullable()
+var filterChainSchema = import_zod9.z.object({
+  id: import_zod9.z.string().uuid(),
+  name: import_zod9.z.string(),
+  slug: import_zod9.z.string(),
+  chainId: import_zod9.z.string(),
+  logoUrl: import_zod9.z.string(),
+  ecosystem: import_zod9.z.string(),
+  status: import_zod9.z.string(),
+  explorerUrl: import_zod9.z.string()
+});
+var filterOrganizationSchema = import_zod9.z.object({
+  id: import_zod9.z.string().uuid(),
+  name: import_zod9.z.string(),
+  description: import_zod9.z.string(),
+  landingUrl: import_zod9.z.string(),
+  iconUrl: import_zod9.z.string(),
+  organizationType: import_zod9.z.string(),
+  turtleRefCode: import_zod9.z.string(),
+  twitterHandle: import_zod9.z.string(),
+  status: import_zod9.z.string(),
+  featured: import_zod9.z.boolean()
+});
+var filterTagSchema = import_zod9.z.object({
+  id: import_zod9.z.string().uuid(),
+  code: import_zod9.z.string(),
+  name: import_zod9.z.string(),
+  description: import_zod9.z.string().optional().nullable(),
+  color: import_zod9.z.string().optional().nullable(),
+  type: import_zod9.z.string().optional().nullable()
 });
-var depositTokenSymbolSchema = import_zod8.z.object({
-  symbol: import_zod8.z.string(),
-  logoUrl: import_zod8.z.string()
+var depositTokenSymbolSchema = import_zod9.z.object({
+  symbol: import_zod9.z.string(),
+  logoUrl: import_zod9.z.string()
 });
-var getOpportunitiesFilterOptionsSchema = import_zod8.z.object({
-  chains: import_zod8.z.array(filterChainSchema),
-  providers: import_zod8.z.array(filterOrganizationSchema),
-  curators: import_zod8.z.array(filterOrganizationSchema).optional().nullable(),
-  partners: import_zod8.z.array(filterOrganizationSchema).optional().nullable(),
-  tags: import_zod8.z.array(filterTagSchema).optional().nullable(),
-  lendingProtocols: import_zod8.z.array(filterOrganizationSchema),
-  depositTokenSymbols: import_zod8.z.array(depositTokenSymbolSchema).optional().nullable()
+var getOpportunitiesFilterOptionsSchema = import_zod9.z.object({
+  chains: import_zod9.z.array(filterChainSchema),
+  providers: import_zod9.z.array(filterOrganizationSchema),
+  curators: import_zod9.z.array(filterOrganizationSchema).optional().nullable(),
+  partners: import_zod9.z.array(filterOrganizationSchema).optional().nullable(),
+  tags: import_zod9.z.array(filterTagSchema).optional().nullable(),
+  lendingProtocols: import_zod9.z.array(filterOrganizationSchema),
+  depositTokenSymbols: import_zod9.z.array(depositTokenSymbolSchema).optional().nullable()
 });
-var getOpportunityByIdInputSchema = import_zod8.z.object({
-  withMainStream: import_zod8.z.boolean().optional()
+var getOpportunityByIdInputSchema = import_zod9.z.object({
+  withMainStream: import_zod9.z.boolean().optional()
 });
 
 // src/v2/opportunities/api.ts
@@ -1568,22 +1582,22 @@ var opportunitiesQueries = (0, import_query_key_factory4.createQueryKeys)("oppor
 var import_query_key_factory5 = require("@lukemorales/query-key-factory");
 
 // src/v2/earn-opportunities/schema.ts
-var import_zod9 = require("zod");
-var earnOpportunitySchema = import_zod9.z.object({
-  id: import_zod9.z.string().uuid(),
-  name: import_zod9.z.string(),
-  description: import_zod9.z.string(),
-  type: import_zod9.z.string(),
-  estimatedApr: import_zod9.z.number(),
-  tvl: import_zod9.z.number(),
-  featured: import_zod9.z.boolean(),
+var import_zod10 = require("zod");
+var earnOpportunitySchema = import_zod10.z.object({
+  id: import_zod10.z.string().uuid(),
+  name: import_zod10.z.string(),
+  description: import_zod10.z.string(),
+  type: import_zod10.z.string(),
+  estimatedApr: import_zod10.z.number(),
+  tvl: import_zod10.z.number(),
+  featured: import_zod10.z.boolean(),
   baseTokens: tokenSchema,
-  depositTokens: import_zod9.z.array(tokenSchema).nullable(),
+  depositTokens: import_zod10.z.array(tokenSchema).nullable(),
   receiptToken: tokenSchema
 });
-var earnOpportunitiesResponseSchema = import_zod9.z.object({
-  opportunities: import_zod9.z.array(earnOpportunitySchema).nullable(),
-  total: import_zod9.z.number().int()
+var earnOpportunitiesResponseSchema = import_zod10.z.object({
+  opportunities: import_zod10.z.array(earnOpportunitySchema).nullable(),
+  total: import_zod10.z.number().int()
 });
 
 // src/v2/earn-opportunities/api.ts
@@ -1614,82 +1628,82 @@ var import_query_key_factory6 = require("@lukemorales/query-key-factory");
 
 // src/v2/earn-route/schema.ts
 var import_utils = require("@turtleclub/utils");
-var import_zod10 = require("zod");
-var assetImageData = import_zod10.z.object({
-  kind: import_zod10.z.literal("image"),
-  url: import_zod10.z.string(),
-  alt: import_zod10.z.string()
-});
-var assetERC20Data = import_zod10.z.object({
-  kind: import_zod10.z.literal("erc20"),
-  address: import_zod10.z.string(),
-  name: import_zod10.z.string(),
-  symbol: import_zod10.z.string(),
-  decimals: import_zod10.z.number()
-});
-var assetData = import_zod10.z.discriminatedUnion("kind", [assetImageData, assetERC20Data]);
-var asset = import_zod10.z.object({
-  id: import_zod10.z.string().uuid(),
-  name: import_zod10.z.string(),
-  slugs: import_zod10.z.array(import_zod10.z.string()),
-  tags: import_zod10.z.array(import_zod10.z.string()),
-  description: import_zod10.z.string().nullable(),
-  data: import_zod10.z.array(assetData)
+var import_zod11 = require("zod");
+var assetImageData = import_zod11.z.object({
+  kind: import_zod11.z.literal("image"),
+  url: import_zod11.z.string(),
+  alt: import_zod11.z.string()
 });
-var routeToken = import_zod10.z.object({
-  address: import_zod10.z.string(),
-  name: import_zod10.z.string(),
-  symbol: import_zod10.z.string(),
-  logos: import_zod10.z.array(import_zod10.z.string()),
-  decimals: import_zod10.z.number(),
-  chain: import_zod10.z.number(),
-  price: import_zod10.z.number().nullable().optional()
-});
-var swapSubstep = import_zod10.z.object({
-  kind: import_zod10.z.literal("swap"),
-  from: import_zod10.z.array(routeToken),
-  to: import_zod10.z.array(routeToken),
-  protocol: import_zod10.z.string(),
+var assetERC20Data = import_zod11.z.object({
+  kind: import_zod11.z.literal("erc20"),
+  address: import_zod11.z.string(),
+  name: import_zod11.z.string(),
+  symbol: import_zod11.z.string(),
+  decimals: import_zod11.z.number()
+});
+var assetData = import_zod11.z.discriminatedUnion("kind", [assetImageData, assetERC20Data]);
+var asset = import_zod11.z.object({
+  id: import_zod11.z.string().uuid(),
+  name: import_zod11.z.string(),
+  slugs: import_zod11.z.array(import_zod11.z.string()),
+  tags: import_zod11.z.array(import_zod11.z.string()),
+  description: import_zod11.z.string().nullable(),
+  data: import_zod11.z.array(assetData)
+});
+var routeToken = import_zod11.z.object({
+  address: import_zod11.z.string(),
+  name: import_zod11.z.string(),
+  symbol: import_zod11.z.string(),
+  logos: import_zod11.z.array(import_zod11.z.string()),
+  decimals: import_zod11.z.number(),
+  chain: import_zod11.z.number(),
+  price: import_zod11.z.number().nullable().optional()
+});
+var swapSubstep = import_zod11.z.object({
+  kind: import_zod11.z.literal("swap"),
+  from: import_zod11.z.array(routeToken),
+  to: import_zod11.z.array(routeToken),
+  protocol: import_zod11.z.string(),
   protocol_asset: asset.nullable(),
-  price_impact: import_zod10.z.number().nullable()
-});
-var depositSubstep = import_zod10.z.object({
-  kind: import_zod10.z.literal("deposit"),
-  vault: import_zod10.z.string(),
-  from: import_zod10.z.array(routeToken),
-  to: import_zod10.z.array(routeToken),
-  amount: import_zod10.z.string(),
-  protocol: import_zod10.z.string(),
+  price_impact: import_zod11.z.number().nullable()
+});
+var depositSubstep = import_zod11.z.object({
+  kind: import_zod11.z.literal("deposit"),
+  vault: import_zod11.z.string(),
+  from: import_zod11.z.array(routeToken),
+  to: import_zod11.z.array(routeToken),
+  amount: import_zod11.z.string(),
+  protocol: import_zod11.z.string(),
   protocol_asset: asset.nullable(),
-  price_impact: import_zod10.z.number().nullable()
+  price_impact: import_zod11.z.number().nullable()
 });
-var routerSubstep = import_zod10.z.discriminatedUnion("kind", [swapSubstep, depositSubstep]);
-var stepTx = import_zod10.z.object({
+var routerSubstep = import_zod11.z.discriminatedUnion("kind", [swapSubstep, depositSubstep]);
+var stepTx = import_zod11.z.object({
   from: import_utils.ethz.address(),
   to: import_utils.ethz.address(),
   data: import_utils.ethz.hex(),
-  value: import_zod10.z.string(),
-  gas: import_zod10.z.number()
+  value: import_zod11.z.string(),
+  gas: import_zod11.z.number()
 });
-var approveStep = import_zod10.z.object({
-  kind: import_zod10.z.literal("approve"),
-  owner: import_zod10.z.string(),
-  spender: import_zod10.z.string(),
+var approveStep = import_zod11.z.object({
+  kind: import_zod11.z.literal("approve"),
+  owner: import_zod11.z.string(),
+  spender: import_zod11.z.string(),
   token: routeToken,
-  amount: import_zod10.z.string(),
+  amount: import_zod11.z.string(),
   tx: stepTx
 });
-var ensoStep = import_zod10.z.object({
-  kind: import_zod10.z.literal("enso"),
-  substeps: import_zod10.z.array(routerSubstep),
+var ensoStep = import_zod11.z.object({
+  kind: import_zod11.z.literal("enso"),
+  substeps: import_zod11.z.array(routerSubstep),
   tx: stepTx,
   asset: asset.nullable()
 });
-var routerStep = import_zod10.z.discriminatedUnion("kind", [approveStep, ensoStep]);
-var earnRouteResponseSchema = import_zod10.z.object({
-  steps: import_zod10.z.array(routerStep),
-  amount_out: import_zod10.z.string(),
-  price_impact: import_zod10.z.number().nullable()
+var routerStep = import_zod11.z.discriminatedUnion("kind", [approveStep, ensoStep]);
+var earnRouteResponseSchema = import_zod11.z.object({
+  steps: import_zod11.z.array(routerStep),
+  amount_out: import_zod11.z.string(),
+  price_impact: import_zod11.z.number().nullable()
 });
 
 // src/v2/earn-route/api.ts
@@ -1732,30 +1746,30 @@ var earnRouteQueries = (0, import_query_key_factory6.createQueryKeys)("earnRoute
 var import_query_key_factory7 = require("@lukemorales/query-key-factory");
 
 // src/v2/earn-membership/schema.ts
-var import_zod11 = require("zod");
-var walletEcosystemEnum = import_zod11.z.enum(["evm", "solana", "ton"]);
-var checkMembershipResponseSchema = import_zod11.z.object({
-  isMember: import_zod11.z.boolean()
+var import_zod12 = require("zod");
+var walletEcosystemEnum = import_zod12.z.enum(["evm", "solana", "ton"]);
+var checkMembershipResponseSchema = import_zod12.z.object({
+  isMember: import_zod12.z.boolean()
 });
-var createAgreementRequestSchema = import_zod11.z.object({
-  address: import_zod11.z.string(),
+var createAgreementRequestSchema = import_zod12.z.object({
+  address: import_zod12.z.string(),
   walletEcosystem: walletEcosystemEnum,
-  url: import_zod11.z.string(),
-  chainId: import_zod11.z.string().default("1")
+  url: import_zod12.z.string(),
+  chainId: import_zod12.z.string().default("1")
 });
-var createAgreementResponseSchema = import_zod11.z.object({
-  message: import_zod11.z.string(),
-  nonce: import_zod11.z.string()
+var createAgreementResponseSchema = import_zod12.z.object({
+  message: import_zod12.z.string(),
+  nonce: import_zod12.z.string()
 });
-var createMembershipRequestSchema = import_zod11.z.object({
-  address: import_zod11.z.string(),
-  walletEcosystem: import_zod11.z.string(),
-  signature: import_zod11.z.string(),
-  nonce: import_zod11.z.string()
+var createMembershipRequestSchema = import_zod12.z.object({
+  address: import_zod12.z.string(),
+  walletEcosystem: import_zod12.z.string(),
+  signature: import_zod12.z.string(),
+  nonce: import_zod12.z.string()
 });
-var createMembershipResponseSchema = import_zod11.z.object({
-  isMember: import_zod11.z.boolean(),
-  error: import_zod11.z.string().optional()
+var createMembershipResponseSchema = import_zod12.z.object({
+  isMember: import_zod12.z.boolean(),
+  error: import_zod12.z.string().optional()
 });
 
 // src/v2/earn-membership/api.ts
@@ -1816,23 +1830,23 @@ var earnMembershipQueries = (0, import_query_key_factory7.createQueryKeys)("earn
 var import_query_key_factory8 = require("@lukemorales/query-key-factory");
 
 // src/v2/earn-deposits/schema.ts
-var import_zod12 = require("zod");
-var depositSchema = import_zod12.z.object({
-  chain: import_zod12.z.number().int(),
-  deposited_amount_usd: import_zod12.z.string(),
-  deposited_token_address: import_zod12.z.string(),
-  deposited_token_decimals: import_zod12.z.number().int(),
-  deposited_token_logo: import_zod12.z.string(),
-  deposited_token_name: import_zod12.z.string(),
-  deposited_token_symbol: import_zod12.z.string(),
-  deposited_value: import_zod12.z.string(),
-  depositor: import_zod12.z.string(),
-  target: import_zod12.z.string(),
-  timestamp: import_zod12.z.string(),
-  tx_hash: import_zod12.z.string()
-});
-var depositsResponseSchema = import_zod12.z.object({
-  deposits: import_zod12.z.array(depositSchema).nullable()
+var import_zod13 = require("zod");
+var depositSchema = import_zod13.z.object({
+  chain: import_zod13.z.number().int(),
+  deposited_amount_usd: import_zod13.z.string(),
+  deposited_token_address: import_zod13.z.string(),
+  deposited_token_decimals: import_zod13.z.number().int(),
+  deposited_token_logo: import_zod13.z.string(),
+  deposited_token_name: import_zod13.z.string(),
+  deposited_token_symbol: import_zod13.z.string(),
+  deposited_value: import_zod13.z.string(),
+  depositor: import_zod13.z.string(),
+  target: import_zod13.z.string(),
+  timestamp: import_zod13.z.string(),
+  tx_hash: import_zod13.z.string()
+});
+var depositsResponseSchema = import_zod13.z.object({
+  deposits: import_zod13.z.array(depositSchema).nullable()
 });
 
 // src/v2/earn-deposits/api.ts
@@ -1982,22 +1996,22 @@ var productsQueries = (0, import_query_key_factory10.createQueryKeys)("products"
 var import_query_key_factory11 = require("@lukemorales/query-key-factory");
 
 // src/v2/enso-balances/schemas.ts
-var import_zod13 = require("zod");
-var balanceTokenSchema = import_zod13.z.object({
-  address: import_zod13.z.string(),
-  name: import_zod13.z.string(),
-  symbol: import_zod13.z.string(),
-  logos: import_zod13.z.array(import_zod13.z.string()),
-  decimals: import_zod13.z.number(),
-  chain: import_zod13.z.number(),
-  price: import_zod13.z.number().nullable().optional()
-});
-var walletBalanceSchema = import_zod13.z.object({
+var import_zod14 = require("zod");
+var balanceTokenSchema = import_zod14.z.object({
+  address: import_zod14.z.string(),
+  name: import_zod14.z.string(),
+  symbol: import_zod14.z.string(),
+  logos: import_zod14.z.array(import_zod14.z.string()),
+  decimals: import_zod14.z.number(),
+  chain: import_zod14.z.number(),
+  price: import_zod14.z.number().nullable().optional()
+});
+var walletBalanceSchema = import_zod14.z.object({
   token: balanceTokenSchema,
-  amount: import_zod13.z.string()
+  amount: import_zod14.z.string()
 });
-var walletBalancesResponseSchema = import_zod13.z.object({
-  balances: import_zod13.z.array(walletBalanceSchema)
+var walletBalancesResponseSchema = import_zod14.z.object({
+  balances: import_zod14.z.array(walletBalanceSchema)
 });
 
 // src/v2/enso-balances/api.ts
@@ -2033,7 +2047,7 @@ var ensoBalancesQueries = (0, import_query_key_factory11.createQueryKeys)("ensoB
 var import_query_key_factory12 = require("@lukemorales/query-key-factory");
 
 // src/v2/widget/schema.ts
-var import_zod14 = require("zod");
+var import_zod15 = require("zod");
 
 // src/v2/opportunities/hooks.ts
 var import_react_query5 = require("@tanstack/react-query");
@@ -2086,9 +2100,9 @@ function useOpportunitiesFilterOptions({
 }
 
 // src/v2/widget/schema.ts
-var widgetOpportunitiesResponseSchema = import_zod14.z.object({
-  opportunities: import_zod14.z.array(opportunitySchema).nullable(),
-  total: import_zod14.z.number().int()
+var widgetOpportunitiesResponseSchema = import_zod15.z.object({
+  opportunities: import_zod15.z.array(opportunitySchema).nullable(),
+  total: import_zod15.z.number().int()
 });
 
 // src/v2/widget/api.ts
@@ -2117,69 +2131,69 @@ var widgetQueries = (0, import_query_key_factory12.createQueryKeys)("widget", {
 var import_query_key_factory13 = require("@lukemorales/query-key-factory");
 
 // src/v2/users/schemas.ts
-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),
+var import_zod16 = require("zod");
+var walletDataSchema = import_zod16.z.object({
+  address: import_zod16.z.string(),
+  totalAmountInUSD: import_zod16.z.string(),
+  tokens: import_zod16.z.array(tokenSchema)
+});
+var holdingsDataSchema = import_zod16.z.object({
+  totalAmountInUSD: import_zod16.z.string(),
+  chains: import_zod16.z.array(chainSchema).nullish(),
+  wallets: import_zod16.z.array(walletDataSchema).nullish()
+});
+var userEarningsSchema = import_zod16.z.object({
+  productId: import_zod16.z.string().uuid(),
+  value: import_zod16.z.number(),
+  referralsEarnings: import_zod16.z.number().nullish(),
+  rewardName: import_zod16.z.string().nullish(),
+  rewardType: import_zod16.z.string().nullish()
+});
+var portfolioSchema = import_zod16.z.object({
+  productsEarnings: import_zod16.z.array(userEarningsSchema),
   holdings: holdingsDataSchema.nullish()
 });
-var holdingInfoSchema = import_zod15.z.object({
-  amount: import_zod15.z.number(),
-  usdValue: import_zod15.z.number(),
+var holdingInfoSchema = import_zod16.z.object({
+  amount: import_zod16.z.number(),
+  usdValue: import_zod16.z.number(),
   token: tokenSchema.nullish()
 });
-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({
+var walletInfoSchema = import_zod16.z.object({
+  address: import_zod16.z.string().nullish(),
+  ecosystem: import_zod16.z.string().nullish(),
+  isMain: import_zod16.z.boolean().nullish(),
+  holdings: import_zod16.z.array(holdingInfoSchema).nullish()
+});
+var userWithDetailsSchema = import_zod16.z.object({
+  id: import_zod16.z.string(),
+  email: import_zod16.z.string().nullable(),
+  username: import_zod16.z.string().nullish(),
+  firstName: import_zod16.z.string().nullish(),
+  lastName: import_zod16.z.string().nullish(),
+  avatarUrl: import_zod16.z.string().nullish(),
+  telegramHandle: import_zod16.z.string().nullish(),
+  xUsername: import_zod16.z.string().nullish(),
+  role: import_zod16.z.string(),
+  createdAt: import_zod16.z.string(),
+  updatedAt: import_zod16.z.string(),
+  tags: import_zod16.z.array(import_zod16.z.string()).nullish(),
+  wallets: import_zod16.z.array(walletInfoSchema).nullish()
+});
+var getUserTurtlePortfolioInputSchema = import_zod16.z.object({
+  userId: import_zod16.z.string().uuid()
+});
+var getUserTurtlePortfolioOutputSchema = import_zod16.z.object({
   portfolio: portfolioSchema
 });
-var getUserTurtlePortfolioPathSchema = import_zod15.z.object({
-  userId: import_zod15.z.string().uuid()
+var getUserTurtlePortfolioPathSchema = import_zod16.z.object({
+  userId: import_zod16.z.string().uuid()
 });
-var getUserByIdInputSchema = import_zod15.z.object({
-  userId: import_zod15.z.string().uuid()
+var getUserByIdInputSchema = import_zod16.z.object({
+  userId: import_zod16.z.string().uuid()
 });
-var getUserByIdOutputSchema = import_zod15.z.object({
+var getUserByIdOutputSchema = import_zod16.z.object({
   user: userWithDetailsSchema.nullable(),
-  error: import_zod15.z.string().optional()
+  error: import_zod16.z.string().optional()
 });
 
 // src/v2/users/api.ts
@@ -2256,30 +2270,30 @@ var nftsQueries = (0, import_query_key_factory14.createQueryKeys)("nfts", {
 var import_query_key_factory15 = require("@lukemorales/query-key-factory");
 
 // 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 checkCoverRequestResponseSchema = import_zod16.z.object({
-  canSubmit: import_zod16.z.boolean(),
+var import_zod17 = require("zod");
+var coverRequestDataSchema = import_zod17.z.object({
+  protocolName: import_zod17.z.string(),
+  coverageAmount: import_zod17.z.string(),
+  periodDays: import_zod17.z.number(),
+  desiredApySacrifice: import_zod17.z.string(),
+  calculatedEstimatedPremium: import_zod17.z.string(),
+  tokenSymbol: import_zod17.z.string()
+});
+var submitCoverRequestResponseSchema = import_zod17.z.object({
+  success: import_zod17.z.boolean()
+});
+var checkCoverRequestResponseSchema = import_zod17.z.object({
+  canSubmit: import_zod17.z.boolean(),
   existingRequest: coverRequestDataSchema.nullable()
 });
-var submitCoverPurchaseDataSchema = import_zod16.z.object({
-  walletAddress: import_zod16.z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address"),
-  txHash: import_zod16.z.string().regex(/^0x[a-fA-F0-9]{64}$/, "Invalid transaction hash")
+var submitCoverPurchaseDataSchema = import_zod17.z.object({
+  walletAddress: import_zod17.z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid Ethereum address"),
+  txHash: import_zod17.z.string().regex(/^0x[a-fA-F0-9]{64}$/, "Invalid transaction hash")
 });
-var submitCoverPurchaseResponseSchema = import_zod16.z.object({
-  success: import_zod16.z.boolean(),
-  message: import_zod16.z.string(),
-  id: import_zod16.z.string()
+var submitCoverPurchaseResponseSchema = import_zod17.z.object({
+  success: import_zod17.z.boolean(),
+  message: import_zod17.z.string(),
+  id: import_zod17.z.string()
 });
 
 // src/v2/covers/api.ts
@@ -2336,34 +2350,34 @@ var coversQueries = (0, import_query_key_factory15.createQueryKeys)("covers", {
 var import_query_key_factory16 = 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(),
+var import_zod18 = require("zod");
+var portfolioTokenSchema = import_zod18.z.object({
+  id: import_zod18.z.string(),
+  address: import_zod18.z.string(),
+  name: import_zod18.z.string(),
+  symbol: import_zod18.z.string(),
+  decimals: import_zod18.z.number(),
+  isNative: import_zod18.z.boolean(),
+  logoUrl: import_zod18.z.string().nullable(),
+  amount: import_zod18.z.string(),
   // Portfolio-specific field (decimal format)
-  rawAmount: import_zod17.z.string(),
-  price: import_zod17.z.string().nullable().transform((val) => val ? parseFloat(val) : null),
+  rawAmount: import_zod18.z.string(),
+  price: import_zod18.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 portfolioWalletSchema = import_zod18.z.object({
+  id: import_zod18.z.string().optional(),
+  address: import_zod18.z.string(),
+  blockchain: import_zod18.z.string().optional(),
+  tokens: import_zod18.z.array(portfolioTokenSchema)
 });
-var portfolioHoldingsSchema = import_zod17.z.object({
-  wallets: import_zod17.z.array(portfolioWalletSchema)
+var portfolioHoldingsSchema = import_zod18.z.object({
+  wallets: import_zod18.z.array(portfolioWalletSchema)
 });
-var portfolioBalanceResponseSchema = import_zod17.z.object({
-  portfolio: import_zod17.z.object({
+var portfolioBalanceResponseSchema = import_zod18.z.object({
+  portfolio: import_zod18.z.object({
     holdings: portfolioHoldingsSchema
   })
 });
@@ -2396,26 +2410,26 @@ var balanceQueries = (0, import_query_key_factory16.createQueryKeys)("balance",
 var import_query_key_factory17 = require("@lukemorales/query-key-factory");
 
 // src/v2/deposits/schemas.ts
-var import_zod18 = require("zod");
-var uuidSchema2 = import_zod18.z.string().uuid();
-var sortBySchema = import_zod18.z.enum(["date", "usd_value"]).optional();
-var sortOrderSchema = import_zod18.z.enum(["asc", "desc"]).optional();
-var getDepositsRequestSchema = import_zod18.z.object({
+var import_zod19 = require("zod");
+var uuidSchema2 = import_zod19.z.string().uuid();
+var sortBySchema = import_zod19.z.enum(["date", "usd_value"]).optional();
+var sortOrderSchema = import_zod19.z.enum(["asc", "desc"]).optional();
+var getDepositsRequestSchema = import_zod19.z.object({
   // Filter by product or opportunity (optional, not mutually exclusive)
-  product_id: import_zod18.z.string().uuid().optional(),
-  opportunity_id: import_zod18.z.string().uuid().optional(),
+  product_id: import_zod19.z.string().uuid().optional(),
+  opportunity_id: import_zod19.z.string().uuid().optional(),
   // Search query
-  search: import_zod18.z.string().optional(),
+  search: import_zod19.z.string().optional(),
   // Sorting options
   sort_by: sortBySchema,
   sort_order: sortOrderSchema,
   // Additional filters
-  distributor_id: import_zod18.z.string().optional(),
-  depositor_address: import_zod18.z.string().optional(),
-  referral: import_zod18.z.string().optional(),
+  distributor_id: import_zod19.z.string().optional(),
+  depositor_address: import_zod19.z.string().optional(),
+  referral: import_zod19.z.string().optional(),
   // Pagination
-  page: import_zod18.z.number().int().min(1).optional().default(1),
-  page_limit: import_zod18.z.number().int().min(1).max(100).optional().default(20)
+  page: import_zod19.z.number().int().min(1).optional().default(1),
+  page_limit: import_zod19.z.number().int().min(1).max(100).optional().default(20)
 }).refine(
   (data) => {
     const hasProductId = !!data.product_id;
@@ -2427,31 +2441,31 @@ var getDepositsRequestSchema = import_zod18.z.object({
     path: ["product_id", "opportunity_id"]
   }
 );
-var depositResponseSchema = import_zod18.z.object({
+var depositResponseSchema = import_zod19.z.object({
   id: uuidSchema2,
   opportunityId: uuidSchema2,
   walletId: uuidSchema2.nullable().optional(),
   crmWalletId: uuidSchema2.nullable().optional(),
-  depositorAddress: import_zod18.z.string(),
-  amount: import_zod18.z.number(),
-  usdValue: import_zod18.z.number(),
-  depositTimestamp: import_zod18.z.string().datetime(),
+  depositorAddress: import_zod19.z.string(),
+  amount: import_zod19.z.number(),
+  usdValue: import_zod19.z.number(),
+  depositTimestamp: import_zod19.z.string().datetime(),
   // ISO 8601 format
-  txHash: import_zod18.z.string(),
-  verified: import_zod18.z.boolean().nullable().optional(),
-  distributorId: import_zod18.z.string().nullable().optional(),
-  referral: import_zod18.z.string().nullable().optional(),
-  explorerUrl: import_zod18.z.string().url().nullable().optional(),
-  createdAt: import_zod18.z.string().datetime(),
+  txHash: import_zod19.z.string(),
+  verified: import_zod19.z.boolean().nullable().optional(),
+  distributorId: import_zod19.z.string().nullable().optional(),
+  referral: import_zod19.z.string().nullable().optional(),
+  explorerUrl: import_zod19.z.string().url().nullable().optional(),
+  createdAt: import_zod19.z.string().datetime(),
   // ISO 8601 format
-  updatedAt: import_zod18.z.string().datetime()
+  updatedAt: import_zod19.z.string().datetime()
   // ISO 8601 format
 });
-var depositsMetadataSchema = import_zod18.z.object({
-  totalUsdValue: import_zod18.z.number().int().min(0)
+var depositsMetadataSchema = import_zod19.z.object({
+  totalUsdValue: import_zod19.z.number().int().min(0)
 });
-var getDepositsResponseSchema = import_zod18.z.object({
-  deposits: import_zod18.z.array(depositResponseSchema),
+var getDepositsResponseSchema = import_zod19.z.object({
+  deposits: import_zod19.z.array(depositResponseSchema),
   pagination: paginationMetadataSchema.partial(),
   metadata: depositsMetadataSchema
 });
@@ -2610,30 +2624,30 @@ var incentivesQueries = (0, import_query_key_factory18.createQueryKeys)("incenti
 var import_query_key_factory19 = require("@lukemorales/query-key-factory");
 
 // src/v2/liquidity-providers/schema.ts
-var import_zod19 = require("zod");
-var sortBySchema2 = import_zod19.z.enum(["username", "telegram", "total_tvl", "active_tvl", "first_deposit", "wallet_count"]).optional();
-var sortOrderSchema2 = import_zod19.z.enum(["asc", "desc"]).optional();
-var getLiquidityProvidersInputSchema = import_zod19.z.object({
-  organizationId: import_zod19.z.string().uuid().optional(),
-  productId: import_zod19.z.string().uuid().optional(),
-  opportunityId: import_zod19.z.string().uuid().optional(),
+var import_zod20 = require("zod");
+var sortBySchema2 = import_zod20.z.enum(["username", "telegram", "total_tvl", "active_tvl", "first_deposit", "wallet_count"]).optional();
+var sortOrderSchema2 = import_zod20.z.enum(["asc", "desc"]).optional();
+var getLiquidityProvidersInputSchema = import_zod20.z.object({
+  organizationId: import_zod20.z.string().uuid().optional(),
+  productId: import_zod20.z.string().uuid().optional(),
+  opportunityId: import_zod20.z.string().uuid().optional(),
   sortBy: sortBySchema2,
   sortOrder: sortOrderSchema2,
-  limit: import_zod19.z.number().int().min(1).max(100).optional().default(20),
-  offset: import_zod19.z.number().int().min(0).optional().default(0)
-});
-var liquidityProviderSchema = import_zod19.z.object({
-  username: import_zod19.z.string(),
-  totalTvl: import_zod19.z.number(),
-  activeTvl: import_zod19.z.number(),
-  opportunities: import_zod19.z.array(import_zod19.z.string().uuid()),
-  telegram: import_zod19.z.string(),
-  firstDeposit: import_zod19.z.string().datetime(),
+  limit: import_zod20.z.number().int().min(1).max(100).optional().default(20),
+  offset: import_zod20.z.number().int().min(0).optional().default(0)
+});
+var liquidityProviderSchema = import_zod20.z.object({
+  username: import_zod20.z.string(),
+  totalTvl: import_zod20.z.number(),
+  activeTvl: import_zod20.z.number(),
+  opportunities: import_zod20.z.array(import_zod20.z.string().uuid()),
+  telegram: import_zod20.z.string(),
+  firstDeposit: import_zod20.z.string().datetime(),
   // ISO 8601 format (time.Time in Go)
-  walletCount: import_zod19.z.number().int()
+  walletCount: import_zod20.z.number().int()
 });
-var GetLiquidityProvidersResponseSchema = import_zod19.z.object({
-  liquidityProviders: import_zod19.z.array(liquidityProviderSchema),
+var GetLiquidityProvidersResponseSchema = import_zod20.z.object({
+  liquidityProviders: import_zod20.z.array(liquidityProviderSchema),
   pagination: paginationMetadataSchema
 });
 
@@ -2676,9 +2690,9 @@ var liquidityProvidersQueries = (0, import_query_key_factory19.createQueryKeys)(
 var import_query_key_factory20 = require("@lukemorales/query-key-factory");
 
 // src/v2/geocheck/schema.ts
-var import_zod20 = require("zod");
-var geoCheckResponseSchema = import_zod20.z.object({
-  canInteract: import_zod20.z.boolean()
+var import_zod21 = require("zod");
+var geoCheckResponseSchema = import_zod21.z.object({
+  canInteract: import_zod21.z.boolean()
 });
 
 // src/v2/geocheck/api.ts
@@ -2704,6 +2718,118 @@ var geocheckQueries = (0, import_query_key_factory20.createQueryKeys)("geocheck"
   }
 });
 
+// src/v2/org-leaderboard/queries.ts
+var import_query_key_factory21 = require("@lukemorales/query-key-factory");
+
+// src/v2/org-leaderboard/schema.ts
+var import_zod22 = require("zod");
+var orgLeaderboardSortBySchema = import_zod22.z.enum([
+  "rank",
+  "points",
+  "username",
+  "referredValue",
+  "userTvl",
+  "dailyPoints"
+]);
+var orgLeaderboardSortOrderSchema = import_zod22.z.enum(["asc", "desc"]);
+var getOrgLeaderboardParamsSchema = import_zod22.z.object({
+  limit: import_zod22.z.number().int().min(1).max(100).optional().default(20),
+  offset: import_zod22.z.number().int().min(0).optional().default(0),
+  searchUsername: import_zod22.z.string().optional(),
+  onlyWithReferral: import_zod22.z.boolean().optional(),
+  minTotalPoints: import_zod22.z.number().optional(),
+  maxTotalPoints: import_zod22.z.number().optional(),
+  sortBy: orgLeaderboardSortBySchema.optional(),
+  sortOrder: orgLeaderboardSortOrderSchema.optional(),
+  date: import_zod22.z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional()
+  // YYYY-MM-DD for historical daily points
+});
+var orgLeaderboardRowSchema = import_zod22.z.object({
+  rank: import_zod22.z.number(),
+  userId: import_zod22.z.string(),
+  turtleUser: import_zod22.z.object({
+    username: import_zod22.z.string().optional(),
+    avatarUrl: import_zod22.z.string().optional()
+  }).optional(),
+  totalPoints: import_zod22.z.number(),
+  userTvl: import_zod22.z.number(),
+  dailyPoints: import_zod22.z.number(),
+  referredValue: import_zod22.z.number()
+});
+var orgLeaderboardResponseSchema = import_zod22.z.object({
+  rows: import_zod22.z.array(orgLeaderboardRowSchema),
+  total: import_zod22.z.number().optional(),
+  totalPages: import_zod22.z.number().optional()
+});
+var orgUserLeaderboardInfoSchema = import_zod22.z.object({
+  userId: import_zod22.z.string(),
+  username: import_zod22.z.string().optional(),
+  rank: import_zod22.z.number(),
+  totalUsers: import_zod22.z.number(),
+  totalPoints: import_zod22.z.number(),
+  userTvl: import_zod22.z.number(),
+  dailyPoints: import_zod22.z.number(),
+  referredValue: import_zod22.z.number(),
+  referralBoostApplied: import_zod22.z.number().optional()
+});
+var orgUserLeaderboardResponseSchema = import_zod22.z.object({
+  userInfo: orgUserLeaderboardInfoSchema.optional()
+});
+
+// src/v2/org-leaderboard/api.ts
+async function getOrgLeaderboard(orgId, params, options) {
+  const searchParams = new URLSearchParams();
+  if (params?.limit !== void 0) searchParams.set("limit", String(params.limit));
+  if (params?.offset !== void 0) searchParams.set("offset", String(params.offset));
+  if (params?.searchUsername) searchParams.set("searchUsername", params.searchUsername);
+  if (params?.onlyWithReferral !== void 0)
+    searchParams.set("onlyWithReferral", String(params.onlyWithReferral));
+  if (params?.minTotalPoints !== void 0)
+    searchParams.set("minTotalPoints", String(params.minTotalPoints));
+  if (params?.maxTotalPoints !== void 0)
+    searchParams.set("maxTotalPoints", String(params.maxTotalPoints));
+  if (params?.sortBy) searchParams.set("sortBy", params.sortBy);
+  if (params?.sortOrder) searchParams.set("sortOrder", params.sortOrder);
+  if (params?.date) searchParams.set("date", params.date);
+  const query = searchParams.toString();
+  const endpoint = `/turtle/leaderboard/organization/${orgId}${query ? `?${query}` : ""}`;
+  const data = await apiClient.fetch(endpoint, {
+    method: "GET",
+    signal: options?.signal
+  });
+  const result = orgLeaderboardResponseSchema.safeParse(data);
+  if (!result.success) {
+    console.error("[org-leaderboard] list parse error", result.error);
+    throw new Error(`Failed to parse org leaderboard response: ${result.error.message}`);
+  }
+  return result.data;
+}
+async function getOrgUserLeaderboard(orgId, userId, options) {
+  const endpoint = `/turtle/leaderboard/organization/${orgId}/user/${userId}`;
+  const data = await apiClient.fetch(endpoint, {
+    method: "GET",
+    signal: options?.signal
+  });
+  const result = orgUserLeaderboardResponseSchema.safeParse(data);
+  if (!result.success) {
+    console.error("[org-leaderboard] user parse error", result.error);
+    throw new Error(`Failed to parse org user leaderboard response: ${result.error.message}`);
+  }
+  return result.data;
+}
+
+// src/v2/org-leaderboard/queries.ts
+var orgLeaderboardQueries = (0, import_query_key_factory21.createQueryKeys)("orgLeaderboard", {
+  list: (orgId, params) => ({
+    queryKey: [orgId, params],
+    queryFn: ({ signal }) => getOrgLeaderboard(orgId, params, { signal })
+  }),
+  user: (orgId, userId) => ({
+    queryKey: [orgId, userId],
+    queryFn: ({ signal }) => getOrgUserLeaderboard(orgId, userId, { signal })
+  })
+});
+
 // src/v2/earn-opportunities/hooks.ts
 var import_react_query6 = require("@tanstack/react-query");
 function useEarnOpportunities() {
@@ -3044,45 +3170,45 @@ var import_react_query10 = require("@tanstack/react-query");
 var import_react_query9 = require("@tanstack/react-query");
 
 // src/v2/earn-actions/schema.ts
-var import_zod21 = require("zod");
-var transactionSchema = import_zod21.z.object({
-  chainId: import_zod21.z.number().int(),
-  data: import_zod21.z.string(),
-  to: import_zod21.z.string(),
-  value: import_zod21.z.string(),
-  gasLimit: import_zod21.z.string().optional()
-});
-var routeTokenSchema = import_zod21.z.object({
-  address: import_zod21.z.string(),
-  symbol: import_zod21.z.string(),
-  decimals: import_zod21.z.number().int(),
-  logoUrl: import_zod21.z.string()
-});
-var routeStepSchema = import_zod21.z.object({
-  action: import_zod21.z.string(),
+var import_zod23 = require("zod");
+var transactionSchema = import_zod23.z.object({
+  chainId: import_zod23.z.number().int(),
+  data: import_zod23.z.string(),
+  to: import_zod23.z.string(),
+  value: import_zod23.z.string(),
+  gasLimit: import_zod23.z.string().optional()
+});
+var routeTokenSchema = import_zod23.z.object({
+  address: import_zod23.z.string(),
+  symbol: import_zod23.z.string(),
+  decimals: import_zod23.z.number().int(),
+  logoUrl: import_zod23.z.string()
+});
+var routeStepSchema = import_zod23.z.object({
+  action: import_zod23.z.string(),
   from: routeTokenSchema,
   to: routeTokenSchema
 });
-var routeMetadataSchema = import_zod21.z.object({
-  provider: import_zod21.z.string(),
-  providerImg: import_zod21.z.string(),
-  amountOut: import_zod21.z.string(),
-  gas: import_zod21.z.string(),
-  route: import_zod21.z.array(routeStepSchema)
+var routeMetadataSchema = import_zod23.z.object({
+  provider: import_zod23.z.string(),
+  providerImg: import_zod23.z.string(),
+  amountOut: import_zod23.z.string(),
+  gas: import_zod23.z.string(),
+  route: import_zod23.z.array(routeStepSchema)
 });
-var txResponseItemSchema = import_zod21.z.object({
-  type: import_zod21.z.string().optional(),
-  description: import_zod21.z.string().optional(),
+var txResponseItemSchema = import_zod23.z.object({
+  type: import_zod23.z.string().optional(),
+  description: import_zod23.z.string().optional(),
   transaction: transactionSchema,
   metadata: routeMetadataSchema.optional()
 });
-var actionResponseSchema = import_zod21.z.object({
-  actionId: import_zod21.z.string().uuid().optional(),
-  transactions: import_zod21.z.array(txResponseItemSchema).nullable()
+var actionResponseSchema = import_zod23.z.object({
+  actionId: import_zod23.z.string().uuid().optional(),
+  transactions: import_zod23.z.array(txResponseItemSchema).nullable()
 });
-var attributeActionResponseSchema = import_zod21.z.object({
-  success: import_zod21.z.boolean(),
-  message: import_zod21.z.string().optional()
+var attributeActionResponseSchema = import_zod23.z.object({
+  success: import_zod23.z.boolean(),
+  message: import_zod23.z.string().optional()
 });
 
 // src/v2/earn-actions/api.ts
@@ -4588,15 +4714,15 @@ function useUploadIncentiveIcon(options) {
 var import_react_query22 = require("@tanstack/react-query");
 
 // src/v2/distributors/schema.ts
-var import_zod22 = require("zod");
-var updateDistributorEarnDetailsInputSchema = import_zod22.z.object({
-  organizationId: import_zod22.z.string().uuid(),
-  distributorId: import_zod22.z.string().uuid(),
-  earnDetails: import_zod22.z.any()
+var import_zod24 = require("zod");
+var updateDistributorEarnDetailsInputSchema = import_zod24.z.object({
+  organizationId: import_zod24.z.string().uuid(),
+  distributorId: import_zod24.z.string().uuid(),
+  earnDetails: import_zod24.z.any()
   // JSONB value - using any for now as requested
 });
-var updateDistributorEarnDetailsResponseSchema = import_zod22.z.object({
-  success: import_zod22.z.boolean()
+var updateDistributorEarnDetailsResponseSchema = import_zod24.z.object({
+  success: import_zod24.z.boolean()
 });
 
 // src/v2/distributors/api.ts
@@ -4633,6 +4759,49 @@ function useLiquidityProviders({ input, enabled = true }) {
   });
 }
 
+// src/v2/org-leaderboard/hooks.ts
+var import_react_query24 = require("@tanstack/react-query");
+var orgLeaderboardCache = {
+  staleTime: 5 * 60 * 1e3,
+  // 5 minutes
+  gcTime: 10 * 60 * 1e3
+  // 10 minutes
+};
+function useOrgLeaderboard({
+  orgId,
+  params,
+  enabled = true
+}) {
+  const query = (0, import_react_query24.useQuery)({
+    ...orgLeaderboardQueries.list(orgId, params),
+    ...queryDefaults,
+    ...orgLeaderboardCache,
+    enabled: enabled && !!orgId
+  });
+  return {
+    ...query,
+    rows: query.data?.rows ?? [],
+    total: query.data?.total,
+    totalPages: query.data?.totalPages
+  };
+}
+function useOrgUserLeaderboard({
+  orgId,
+  userId,
+  enabled = true
+}) {
+  const query = (0, import_react_query24.useQuery)({
+    ...orgLeaderboardQueries.user(orgId, userId),
+    ...queryDefaults,
+    ...orgLeaderboardCache,
+    enabled: enabled && !!orgId && !!userId
+  });
+  return {
+    ...query,
+    userInfo: query.data?.userInfo
+  };
+}
+
 // src/v2/lib/turtle-provider.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
 function TurtleHooksProvider({
@@ -4648,7 +4817,7 @@ function TurtleHooksProvider({
 }
 
 // src/v2/index.ts
-var queries = (0, import_query_key_factory21.mergeQueryKeys)(
+var queries = (0, import_query_key_factory22.mergeQueryKeys)(
   opportunitiesQueries,
   earnOpportunitiesQueries,
   earnRouteQueries,
@@ -4668,7 +4837,8 @@ var queries = (0, import_query_key_factory21.mergeQueryKeys)(
   depositsQueries,
   incentivesQueries,
   liquidityProvidersQueries,
-  geocheckQueries
+  geocheckQueries,
+  orgLeaderboardQueries
 );
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -4760,6 +4930,9 @@ var queries = (0, import_query_key_factory21.mergeQueryKeys)(
   getOpportunitiesPaginatedSchema,
   getOpportunityById,
   getOpportunityByIdInputSchema,
+  getOrgLeaderboard,
+  getOrgLeaderboardParamsSchema,
+  getOrgUserLeaderboard,
   getPortfolioBalance,
   getProduct,
   getProducts,
@@ -4803,9 +4976,15 @@ var queries = (0, import_query_key_factory21.mergeQueryKeys)(
   opportunitiesResponseSchema,
   opportunityFiltersSchema,
   opportunitySchema,
+  orgLeaderboardQueries,
+  orgLeaderboardResponseSchema,
+  orgLeaderboardRowSchema,
+  orgLeaderboardSortBySchema,
+  orgLeaderboardSortOrderSchema,
+  orgUserLeaderboardInfoSchema,
+  orgUserLeaderboardResponseSchema,
   organizationSchema,
   organizationsMutations,
-  paginationMetadataSchema,
   paginationSchema,
   portfolioBalanceResponseSchema,
   portfolioHoldingsSchema,
@@ -4905,6 +5084,8 @@ var queries = (0, import_query_key_factory21.mergeQueryKeys)(
   useOpportunitiesFilterOptions,
   useOpportunitiesPaginated,
   useOpportunity,
+  useOrgLeaderboard,
+  useOrgUserLeaderboard,
   usePortfolioBalance,
   useProduct,
   useProducts,