@turtleclub/hooks 0.5.0-beta.60 → 0.5.0-beta.62

package/dist/index.cjs

@@ -184,6 +184,8 @@ __export(index_exports, {
   streamsQueries: () => streamsQueries,
   submitCoverRequest: () => submitCoverRequest,
   submitCoverRequestResponseSchema: () => submitCoverRequestResponseSchema,
+  supportedChainEcosystemSchema: () => supportedChainEcosystemSchema,
+  supportedChainStatusSchema: () => supportedChainStatusSchema,
   supportedChainsQueries: () => supportedChainsQueries,
   supportedChainsResponseSchema: () => supportedChainsResponseSchema,
   supportedTokenSchema: () => supportedTokenSchema,
@@ -288,7 +290,7 @@ module.exports = __toCommonJS(index_exports);
 var import_query_key_factory21 = require("@lukemorales/query-key-factory");
 
 // src/v2/opportunities/queries.ts
-var import_query_key_factory3 = require("@lukemorales/query-key-factory");
+var import_query_key_factory4 = require("@lukemorales/query-key-factory");
 
 // src/v2/lib/api-client.ts
 var API_BASE_URL = "https://api.turtle.xyz";
@@ -380,7 +382,7 @@ var ApiClient = class _ApiClient {
 var apiClient = ApiClient.getInstance();
 
 // src/v2/opportunities/schema.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 
 // src/v2/supported-tokens/schema.ts
 var import_zod4 = require("zod");
@@ -487,15 +489,18 @@ var paginationMetadataSchema = import_zod2.z.object({
 });
 
 // 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(),
+  id: import_zod3.z.string(),
   name: import_zod3.z.string(),
-  slug: import_zod3.z.string().optional(),
+  slug: import_zod3.z.string(),
   chainId: import_zod3.z.string(),
-  logoUrl: import_zod3.z.string().optional(),
-  ecosystem: import_zod3.z.string().optional(),
-  status: import_zod3.z.string().optional(),
-  explorerUrl: import_zod3.z.string().optional()
+  isTestnet: import_zod3.z.boolean(),
+  logoUrl: import_zod3.z.string(),
+  ecosystem: supportedChainEcosystemSchema,
+  status: supportedChainStatusSchema,
+  explorerUrl: import_zod3.z.string()
 });
 var getSupportedChainsInputSchema = import_zod3.z.object({
   page: import_zod3.z.number().min(1).default(1).optional(),
@@ -603,22 +608,23 @@ function useSupportedChains(options) {
 }
 
 // src/v2/supported-tokens/schema.ts
+var uuidSchema = import_zod4.z.string().uuid();
 var tokenSchema = import_zod4.z.object({
-  id: import_zod4.z.string().optional(),
+  id: uuidSchema,
+  address: import_zod4.z.string(),
   name: import_zod4.z.string(),
   symbol: import_zod4.z.string(),
-  address: import_zod4.z.string(),
-  chain: chainSchema,
-  decimals: import_zod4.z.number(),
-  logoUrl: import_zod4.z.string().optional(),
+  decimals: import_zod4.z.number().int().nonnegative(),
   isNative: import_zod4.z.boolean(),
-  priceUsd: import_zod4.z.number().optional(),
-  price: import_zod4.z.string().optional(),
-  amount: import_zod4.z.string().optional(),
-  rawAmount: import_zod4.z.string().optional()
+  logoUrl: import_zod4.z.string(),
+  chain: chainSchema,
+  priceUsd: import_zod4.z.number(),
+  canonicalAssetId: uuidSchema,
+  streamsMinAmount: import_zod4.z.string().nullable(),
+  totalTurtleTvl: import_zod4.z.number()
 });
 var supportedTokenSchema = tokenSchema.extend({
-  active: import_zod4.z.boolean().optional()
+  active: import_zod4.z.boolean()
 });
 var supportedTokensResponseSchema = import_zod4.z.object({
   tokens: import_zod4.z.array(supportedTokenSchema),
@@ -821,61 +827,481 @@ var productFiltersSchema = import_zod6.z.object({
   organizationId: import_zod6.z.string().uuid().optional()
 });
 
-// src/v2/opportunities/schema.ts
-var opportunityTypeEnum = import_zod7.z.enum(["vault", "lending", "staking", "stablecoin", "draft", ""]);
-var opportunityStatusEnum = import_zod7.z.enum(["active", "paused", "deprecated", "draft", "ended"]);
-var opportunitySchema = import_zod7.z.object({
-  id: import_zod7.z.string().uuid().optional(),
+// src/v2/streams/hooks.ts
+var import_react_query4 = require("@tanstack/react-query");
+
+// src/v2/streams/queries.ts
+var import_query_key_factory3 = require("@lukemorales/query-key-factory");
+
+// src/v2/streams/schemas.ts
+var import_zod7 = require("zod");
+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(),
+  tvl: import_zod7.z.string().nullable().optional(),
+  baseTvl: import_zod7.z.string().nullable().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(),
-  shortName: 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(),
+  organization: organizationSchema.nullable().optional()
+});
+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 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(),
+  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()
+}).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 feeTierSchema = import_zod7.z.object({
+  maxTVL: import_zod7.z.string().nullable(),
+  // represents a USD amount
+  feePct: import_zod7.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 feeSnapshotSchema = import_zod7.z.object({
+  timestamp: import_zod7.z.string().datetime(),
+  tvl: import_zod7.z.string().nullable(),
+  // means USD amount
+  accumulatedFee: import_zod7.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(),
+  lastFeeSnapshot: feeSnapshotSchema.nullable()
+});
+var streamSchema = import_zod7.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(),
+  contractAddress: import_zod7.z.string().nullable(),
+  createdAt: import_zod7.z.string().datetime(),
+  creationConfirmedAt: import_zod7.z.string().datetime().nullable(),
+  customArgs: import_zod7.z.union([
+    customArgsTokensPerUsdSchema,
+    customArgsAprSchema,
+    customArgsTokensPerDaySchema
+  ]),
+  endTimestamp: import_zod7.z.string().datetime().nullable(),
+  fee: feeSchema.nullable(),
+  hashCommitmentPaused: import_zod7.z.boolean(),
+  id: import_zod7.z.string().uuid(),
+  lastSnapshot: snapshotSchema.nullable(),
+  merkleTreeComputationPaused: import_zod7.z.boolean(),
+  orgId: import_zod7.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(),
+  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({
+  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()
+      // Address as string
+    })
+  )
+});
+var streamSignatureRequestInputSchema = import_zod7.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()
+    }),
+    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() })
+    ])
+  ),
+  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()
+      }),
+      signature: import_zod7.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(),
+  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(),
+  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 getStreamWalletsResponseSchema = import_zod7.z.object({
+  data: import_zod7.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 streamWalletDetailsSchema = import_zod7.z.object({
+  streamId: import_zod7.z.string(),
+  userAddress: import_zod7.z.string(),
+  snapshots: import_zod7.z.array(streamWalletSnapshotSchema),
+  stream: streamSchema
+});
+var getStreamWalletDetailsResponseSchema = import_zod7.z.object({
+  wallet: streamWalletDetailsSchema
+});
+
+// src/v2/streams/api.ts
+async function getStreams(query) {
+  const params = new URLSearchParams();
+  if (query?.streamId) params.set("id", query.streamId);
+  if (query?.userId) params.set("userId", query.userId);
+  if (query?.organizationId) params.set("organizationId", query.organizationId);
+  if (query?.withSnapshots) params.append("withSnapshots", "true");
+  if (query?.usersCount && query?.withSnapshots) params.append("usersCount", "true");
+  const queryString = params.toString();
+  const endpoint = `/streams${queryString ? `?${queryString}` : ""}`;
+  const data = await apiClient.fetch(endpoint, { method: "GET" });
+  const result = getStreamsOutputSchema.safeParse(data);
+  if (!result.success) {
+    console.error(
+      "Zod Validation Error in getStreams:",
+      JSON.stringify(result.error.format(), null, 2)
+    );
+    throw new Error(`Failed to parse streams: ${result.error.message}`);
+  }
+  return result.data.streams;
+}
+async function getStreamPoints(query) {
+  const params = new URLSearchParams();
+  if (query?.id) params.set("id", query.id);
+  if (query?.organizationId) params.set("organizationId", query.organizationId);
+  if (query?.symbol) params.set("symbol", query.symbol);
+  if (query?.name) params.set("name", query.name);
+  const queryString = params.toString();
+  const endpoint = `/streams/points${queryString ? `?${queryString}` : ""}`;
+  const data = await apiClient.fetch(endpoint, { method: "GET" });
+  const result = getStreamPointsOutputSchema.safeParse(data);
+  if (!result.success) {
+    console.error(
+      "Zod Validation Error in getStreamPoints:",
+      JSON.stringify(result.error.format(), null, 2)
+    );
+    throw new Error(`Failed to parse stream points: ${result.error.message}`);
+  }
+  return result.data.points;
+}
+async function createStreamPoint(organizationId, body) {
+  const endpoint = `/streams/points/${organizationId}`;
+  const data = await apiClient.fetch(endpoint, {
+    method: "POST",
+    body
+  });
+  const result = createStreamPointOutputSchema.safeParse(data);
+  if (!result.success) {
+    throw new Error(`Failed to parse create point response: ${result.error.message}`);
+  }
+  return result.data;
+}
+async function getStreamWallets(query) {
+  const params = new URLSearchParams();
+  if (query?.page) params.set("page", query.page.toString());
+  if (query?.limit) params.set("limit", query.limit.toString());
+  const queryString = params.toString();
+  const endpoint = `/streams/${query.streamId}/wallets/${queryString ? `?${queryString}` : ""}`;
+  const data = await apiClient.fetch(endpoint, { method: "GET" });
+  const result = getStreamWalletsResponseSchema.safeParse(data);
+  if (!result.success) {
+    console.error(
+      "Zod Validation Error in getStreamWallets:",
+      JSON.stringify(result.error.format(), null, 2)
+    );
+    throw new Error(`Failed to parse stream wallets: ${result.error.message}`);
+  }
+  return result.data;
+}
+async function getStreamWalletDetails(streamId, userAddress) {
+  const endpoint = `/streams/${streamId}/wallets/${userAddress}`;
+  const data = await apiClient.fetch(endpoint, { method: "GET" });
+  const result = getStreamWalletDetailsResponseSchema.safeParse(data);
+  if (!result.success) {
+    console.error(
+      "Zod Validation Error in getStreamWalletDetails:",
+      JSON.stringify(result.error.format(), null, 2)
+    );
+    throw new Error(`Failed to parse stream wallet details: ${result.error.message}`);
+  }
+  return result.data.wallet;
+}
+async function getStreamsSupportedChains() {
+  const endpoint = "/streams/supported_chains";
+  const data = await apiClient.fetch(endpoint, { method: "GET" });
+  const result = getStreamsSupportedChainsOutputSchema.safeParse(data);
+  if (!result.success) {
+    throw new Error(`Failed to parse supported chains: ${result.error.message}`);
+  }
+  return result.data.chains;
+}
+async function requestStreamSignature(organizationId, input) {
+  const endpoint = `/streams/create/${organizationId}`;
+  const data = await apiClient.fetch(endpoint, {
+    method: "POST",
+    body: input
+  });
+  const result = streamSignatureRequestOutputSchema.safeParse(data);
+  if (!result.success) {
+    throw new Error(`Failed to parse signature response: ${result.error.message}`);
+  }
+  return result.data;
+}
+
+// src/v2/streams/queries.ts
+var streamsQueries = (0, import_query_key_factory3.createQueryKeys)("streams", {
+  list: (query) => ({
+    queryKey: [query ?? "all"],
+    queryFn: () => getStreams(query)
+  }),
+  points: (query) => ({
+    queryKey: [query ?? "all"],
+    queryFn: () => getStreamPoints(query)
+  }),
+  wallets: (query) => ({
+    queryKey: [query],
+    queryFn: () => getStreamWallets(query)
+  }),
+  walletDetails: (query) => ({
+    queryKey: [query],
+    queryFn: () => getStreamWalletDetails(query.streamId, query.userAddress)
+  }),
+  supportedChains: {
+    queryKey: null,
+    queryFn: () => getStreamsSupportedChains()
+  }
+});
+
+// src/v2/streams/hooks.ts
+function useStreams({
+  query,
+  options
+} = {}) {
+  return (0, import_react_query4.useQuery)(createQueryOptions(streamsQueries.list(query), options));
+}
+function useStreamPoints({
+  query,
+  options
+} = {}) {
+  return (0, import_react_query4.useQuery)(createQueryOptions(streamsQueries.points(query), options));
+}
+function useStreamWallets({
+  query,
+  options
+}) {
+  return (0, import_react_query4.useQuery)(createQueryOptions(streamsQueries.wallets(query), options));
+}
+function useStreamWalletDetails({
+  query,
+  options
+}) {
+  return (0, import_react_query4.useQuery)(createQueryOptions(streamsQueries.walletDetails(query), options));
+}
+function useStreamSupportedChains({
+  options
+} = {}) {
+  return (0, import_react_query4.useQuery)(createQueryOptions(streamsQueries.supportedChains, options));
+}
+
+// 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(),
   type: opportunityTypeEnum,
-  description: import_zod7.z.string().optional().default(""),
-  curator: import_zod7.z.string().optional().default(""),
-  tvl: import_zod7.z.number().min(0, "TVL must be positive"),
-  featured: import_zod7.z.boolean().optional().default(false),
-  featuredOrder: import_zod7.z.number().int().optional().nullable(),
-  originalConfig: import_zod7.z.any().optional().nullable(),
-  exposures: import_zod7.z.array(import_zod7.z.string()).optional().default([]),
+  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([]),
   status: opportunityStatusEnum.optional().default("active"),
-  statusReason: import_zod7.z.string().optional().default(""),
-  depositDisabled: import_zod7.z.boolean().optional().default(false),
-  depositDisabledReason: import_zod7.z.string().optional().default(""),
-  withdrawalDisabled: import_zod7.z.boolean().optional().default(false),
-  withdrawalDisabledReason: import_zod7.z.string().optional().default(""),
-  docsUrl: import_zod7.z.string().optional().nullable(),
-  auditsUrl: import_zod7.z.string().optional().nullable(),
-  turtleTvl: import_zod7.z.number(),
-  turtleUsers: import_zod7.z.number(),
-  earnEnabled: import_zod7.z.boolean(),
-  createdAt: import_zod7.z.string().datetime().optional(),
-  updatedAt: import_zod7.z.string().datetime().optional(),
+  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(),
+  createdAt: import_zod8.z.string().datetime().optional(),
+  updatedAt: import_zod8.z.string().datetime().optional(),
+  mainStreamId: import_zod8.z.string().optional(),
   // Relationships
-  depositTokens: import_zod7.z.array(supportedTokenSchema),
-  withdrawTokens: import_zod7.z.array(supportedTokenSchema).optional().default([]),
+  depositTokens: import_zod8.z.array(supportedTokenSchema),
+  withdrawTokens: import_zod8.z.array(supportedTokenSchema).optional().default([]),
   baseTokens: supportedTokenSchema,
   receiptToken: supportedTokenSchema,
-  incentives: import_zod7.z.array(incentiveSchema),
-  products: import_zod7.z.array(productSchema),
+  incentives: import_zod8.z.array(incentiveSchema),
+  products: import_zod8.z.array(productSchema),
   vaultConfig: vaultConfigSchema.optional().nullable(),
   lendingConfig: lendingConfigSchema.optional().nullable(),
+  mainStream: streamSchema.optional().nullable(),
   // Will be deprecated
-  exposure: import_zod7.z.array(import_zod7.z.string()),
-  explorerUrl: import_zod7.z.string().nullable()
+  exposure: import_zod8.z.array(import_zod8.z.string()),
+  explorerUrl: import_zod8.z.string().nullable()
 });
-var opportunityFiltersSchema = import_zod7.z.object({
-  tokenId: import_zod7.z.string().uuid().optional(),
-  chain: import_zod7.z.string().optional(),
-  productId: import_zod7.z.string().uuid().optional()
+var 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()
 });
-var opportunitiesResponseSchema = import_zod7.z.object({
-  opportunities: import_zod7.z.array(opportunitySchema),
-  total: import_zod7.z.number().optional()
+var opportunitiesResponseSchema = import_zod8.z.object({
+  opportunities: import_zod8.z.array(opportunitySchema),
+  total: import_zod8.z.number().optional()
 });
-var getOpportunitiesPaginatedInputSchema = import_zod7.z.object({
-  page: import_zod7.z.number().min(1).default(1),
-  limit: import_zod7.z.number().min(1).max(100).default(10),
+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),
   // Sorting
-  sortBy: import_zod7.z.enum([
+  sortBy: import_zod8.z.enum([
     "turtleTvl",
     "tvl",
     "name",
@@ -886,101 +1312,101 @@ var getOpportunitiesPaginatedInputSchema = import_zod7.z.object({
     "provider",
     "apr"
   ]).optional(),
-  sortOrder: import_zod7.z.enum(["asc", "desc"]).optional(),
+  sortOrder: import_zod8.z.enum(["asc", "desc"]).optional(),
   // Filter by receipt token chain (comma-separated)
-  receiptTokenChainId: import_zod7.z.string().optional(),
+  receiptTokenChainId: import_zod8.z.string().optional(),
   // Comma-separated UUIDs
-  receiptTokenChainSlug: import_zod7.z.string().optional(),
+  receiptTokenChainSlug: import_zod8.z.string().optional(),
   // Comma-separated slugs
   // Filter by deposit token
-  depositTokenGroup: import_zod7.z.string().optional(),
-  depositTokenSymbols: import_zod7.z.string().optional(),
+  depositTokenGroup: import_zod8.z.string().optional(),
+  depositTokenSymbols: import_zod8.z.string().optional(),
   // Comma-separated symbols
-  depositTokenChainId: import_zod7.z.string().optional(),
+  depositTokenChainId: import_zod8.z.string().optional(),
   // Filter by tags (comma-separated)
-  tags: import_zod7.z.string().optional(),
+  tags: import_zod8.z.string().optional(),
   // Filter by IDs (comma-separated UUIDs)
-  productId: import_zod7.z.string().optional(),
+  productId: import_zod8.z.string().optional(),
   // Comma-separated UUIDs
-  curatorId: import_zod7.z.string().optional(),
+  curatorId: import_zod8.z.string().optional(),
   // Comma-separated UUIDs
-  providerId: import_zod7.z.string().optional(),
+  providerId: import_zod8.z.string().optional(),
   // Comma-separated UUIDs
-  partnerId: import_zod7.z.string().optional(),
+  partnerId: import_zod8.z.string().optional(),
   // Comma-separated UUIDs
-  lendingProtocolId: import_zod7.z.string().optional(),
+  lendingProtocolId: import_zod8.z.string().optional(),
   // Comma-separated UUIDs
   // Status filters
-  withdrawalDisabled: import_zod7.z.boolean().optional(),
-  depositDisabled: import_zod7.z.boolean().optional(),
-  status: import_zod7.z.string().optional(),
-  earnEnabled: import_zod7.z.boolean().optional(),
-  featured: import_zod7.z.boolean().optional(),
+  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(),
   // TVL filters
-  tvlGreaterThan: import_zod7.z.number().optional(),
-  turtleTvlGreaterThan: import_zod7.z.number().optional(),
-  tvlMin: import_zod7.z.number().optional(),
-  tvlMax: import_zod7.z.number().optional(),
+  tvlGreaterThan: import_zod8.z.number().optional(),
+  turtleTvlGreaterThan: import_zod8.z.number().optional(),
+  tvlMin: import_zod8.z.number().optional(),
+  tvlMax: import_zod8.z.number().optional(),
   // APR filters
-  minApr: import_zod7.z.number().optional(),
-  maxApr: import_zod7.z.number().optional(),
+  minApr: import_zod8.z.number().optional(),
+  maxApr: import_zod8.z.number().optional(),
   // Chain IDs (comma-separated)
-  chainIds: import_zod7.z.string().optional(),
+  chainIds: import_zod8.z.string().optional(),
   // Search
-  search: import_zod7.z.string().optional()
+  search: import_zod8.z.string().optional()
 });
-var paginationMetadataSchema2 = import_zod7.z.object({
-  page: import_zod7.z.number(),
-  limit: import_zod7.z.number(),
-  total: import_zod7.z.number(),
-  totalPages: import_zod7.z.number()
+var 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 getOpportunitiesPaginatedSchema = import_zod7.z.object({
-  opportunities: import_zod7.z.array(opportunitySchema),
+var getOpportunitiesPaginatedSchema = import_zod8.z.object({
+  opportunities: import_zod8.z.array(opportunitySchema),
   pagination: paginationMetadataSchema2
 });
-var filterChainSchema = import_zod7.z.object({
-  id: import_zod7.z.string().uuid(),
-  name: import_zod7.z.string(),
-  slug: import_zod7.z.string(),
-  chainId: import_zod7.z.string(),
-  logoUrl: import_zod7.z.string(),
-  ecosystem: import_zod7.z.string(),
-  status: import_zod7.z.string(),
-  explorerUrl: import_zod7.z.string()
-});
-var filterOrganizationSchema = import_zod7.z.object({
-  id: import_zod7.z.string().uuid(),
-  name: import_zod7.z.string(),
-  description: import_zod7.z.string(),
-  landingUrl: import_zod7.z.string(),
-  iconUrl: import_zod7.z.string(),
-  organizationType: import_zod7.z.string(),
-  turtleRefCode: import_zod7.z.string(),
-  twitterHandle: import_zod7.z.string(),
-  status: import_zod7.z.string(),
-  featured: import_zod7.z.boolean()
-});
-var filterTagSchema = import_zod7.z.object({
-  id: import_zod7.z.string().uuid(),
-  code: import_zod7.z.string(),
-  name: import_zod7.z.string(),
-  description: import_zod7.z.string().optional().nullable(),
-  color: import_zod7.z.string().optional().nullable(),
-  type: import_zod7.z.string().optional().nullable()
+var 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 depositTokenSymbolSchema = import_zod7.z.object({
-  symbol: import_zod7.z.string(),
-  logoUrl: import_zod7.z.string()
+var depositTokenSymbolSchema = import_zod8.z.object({
+  symbol: import_zod8.z.string(),
+  logoUrl: import_zod8.z.string()
 });
-var getOpportunitiesFilterOptionsSchema = import_zod7.z.object({
-  chains: import_zod7.z.array(filterChainSchema),
-  providers: import_zod7.z.array(filterOrganizationSchema),
-  curators: import_zod7.z.array(filterOrganizationSchema).optional().nullable(),
-  partners: import_zod7.z.array(filterOrganizationSchema).optional().nullable(),
-  tags: import_zod7.z.array(filterTagSchema).optional().nullable(),
-  lendingProtocols: import_zod7.z.array(filterOrganizationSchema),
-  depositTokenSymbols: import_zod7.z.array(depositTokenSymbolSchema).optional().nullable()
+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()
 });
 
 // src/v2/opportunities/api.ts
@@ -1050,7 +1476,7 @@ async function getOpportunitiesFilterOptions(options) {
 }
 
 // src/v2/opportunities/queries.ts
-var opportunitiesQueries = (0, import_query_key_factory3.createQueryKeys)("opportunities", {
+var opportunitiesQueries = (0, import_query_key_factory4.createQueryKeys)("opportunities", {
   // Get all opportunities (no filters)
   all: {
     queryKey: null,
@@ -1079,25 +1505,25 @@ var opportunitiesQueries = (0, import_query_key_factory3.createQueryKeys)("oppor
 });
 
 // src/v2/earn-opportunities/queries.ts
-var import_query_key_factory4 = require("@lukemorales/query-key-factory");
+var import_query_key_factory5 = require("@lukemorales/query-key-factory");
 
 // src/v2/earn-opportunities/schema.ts
-var import_zod8 = require("zod");
-var earnOpportunitySchema = import_zod8.z.object({
-  id: import_zod8.z.string().uuid(),
-  name: import_zod8.z.string(),
-  description: import_zod8.z.string(),
-  type: import_zod8.z.string(),
-  estimatedApr: import_zod8.z.number(),
-  tvl: import_zod8.z.number(),
-  featured: import_zod8.z.boolean(),
+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(),
   baseTokens: tokenSchema,
-  depositTokens: import_zod8.z.array(tokenSchema).nullable(),
+  depositTokens: import_zod9.z.array(tokenSchema).nullable(),
   receiptToken: tokenSchema
 });
-var earnOpportunitiesResponseSchema = import_zod8.z.object({
-  opportunities: import_zod8.z.array(earnOpportunitySchema).nullable(),
-  total: import_zod8.z.number().int()
+var earnOpportunitiesResponseSchema = import_zod9.z.object({
+  opportunities: import_zod9.z.array(earnOpportunitySchema).nullable(),
+  total: import_zod9.z.number().int()
 });
 
 // src/v2/earn-opportunities/api.ts
@@ -1116,7 +1542,7 @@ async function getEarnOpportunities(context) {
 }
 
 // src/v2/earn-opportunities/queries.ts
-var earnOpportunitiesQueries = (0, import_query_key_factory4.createQueryKeys)("earnOpportunities", {
+var earnOpportunitiesQueries = (0, import_query_key_factory5.createQueryKeys)("earnOpportunities", {
   all: {
     queryKey: null,
     queryFn: (context) => getEarnOpportunities(context)
@@ -1124,86 +1550,86 @@ var earnOpportunitiesQueries = (0, import_query_key_factory4.createQueryKeys)("e
 });
 
 // src/v2/earn-route/queries.ts
-var import_query_key_factory5 = require("@lukemorales/query-key-factory");
+var import_query_key_factory6 = require("@lukemorales/query-key-factory");
 
 // src/v2/earn-route/schema.ts
 var import_utils = require("@turtleclub/utils");
-var import_zod9 = require("zod");
-var assetImageData = import_zod9.z.object({
-  kind: import_zod9.z.literal("image"),
-  url: import_zod9.z.string(),
-  alt: import_zod9.z.string()
-});
-var assetERC20Data = import_zod9.z.object({
-  kind: import_zod9.z.literal("erc20"),
-  address: import_zod9.z.string(),
-  name: import_zod9.z.string(),
-  symbol: import_zod9.z.string(),
-  decimals: import_zod9.z.number()
-});
-var assetData = import_zod9.z.discriminatedUnion("kind", [assetImageData, assetERC20Data]);
-var asset = import_zod9.z.object({
-  id: import_zod9.z.string().uuid(),
-  name: import_zod9.z.string(),
-  slugs: import_zod9.z.array(import_zod9.z.string()),
-  tags: import_zod9.z.array(import_zod9.z.string()),
-  description: import_zod9.z.string().nullable(),
-  data: import_zod9.z.array(assetData)
+var 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 routeToken = import_zod9.z.object({
-  address: import_zod9.z.string(),
-  name: import_zod9.z.string(),
-  symbol: import_zod9.z.string(),
-  logos: import_zod9.z.array(import_zod9.z.string()),
-  decimals: import_zod9.z.number(),
-  chain: import_zod9.z.number(),
-  price: import_zod9.z.number().nullable().optional()
-});
-var swapSubstep = import_zod9.z.object({
-  kind: import_zod9.z.literal("swap"),
-  from: import_zod9.z.array(routeToken),
-  to: import_zod9.z.array(routeToken),
-  protocol: import_zod9.z.string(),
+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 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(),
   protocol_asset: asset.nullable(),
-  price_impact: import_zod9.z.number().nullable()
-});
-var depositSubstep = import_zod9.z.object({
-  kind: import_zod9.z.literal("deposit"),
-  vault: import_zod9.z.string(),
-  from: import_zod9.z.array(routeToken),
-  to: import_zod9.z.array(routeToken),
-  amount: import_zod9.z.string(),
-  protocol: import_zod9.z.string(),
+  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(),
   protocol_asset: asset.nullable(),
-  price_impact: import_zod9.z.number().nullable()
+  price_impact: import_zod10.z.number().nullable()
 });
-var routerSubstep = import_zod9.z.discriminatedUnion("kind", [swapSubstep, depositSubstep]);
-var stepTx = import_zod9.z.object({
+var routerSubstep = import_zod10.z.discriminatedUnion("kind", [swapSubstep, depositSubstep]);
+var stepTx = import_zod10.z.object({
   from: import_utils.ethz.address(),
   to: import_utils.ethz.address(),
   data: import_utils.ethz.hex(),
-  value: import_zod9.z.string(),
-  gas: import_zod9.z.number()
+  value: import_zod10.z.string(),
+  gas: import_zod10.z.number()
 });
-var approveStep = import_zod9.z.object({
-  kind: import_zod9.z.literal("approve"),
-  owner: import_zod9.z.string(),
-  spender: import_zod9.z.string(),
+var approveStep = import_zod10.z.object({
+  kind: import_zod10.z.literal("approve"),
+  owner: import_zod10.z.string(),
+  spender: import_zod10.z.string(),
   token: routeToken,
-  amount: import_zod9.z.string(),
+  amount: import_zod10.z.string(),
   tx: stepTx
 });
-var ensoStep = import_zod9.z.object({
-  kind: import_zod9.z.literal("enso"),
-  substeps: import_zod9.z.array(routerSubstep),
+var ensoStep = import_zod10.z.object({
+  kind: import_zod10.z.literal("enso"),
+  substeps: import_zod10.z.array(routerSubstep),
   tx: stepTx,
   asset: asset.nullable()
 });
-var routerStep = import_zod9.z.discriminatedUnion("kind", [approveStep, ensoStep]);
-var earnRouteResponseSchema = import_zod9.z.object({
-  steps: import_zod9.z.array(routerStep),
-  amount_out: import_zod9.z.string(),
-  price_impact: import_zod9.z.number().nullable()
+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()
 });
 
 // src/v2/earn-route/api.ts
@@ -1234,7 +1660,7 @@ async function getEarnRoute(params, context) {
 }
 
 // src/v2/earn-route/queries.ts
-var earnRouteQueries = (0, import_query_key_factory5.createQueryKeys)("earnRoute", {
+var earnRouteQueries = (0, import_query_key_factory6.createQueryKeys)("earnRoute", {
   // Get earn route with specific parameters
   byParams: (params) => ({
     queryKey: [params],
@@ -1243,33 +1669,33 @@ var earnRouteQueries = (0, import_query_key_factory5.createQueryKeys)("earnRoute
 });
 
 // src/v2/earn-membership/queries.ts
-var import_query_key_factory6 = require("@lukemorales/query-key-factory");
+var import_query_key_factory7 = require("@lukemorales/query-key-factory");
 
 // src/v2/earn-membership/schema.ts
-var import_zod10 = require("zod");
-var walletEcosystemEnum = import_zod10.z.enum(["evm", "solana", "ton"]);
-var checkMembershipResponseSchema = import_zod10.z.object({
-  isMember: import_zod10.z.boolean()
+var 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 createAgreementRequestSchema = import_zod10.z.object({
-  address: import_zod10.z.string(),
+var createAgreementRequestSchema = import_zod11.z.object({
+  address: import_zod11.z.string(),
   walletEcosystem: walletEcosystemEnum,
-  url: import_zod10.z.string(),
-  chainId: import_zod10.z.string().default("1")
+  url: import_zod11.z.string(),
+  chainId: import_zod11.z.string().default("1")
 });
-var createAgreementResponseSchema = import_zod10.z.object({
-  message: import_zod10.z.string(),
-  nonce: import_zod10.z.string()
+var createAgreementResponseSchema = import_zod11.z.object({
+  message: import_zod11.z.string(),
+  nonce: import_zod11.z.string()
 });
-var createMembershipRequestSchema = import_zod10.z.object({
-  address: import_zod10.z.string(),
-  walletEcosystem: import_zod10.z.string(),
-  signature: import_zod10.z.string(),
-  nonce: import_zod10.z.string()
+var 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 createMembershipResponseSchema = import_zod10.z.object({
-  isMember: import_zod10.z.boolean(),
-  error: import_zod10.z.string().optional()
+var createMembershipResponseSchema = import_zod11.z.object({
+  isMember: import_zod11.z.boolean(),
+  error: import_zod11.z.string().optional()
 });
 
 // src/v2/earn-membership/api.ts
@@ -1318,7 +1744,7 @@ async function createMembership(request) {
 }
 
 // src/v2/earn-membership/queries.ts
-var earnMembershipQueries = (0, import_query_key_factory6.createQueryKeys)("earnMembership", {
+var earnMembershipQueries = (0, import_query_key_factory7.createQueryKeys)("earnMembership", {
   // Check membership status
   check: (params) => ({
     queryKey: [params],
@@ -1327,26 +1753,26 @@ var earnMembershipQueries = (0, import_query_key_factory6.createQueryKeys)("earn
 });
 
 // src/v2/earn-deposits/queries.ts
-var import_query_key_factory7 = require("@lukemorales/query-key-factory");
+var import_query_key_factory8 = require("@lukemorales/query-key-factory");
 
 // src/v2/earn-deposits/schema.ts
-var import_zod11 = require("zod");
-var depositSchema = import_zod11.z.object({
-  chain: import_zod11.z.number().int(),
-  deposited_amount_usd: import_zod11.z.string(),
-  deposited_token_address: import_zod11.z.string(),
-  deposited_token_decimals: import_zod11.z.number().int(),
-  deposited_token_logo: import_zod11.z.string(),
-  deposited_token_name: import_zod11.z.string(),
-  deposited_token_symbol: import_zod11.z.string(),
-  deposited_value: import_zod11.z.string(),
-  depositor: import_zod11.z.string(),
-  target: import_zod11.z.string(),
-  timestamp: import_zod11.z.string(),
-  tx_hash: import_zod11.z.string()
-});
-var depositsResponseSchema = import_zod11.z.object({
-  deposits: import_zod11.z.array(depositSchema).nullable()
+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()
 });
 
 // src/v2/earn-deposits/api.ts
@@ -1373,7 +1799,7 @@ async function getDeposits(params, context) {
 }
 
 // src/v2/earn-deposits/queries.ts
-var earnDepositsQueries = (0, import_query_key_factory7.createQueryKeys)("earnDeposits", {
+var earnDepositsQueries = (0, import_query_key_factory8.createQueryKeys)("earnDeposits", {
   byParams: (params) => ({
     queryKey: [params],
     queryFn: (context) => getDeposits(params, context)
@@ -1381,15 +1807,15 @@ var earnDepositsQueries = (0, import_query_key_factory7.createQueryKeys)("earnDe
 });
 
 // src/v2/earn-actions/queries.ts
-var import_query_key_factory8 = require("@lukemorales/query-key-factory");
-var earnActionsQueries = (0, import_query_key_factory8.createQueryKeys)("earnActions", {
+var import_query_key_factory9 = require("@lukemorales/query-key-factory");
+var earnActionsQueries = (0, import_query_key_factory9.createQueryKeys)("earnActions", {
   // Placeholder for potential future GET endpoints
   // e.g., getting action history
 });
 var earnInteractionsQueries = earnActionsQueries;
 
 // src/v2/products/queries.ts
-var import_query_key_factory9 = require("@lukemorales/query-key-factory");
+var import_query_key_factory10 = require("@lukemorales/query-key-factory");
 
 // src/v2/products/api.ts
 async function getProducts(filters) {
@@ -1476,7 +1902,7 @@ async function uploadProductLogo({
 }
 
 // src/v2/products/queries.ts
-var productsQueries = (0, import_query_key_factory9.createQueryKeys)("products", {
+var productsQueries = (0, import_query_key_factory10.createQueryKeys)("products", {
   // Get all products (no filters)
   all: () => ({
     queryKey: ["all"],
@@ -1493,25 +1919,25 @@ var productsQueries = (0, import_query_key_factory9.createQueryKeys)("products",
 });
 
 // src/v2/enso-balances/queries.ts
-var import_query_key_factory10 = require("@lukemorales/query-key-factory");
+var import_query_key_factory11 = require("@lukemorales/query-key-factory");
 
 // src/v2/enso-balances/schemas.ts
-var import_zod12 = require("zod");
-var balanceTokenSchema = import_zod12.z.object({
-  address: import_zod12.z.string(),
-  name: import_zod12.z.string(),
-  symbol: import_zod12.z.string(),
-  logos: import_zod12.z.array(import_zod12.z.string()),
-  decimals: import_zod12.z.number(),
-  chain: import_zod12.z.number(),
-  price: import_zod12.z.number().nullable().optional()
-});
-var walletBalanceSchema = import_zod12.z.object({
+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({
   token: balanceTokenSchema,
-  amount: import_zod12.z.string()
+  amount: import_zod13.z.string()
 });
-var walletBalancesResponseSchema = import_zod12.z.object({
-  balances: import_zod12.z.array(walletBalanceSchema)
+var walletBalancesResponseSchema = import_zod13.z.object({
+  balances: import_zod13.z.array(walletBalanceSchema)
 });
 
 // src/v2/enso-balances/api.ts
@@ -1536,7 +1962,7 @@ async function getWalletBalances(params, context) {
 }
 
 // src/v2/enso-balances/queries.ts
-var ensoBalancesQueries = (0, import_query_key_factory10.createQueryKeys)("ensoBalances", {
+var ensoBalancesQueries = (0, import_query_key_factory11.createQueryKeys)("ensoBalances", {
   byParams: (params) => ({
     queryKey: [params],
     queryFn: (context) => getWalletBalances(params, context)
@@ -1544,15 +1970,15 @@ var ensoBalancesQueries = (0, import_query_key_factory10.createQueryKeys)("ensoB
 });
 
 // src/v2/widget/queries.ts
-var import_query_key_factory11 = require("@lukemorales/query-key-factory");
+var import_query_key_factory12 = require("@lukemorales/query-key-factory");
 
 // src/v2/widget/schema.ts
-var import_zod13 = require("zod");
+var import_zod14 = require("zod");
 
 // src/v2/opportunities/hooks.ts
-var import_react_query4 = require("@tanstack/react-query");
+var import_react_query5 = require("@tanstack/react-query");
 function useOpportunities(options) {
-  return (0, import_react_query4.useQuery)({
+  return (0, import_react_query5.useQuery)({
     ...opportunitiesQueries.all,
     ...queryDefaults,
     select: (data) => {
@@ -1568,7 +1994,7 @@ function useOpportunities(options) {
   });
 }
 function useOpportunity({ id, ...options }) {
-  return (0, import_react_query4.useQuery)({
+  return (0, import_react_query5.useQuery)({
     ...opportunitiesQueries.byId(id),
     ...queryDefaults,
     select: (data) => {
@@ -1583,7 +2009,7 @@ function useOpportunitiesPaginated({
   params,
   enabled = true
 } = {}) {
-  return (0, import_react_query4.useQuery)({
+  return (0, import_react_query5.useQuery)({
     ...opportunitiesQueries.paginated(params),
     ...queryDefaults,
     enabled
@@ -1592,7 +2018,7 @@ function useOpportunitiesPaginated({
 function useOpportunitiesFilterOptions({
   enabled = true
 } = {}) {
-  return (0, import_react_query4.useQuery)({
+  return (0, import_react_query5.useQuery)({
     ...opportunitiesQueries.filterOptions,
     ...queryDefaults,
     enabled
@@ -1600,9 +2026,9 @@ function useOpportunitiesFilterOptions({
 }
 
 // src/v2/widget/schema.ts
-var widgetOpportunitiesResponseSchema = import_zod13.z.object({
-  opportunities: import_zod13.z.array(opportunitySchema).nullable(),
-  total: import_zod13.z.number().int()
+var widgetOpportunitiesResponseSchema = import_zod14.z.object({
+  opportunities: import_zod14.z.array(opportunitySchema).nullable(),
+  total: import_zod14.z.number().int()
 });
 
 // src/v2/widget/api.ts
@@ -1620,397 +2046,13 @@ async function getWidgetOpportunities(distributorId, context) {
 }
 
 // src/v2/widget/queries.ts
-var widgetQueries = (0, import_query_key_factory11.createQueryKeys)("widget", {
+var widgetQueries = (0, import_query_key_factory12.createQueryKeys)("widget", {
   opportunities: (distributorId) => ({
     queryKey: [distributorId],
     queryFn: (context) => getWidgetOpportunities(distributorId, context)
   })
 });
 
-// src/v2/streams/queries.ts
-var import_query_key_factory12 = require("@lukemorales/query-key-factory");
-
-// src/v2/streams/schemas.ts
-var import_zod14 = require("zod");
-var snapshotSchema = import_zod14.z.object({
-  amountBase: import_zod14.z.string(),
-  amountDistributed: import_zod14.z.string(),
-  createdAt: import_zod14.z.string().datetime(),
-  rootHash: import_zod14.z.string().nullable(),
-  timestamp: import_zod14.z.string().datetime(),
-  updatedAt: import_zod14.z.string().datetime(),
-  userCount: import_zod14.z.number().nullable().optional(),
-  tvl: import_zod14.z.string().nullable().optional(),
-  baseTvl: import_zod14.z.string().nullable().optional()
-});
-var streamPointSchema = import_zod14.z.object({
-  id: import_zod14.z.string(),
-  orgId: import_zod14.z.string().optional(),
-  symbol: import_zod14.z.string(),
-  name: import_zod14.z.string(),
-  decimals: import_zod14.z.coerce.number().optional(),
-  logoUrl: import_zod14.z.string().url().nullable().optional(),
-  createdAt: import_zod14.z.string().optional(),
-  updatedAt: import_zod14.z.string().optional(),
-  deletedAt: import_zod14.z.string().nullable().optional(),
-  organization: organizationSchema.nullable().optional()
-});
-var customArgsTokensPerUsdSchema = import_zod14.z.object({
-  tokensPerUSD: import_zod14.z.string(),
-  targetChainId: import_zod14.z.number(),
-  targetTokenAddress: import_zod14.z.string()
-});
-var customArgsAprSchema = import_zod14.z.object({
-  apr: import_zod14.z.string(),
-  targetChainId: import_zod14.z.number(),
-  targetTokenAddress: import_zod14.z.string()
-});
-var customArgsTokensPerDaySchema = import_zod14.z.object({
-  tokensPerDay: import_zod14.z.string(),
-  targetChainId: import_zod14.z.number(),
-  targetTokenAddress: import_zod14.z.string()
-});
-var chainSchema2 = import_zod14.z.object({
-  chainId: import_zod14.z.coerce.number(),
-  ecosystem: import_zod14.z.string(),
-  explorerUrl: import_zod14.z.string(),
-  id: import_zod14.z.string().uuid(),
-  isTestnet: import_zod14.z.boolean(),
-  logoUrl: import_zod14.z.string(),
-  name: import_zod14.z.string(),
-  slug: import_zod14.z.string(),
-  status: import_zod14.z.string()
-});
-var rewardTokenSchema = import_zod14.z.object({
-  active: import_zod14.z.boolean(),
-  address: import_zod14.z.string(),
-  canonicalAssetId: import_zod14.z.string().uuid(),
-  chain: chainSchema2,
-  decimals: import_zod14.z.number(),
-  id: import_zod14.z.string().uuid(),
-  isNative: import_zod14.z.boolean(),
-  logoUrl: import_zod14.z.string(),
-  name: import_zod14.z.string(),
-  priceUsd: import_zod14.z.number(),
-  symbol: import_zod14.z.string(),
-  streamsMinAmount: import_zod14.z.string().nullable().optional()
-}).nullable();
-var adaptersSchema = import_zod14.z.array(
-  import_zod14.z.object({
-    type: import_zod14.z.string(),
-    params: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.number())
-  })
-);
-var feeTierSchema = import_zod14.z.object({
-  maxTVL: import_zod14.z.string().nullable(),
-  // represents a USD amount
-  feePct: import_zod14.z.string()
-  // represents a percentage (e.g. 0.15 means 15%)
-});
-var feeScheduleSchema = import_zod14.z.object({
-  feeTiers: import_zod14.z.array(feeTierSchema),
-  until: import_zod14.z.string().datetime().nullable()
-});
-var feeSnapshotSchema = import_zod14.z.object({
-  timestamp: import_zod14.z.string().datetime(),
-  tvl: import_zod14.z.string().nullable(),
-  // means USD amount
-  accumulatedFee: import_zod14.z.string(),
-  // means USD amount
-  createdAt: import_zod14.z.string().datetime(),
-  updatedAt: import_zod14.z.string().datetime()
-});
-var feeSchema = import_zod14.z.object({
-  managementFeeSchedules: import_zod14.z.array(feeScheduleSchema),
-  createdAt: import_zod14.z.string().datetime(),
-  updatedAt: import_zod14.z.string().datetime(),
-  lastFeeSnapshotTimestamp: import_zod14.z.string().datetime(),
-  feeComputationPaused: import_zod14.z.boolean(),
-  feeSnapshots: import_zod14.z.array(feeSnapshotSchema).optional(),
-  lastFeeSnapshot: feeSnapshotSchema.nullable()
-});
-var streamSchema = import_zod14.z.object({
-  adapters: adaptersSchema,
-  admin: import_zod14.z.string().nullable(),
-  chainId: import_zod14.z.number().nullable(),
-  chargedFee: import_zod14.z.string().nullable(),
-  claimPaused: import_zod14.z.boolean(),
-  contractAddress: import_zod14.z.string().nullable(),
-  createdAt: import_zod14.z.string().datetime(),
-  creationConfirmedAt: import_zod14.z.string().datetime().nullable(),
-  customArgs: import_zod14.z.union([
-    customArgsTokensPerUsdSchema,
-    customArgsAprSchema,
-    customArgsTokensPerDaySchema
-  ]),
-  endTimestamp: import_zod14.z.string().datetime().nullable(),
-  fee: feeSchema.nullable(),
-  hashCommitmentPaused: import_zod14.z.boolean(),
-  id: import_zod14.z.string().uuid(),
-  lastSnapshot: snapshotSchema.nullable(),
-  merkleTreeComputationPaused: import_zod14.z.boolean(),
-  orgId: import_zod14.z.string().uuid(),
-  point: streamPointSchema.nullable().optional(),
-  rewardToken: rewardTokenSchema,
-  snapshotComputationPaused: import_zod14.z.boolean(),
-  snapshots: import_zod14.z.array(snapshotSchema).optional(),
-  startTimestamp: import_zod14.z.string().datetime(),
-  strategy: import_zod14.z.string(),
-  totalAmount: import_zod14.z.string().nullable(),
-  type: import_zod14.z.number(),
-  updatedAt: import_zod14.z.string().datetime(),
-  userId: import_zod14.z.string().uuid()
-});
-var getStreamsOutputSchema = import_zod14.z.object({
-  streams: import_zod14.z.array(streamSchema)
-});
-var getStreamPointsOutputSchema = import_zod14.z.object({
-  points: import_zod14.z.array(streamPointSchema)
-});
-var createStreamPointBodySchema = import_zod14.z.object({
-  name: import_zod14.z.string(),
-  symbol: import_zod14.z.string(),
-  decimals: import_zod14.z.number().optional(),
-  logoUrl: import_zod14.z.string().url().nullable().optional()
-});
-var createStreamPointOutputSchema = import_zod14.z.object({
-  point: streamPointSchema
-});
-var getStreamsSupportedChainsOutputSchema = import_zod14.z.object({
-  success: import_zod14.z.boolean(),
-  chains: import_zod14.z.array(
-    import_zod14.z.object({
-      id: import_zod14.z.string(),
-      name: import_zod14.z.string(),
-      slug: import_zod14.z.string(),
-      chainId: import_zod14.z.number(),
-      logoUrl: import_zod14.z.string(),
-      ecosystem: import_zod14.z.string(),
-      status: import_zod14.z.string(),
-      explorerUrl: import_zod14.z.string(),
-      streamFactory: import_zod14.z.string()
-      // Address as string
-    })
-  )
-});
-var streamSignatureRequestInputSchema = import_zod14.z.object({
-  adapters: adaptersSchema,
-  chainId: import_zod14.z.number().nullable(),
-  customArgs: import_zod14.z.intersection(
-    import_zod14.z.object({
-      targetChainId: import_zod14.z.number(),
-      targetTokenAddress: import_zod14.z.string()
-    }),
-    import_zod14.z.union([
-      import_zod14.z.object({ tokensPerUSD: import_zod14.z.string() }),
-      import_zod14.z.object({ apr: import_zod14.z.string() }),
-      import_zod14.z.object({ tokensPerDay: import_zod14.z.string() })
-    ])
-  ),
-  endTimestamp: import_zod14.z.string().nullable(),
-  pointId: import_zod14.z.string().uuid().nullable(),
-  rewardToken: import_zod14.z.string().nullable(),
-  startTimestamp: import_zod14.z.string(),
-  totalAmount: import_zod14.z.string().nullable(),
-  type: import_zod14.z.number(),
-  walletAddress: import_zod14.z.string().nullable()
-});
-var streamSignatureRequestOutputSchema = import_zod14.z.object({
-  success: import_zod14.z.boolean(),
-  message: import_zod14.z.string(),
-  txParams: import_zod14.z.object({
-    chainId: import_zod14.z.number(),
-    sender: import_zod14.z.string(),
-    params: import_zod14.z.object({
-      deadline: import_zod14.z.number(),
-      params: import_zod14.z.object({
-        StreamId: import_zod14.z.array(import_zod14.z.number()),
-        RewardToken: import_zod14.z.string(),
-        NetTotalAmount: import_zod14.z.string(),
-        FeeAmount: import_zod14.z.string()
-      }),
-      signature: import_zod14.z.string()
-    })
-  }).nullable()
-});
-var getStreamsQuerySchema = import_zod14.z.object({
-  streamId: import_zod14.z.string().optional(),
-  userId: import_zod14.z.string().optional(),
-  organizationId: import_zod14.z.string().optional(),
-  withSnapshots: import_zod14.z.boolean().optional(),
-  usersCount: import_zod14.z.boolean().optional()
-});
-var getStreamPointsQuerySchema = import_zod14.z.object({
-  id: import_zod14.z.string().optional().nullable(),
-  organizationId: import_zod14.z.string().optional().nullable(),
-  symbol: import_zod14.z.string().optional().nullable(),
-  name: import_zod14.z.string().optional().nullable()
-});
-var streamWalletSnapshotSchema = import_zod14.z.object({
-  timestamp: import_zod14.z.string().datetime(),
-  rewardsAccumulated: import_zod14.z.string(),
-  rewardsAccumulatedBase: import_zod14.z.string(),
-  createdAt: import_zod14.z.string().datetime(),
-  updatedAt: import_zod14.z.string().datetime(),
-  tvl: import_zod14.z.string().nullable().optional()
-});
-var streamWalletSchema = import_zod14.z.object({
-  userAddress: import_zod14.z.string(),
-  lastSnapshot: streamWalletSnapshotSchema
-});
-var paginationSchema = import_zod14.z.object({
-  limit: import_zod14.z.number(),
-  page: import_zod14.z.number(),
-  total: import_zod14.z.number(),
-  totalPages: import_zod14.z.number()
-});
-var getStreamWalletsResponseSchema = import_zod14.z.object({
-  data: import_zod14.z.array(streamWalletSchema),
-  pagination: paginationSchema
-});
-var getStreamWalletsQuerySchema = import_zod14.z.object({
-  streamId: import_zod14.z.string(),
-  page: import_zod14.z.number().optional(),
-  limit: import_zod14.z.number().optional()
-});
-var streamWalletDetailsSchema = import_zod14.z.object({
-  streamId: import_zod14.z.string(),
-  userAddress: import_zod14.z.string(),
-  snapshots: import_zod14.z.array(streamWalletSnapshotSchema),
-  stream: streamSchema
-});
-var getStreamWalletDetailsResponseSchema = import_zod14.z.object({
-  wallet: streamWalletDetailsSchema
-});
-
-// src/v2/streams/api.ts
-async function getStreams(query) {
-  const params = new URLSearchParams();
-  if (query?.streamId) params.set("id", query.streamId);
-  if (query?.userId) params.set("userId", query.userId);
-  if (query?.organizationId) params.set("organizationId", query.organizationId);
-  if (query?.withSnapshots) params.append("withSnapshots", "true");
-  if (query?.usersCount && query?.withSnapshots) params.append("usersCount", "true");
-  const queryString = params.toString();
-  const endpoint = `/streams${queryString ? `?${queryString}` : ""}`;
-  const data = await apiClient.fetch(endpoint, { method: "GET" });
-  const result = getStreamsOutputSchema.safeParse(data);
-  if (!result.success) {
-    console.error(
-      "Zod Validation Error in getStreams:",
-      JSON.stringify(result.error.format(), null, 2)
-    );
-    throw new Error(`Failed to parse streams: ${result.error.message}`);
-  }
-  return result.data.streams;
-}
-async function getStreamPoints(query) {
-  const params = new URLSearchParams();
-  if (query?.id) params.set("id", query.id);
-  if (query?.organizationId) params.set("organizationId", query.organizationId);
-  if (query?.symbol) params.set("symbol", query.symbol);
-  if (query?.name) params.set("name", query.name);
-  const queryString = params.toString();
-  const endpoint = `/streams/points${queryString ? `?${queryString}` : ""}`;
-  const data = await apiClient.fetch(endpoint, { method: "GET" });
-  const result = getStreamPointsOutputSchema.safeParse(data);
-  if (!result.success) {
-    console.error(
-      "Zod Validation Error in getStreamPoints:",
-      JSON.stringify(result.error.format(), null, 2)
-    );
-    throw new Error(`Failed to parse stream points: ${result.error.message}`);
-  }
-  return result.data.points;
-}
-async function createStreamPoint(organizationId, body) {
-  const endpoint = `/streams/points/${organizationId}`;
-  const data = await apiClient.fetch(endpoint, {
-    method: "POST",
-    body
-  });
-  const result = createStreamPointOutputSchema.safeParse(data);
-  if (!result.success) {
-    throw new Error(`Failed to parse create point response: ${result.error.message}`);
-  }
-  return result.data;
-}
-async function getStreamWallets(query) {
-  const params = new URLSearchParams();
-  if (query?.page) params.set("page", query.page.toString());
-  if (query?.limit) params.set("limit", query.limit.toString());
-  const queryString = params.toString();
-  const endpoint = `/streams/${query.streamId}/wallets/${queryString ? `?${queryString}` : ""}`;
-  const data = await apiClient.fetch(endpoint, { method: "GET" });
-  const result = getStreamWalletsResponseSchema.safeParse(data);
-  if (!result.success) {
-    console.error(
-      "Zod Validation Error in getStreamWallets:",
-      JSON.stringify(result.error.format(), null, 2)
-    );
-    throw new Error(`Failed to parse stream wallets: ${result.error.message}`);
-  }
-  return result.data;
-}
-async function getStreamWalletDetails(streamId, userAddress) {
-  const endpoint = `/streams/${streamId}/wallets/${userAddress}`;
-  const data = await apiClient.fetch(endpoint, { method: "GET" });
-  const result = getStreamWalletDetailsResponseSchema.safeParse(data);
-  if (!result.success) {
-    console.error(
-      "Zod Validation Error in getStreamWalletDetails:",
-      JSON.stringify(result.error.format(), null, 2)
-    );
-    throw new Error(`Failed to parse stream wallet details: ${result.error.message}`);
-  }
-  return result.data.wallet;
-}
-async function getStreamsSupportedChains() {
-  const endpoint = "/streams/supported_chains";
-  const data = await apiClient.fetch(endpoint, { method: "GET" });
-  const result = getStreamsSupportedChainsOutputSchema.safeParse(data);
-  if (!result.success) {
-    throw new Error(`Failed to parse supported chains: ${result.error.message}`);
-  }
-  return result.data.chains;
-}
-async function requestStreamSignature(organizationId, input) {
-  const endpoint = `/streams/create/${organizationId}`;
-  const data = await apiClient.fetch(endpoint, {
-    method: "POST",
-    body: input
-  });
-  const result = streamSignatureRequestOutputSchema.safeParse(data);
-  if (!result.success) {
-    throw new Error(`Failed to parse signature response: ${result.error.message}`);
-  }
-  return result.data;
-}
-
-// src/v2/streams/queries.ts
-var streamsQueries = (0, import_query_key_factory12.createQueryKeys)("streams", {
-  list: (query) => ({
-    queryKey: [query ?? "all"],
-    queryFn: () => getStreams(query)
-  }),
-  points: (query) => ({
-    queryKey: [query ?? "all"],
-    queryFn: () => getStreamPoints(query)
-  }),
-  wallets: (query) => ({
-    queryKey: [query],
-    queryFn: () => getStreamWallets(query)
-  }),
-  walletDetails: (query) => ({
-    queryKey: [query],
-    queryFn: () => getStreamWalletDetails(query.streamId, query.userAddress)
-  }),
-  supportedChains: {
-    queryKey: null,
-    queryFn: () => getStreamsSupportedChains()
-  }
-});
-
 // src/v2/users/queries.ts
 var import_query_key_factory13 = require("@lukemorales/query-key-factory");
 
@@ -2273,7 +2315,7 @@ var import_query_key_factory17 = require("@lukemorales/query-key-factory");
 
 // src/v2/deposits/schemas.ts
 var import_zod18 = require("zod");
-var uuidSchema = import_zod18.z.string().uuid();
+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({
@@ -2304,10 +2346,10 @@ var getDepositsRequestSchema = import_zod18.z.object({
   }
 );
 var depositResponseSchema = import_zod18.z.object({
-  id: uuidSchema,
-  opportunityId: uuidSchema,
-  walletId: uuidSchema.nullable().optional(),
-  crmWalletId: uuidSchema.nullable().optional(),
+  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(),
@@ -2581,18 +2623,18 @@ var geocheckQueries = (0, import_query_key_factory20.createQueryKeys)("geocheck"
 });
 
 // src/v2/earn-opportunities/hooks.ts
-var import_react_query5 = require("@tanstack/react-query");
+var import_react_query6 = require("@tanstack/react-query");
 function useEarnOpportunities() {
-  return (0, import_react_query5.useQuery)({
+  return (0, import_react_query6.useQuery)({
     ...earnOpportunitiesQueries.all,
     ...queryDefaults
   });
 }
 
 // src/v2/earn-route/hooks.ts
-var import_react_query6 = require("@tanstack/react-query");
+var import_react_query7 = require("@tanstack/react-query");
 function useEarnRoute({ params, enabled = true }) {
-  return (0, import_react_query6.useQuery)({
+  return (0, import_react_query7.useQuery)({
     // Null assertion is safe because the query is enable only if params is provided
     ...earnRouteQueries.byParams(params),
     ...queryDefaults,
@@ -2601,25 +2643,25 @@ function useEarnRoute({ params, enabled = true }) {
 }
 
 // src/v2/earn-membership/hooks.ts
-var import_react_query7 = require("@tanstack/react-query");
+var import_react_query8 = require("@tanstack/react-query");
 function useCheckMembership({
   params,
   enabled = true
 }) {
-  return (0, import_react_query7.useQuery)({
+  return (0, import_react_query8.useQuery)({
     ...earnMembershipQueries.check(params),
     ...queryDefaults,
     enabled
   });
 }
 function useCreateMembershipAgreement() {
-  return (0, import_react_query7.useMutation)({
+  return (0, import_react_query8.useMutation)({
     mutationFn: (request) => createMembershipAgreement(request)
   });
 }
 function useCreateMembership() {
-  const queryClient = (0, import_react_query7.useQueryClient)();
-  return (0, import_react_query7.useMutation)({
+  const queryClient = (0, import_react_query8.useQueryClient)();
+  return (0, import_react_query8.useMutation)({
     mutationFn: (request) => createMembership(request),
     onSuccess: (data, variables) => {
       queryClient.invalidateQueries({
@@ -2633,7 +2675,7 @@ function useCreateMembership() {
 }
 
 // src/v2/earn-deposits/hooks.ts
-var import_react_query11 = require("@tanstack/react-query");
+var import_react_query12 = require("@tanstack/react-query");
 
 // src/v2/earn-deposits/hooks/useDepositValidation.ts
 var import_react2 = require("react");
@@ -2897,10 +2939,10 @@ var import_react6 = require("react");
 
 // src/v2/earn-actions/useEarnDeposit.ts
 var import_react5 = require("react");
-var import_react_query9 = require("@tanstack/react-query");
+var import_react_query10 = require("@tanstack/react-query");
 
 // src/v2/earn-actions/hooks.ts
-var import_react_query8 = require("@tanstack/react-query");
+var import_react_query9 = require("@tanstack/react-query");
 
 // src/v2/earn-actions/schema.ts
 var import_zod21 = require("zod");
@@ -2994,7 +3036,7 @@ var createClaimWithdrawInteraction = createClaimWithdrawAction;
 // src/v2/earn-actions/hooks.ts
 function createActionHook(mutationFn) {
   return function useAction(options) {
-    return (0, import_react_query8.useMutation)({
+    return (0, import_react_query9.useMutation)({
       mutationFn,
       ...options
     });
@@ -3007,7 +3049,7 @@ var useClaimDepositAction = createActionHook(createClaimDepositAction);
 var useCancelDepositAction = createActionHook(createCancelDepositAction);
 var useCancelWithdrawAction = createActionHook(createCancelWithdrawAction);
 function useAttributeAction(options) {
-  return (0, import_react_query8.useMutation)({
+  return (0, import_react_query9.useMutation)({
     mutationFn: attributeAction,
     ...options
   });
@@ -3028,7 +3070,7 @@ function useEarnDeposit(options) {
     onSuccess,
     referralCode
   } = options;
-  const queryClient = (0, import_react_query9.useQueryClient)();
+  const queryClient = (0, import_react_query10.useQueryClient)();
   const [isConfirming, setIsConfirming] = (0, import_react5.useState)(false);
   const [error, setError] = (0, import_react5.useState)(null);
   const [metadata, setMetadata] = (0, import_react5.useState)(null);
@@ -3346,7 +3388,7 @@ function useGetOnChainBalance({
 var import_react9 = require("react");
 
 // src/v2/balance/hooks/usePortfolioBalance.ts
-var import_react_query10 = require("@tanstack/react-query");
+var import_react_query11 = require("@tanstack/react-query");
 var import_react8 = require("react");
 var import_viem4 = require("viem");
 function usePortfolioBalance({
@@ -3359,7 +3401,7 @@ function usePortfolioBalance({
     isLoading,
     error,
     refetch
-  } = (0, import_react_query10.useQuery)({
+  } = (0, import_react_query11.useQuery)({
     ...balanceQueries.portfolio(address || ""),
     ...queryDefaults,
     enabled: !!address,
@@ -3639,7 +3681,7 @@ function useActionsDefaultParams({
 
 // src/v2/earn-deposits/hooks.ts
 function useDeposits({ params, enabled = true }) {
-  return (0, import_react_query11.useQuery)({
+  return (0, import_react_query12.useQuery)({
     ...earnDepositsQueries.byParams(params),
     ...queryDefaults,
     enabled
@@ -3648,7 +3690,7 @@ function useDeposits({ params, enabled = true }) {
 
 // src/v2/earn-actions/useEarnWithdraw.ts
 var import_react11 = require("react");
-var import_react_query12 = require("@tanstack/react-query");
+var import_react_query13 = require("@tanstack/react-query");
 function useEarnWithdraw(options) {
   const {
     opportunity,
@@ -3657,7 +3699,7 @@ function useEarnWithdraw(options) {
     executeTransactionAndWait,
     onSuccess
   } = options;
-  const queryClient = (0, import_react_query12.useQueryClient)();
+  const queryClient = (0, import_react_query13.useQueryClient)();
   const [isConfirming, setIsConfirming] = (0, import_react11.useState)(false);
   const [error, setError] = (0, import_react11.useState)(null);
   const [metadata, setMetadata] = (0, import_react11.useState)(null);
@@ -3967,12 +4009,12 @@ function useWithdrawFlow({
 
 // src/v2/enso-balances/hooks.ts
 var import_react15 = require("react");
-var import_react_query13 = require("@tanstack/react-query");
+var import_react_query14 = require("@tanstack/react-query");
 function useMultiChainBalances({
   chainIds,
   address
 }) {
-  const queries2 = (0, import_react_query13.useQueries)({
+  const queries2 = (0, import_react_query14.useQueries)({
     queries: chainIds.map((chainId) => ({
       ...ensoBalancesQueries.byParams({ user: address || "", chain: chainId }),
       enabled: !!address,
@@ -4008,41 +4050,41 @@ function useMultiChainBalances({
 }
 
 // src/v2/products/hooks.ts
-var import_react_query14 = require("@tanstack/react-query");
+var import_react_query15 = require("@tanstack/react-query");
 function useProducts({ filters, enabled = true }) {
-  return (0, import_react_query14.useQuery)({
+  return (0, import_react_query15.useQuery)({
     ...productsQueries.list(filters),
     ...queryDefaults,
     enabled
   });
 }
 function useProduct({ id, enabled = true }) {
-  return (0, import_react_query14.useQuery)({
+  return (0, import_react_query15.useQuery)({
     ...productsQueries.byId(id),
     ...queryDefaults,
     enabled
   });
 }
 function useCreateProduct(options) {
-  return (0, import_react_query14.useMutation)({
+  return (0, import_react_query15.useMutation)({
     mutationFn: (input) => createProduct(input),
     ...options
   });
 }
 function useUpdateProduct(options) {
-  return (0, import_react_query14.useMutation)({
+  return (0, import_react_query15.useMutation)({
     mutationFn: (input) => updateProduct(input),
     ...options
   });
 }
 function useDeleteProduct(options) {
-  return (0, import_react_query14.useMutation)({
+  return (0, import_react_query15.useMutation)({
     mutationFn: (id) => deleteProduct(id),
     ...options
   });
 }
 function useUploadProductLogo(options) {
-  return (0, import_react_query14.useMutation)({
+  return (0, import_react_query15.useMutation)({
     mutationFn: (request) => uploadProductLogo(request),
     ...options
   });
@@ -4090,9 +4132,9 @@ function useEnsoBalances({
 }
 
 // src/v2/widget/hooks.ts
-var import_react_query15 = require("@tanstack/react-query");
+var import_react_query16 = require("@tanstack/react-query");
 function useWidgetOpportunities(distributorId) {
-  return (0, import_react_query15.useQuery)({
+  return (0, import_react_query16.useQuery)({
     ...widgetQueries.opportunities(distributorId),
     ...queryDefaults,
     select: (data) => {
@@ -4116,10 +4158,10 @@ function useWidgetOpportunities(distributorId) {
 }
 
 // src/v2/geocheck/hooks.ts
-var import_react_query16 = require("@tanstack/react-query");
+var import_react_query17 = require("@tanstack/react-query");
 function useGeocheck(options = {}) {
   const { enabled = true, staleTime, gcTime } = options;
-  return (0, import_react_query16.useQuery)({
+  return (0, import_react_query17.useQuery)({
     ...geocheckQueries.check,
     ...queryDefaults,
     enabled,
@@ -4130,38 +4172,6 @@ function useGeocheck(options = {}) {
   });
 }
 
-// src/v2/streams/hooks.ts
-var import_react_query17 = require("@tanstack/react-query");
-function useStreams({
-  query,
-  options
-} = {}) {
-  return (0, import_react_query17.useQuery)(createQueryOptions(streamsQueries.list(query), options));
-}
-function useStreamPoints({
-  query,
-  options
-} = {}) {
-  return (0, import_react_query17.useQuery)(createQueryOptions(streamsQueries.points(query), options));
-}
-function useStreamWallets({
-  query,
-  options
-}) {
-  return (0, import_react_query17.useQuery)(createQueryOptions(streamsQueries.wallets(query), options));
-}
-function useStreamWalletDetails({
-  query,
-  options
-}) {
-  return (0, import_react_query17.useQuery)(createQueryOptions(streamsQueries.walletDetails(query), options));
-}
-function useStreamSupportedChains({
-  options
-} = {}) {
-  return (0, import_react_query17.useQuery)(createQueryOptions(streamsQueries.supportedChains, options));
-}
-
 // src/v2/swap/useSwapRoute.ts
 var import_react17 = require("react");
 
@@ -4724,6 +4734,8 @@ var queries = (0, import_query_key_factory21.mergeQueryKeys)(
   streamsQueries,
   submitCoverRequest,
   submitCoverRequestResponseSchema,
+  supportedChainEcosystemSchema,
+  supportedChainStatusSchema,
   supportedChainsQueries,
   supportedChainsResponseSchema,
   supportedTokenSchema,