@turtleclub/hooks 0.5.0-beta.8 → 0.5.0-beta.9

package/dist/index.cjs

@@ -64,6 +64,11 @@ __export(index_exports, {
   getPortfolioBalance: () => getPortfolioBalance,
   getProducts: () => getProducts,
   getSourcePriority: () => getSourcePriority,
+  getStreams: () => getStreams,
+  getStreamsOutputSchema: () => getStreamsOutputSchema,
+  getStreamsQuerySchema: () => getStreamsQuerySchema,
+  getStreamsSupportedChains: () => getStreamsSupportedChains,
+  getStreamsSupportedChainsOutputSchema: () => getStreamsSupportedChainsOutputSchema,
   getSupportedChains: () => getSupportedChains,
   getSupportedTokens: () => getSupportedTokens,
   getUserById: () => getUserById,
@@ -92,10 +97,16 @@ __export(index_exports, {
   productSchema: () => productSchema,
   productsQueries: () => productsQueries,
   queries: () => queries,
+  requestStreamSignature: () => requestStreamSignature,
   routeToken: () => routeToken,
   routerStep: () => routerStep,
   routerSubstep: () => routerSubstep,
+  snapshotSchema: () => snapshotSchema,
   stepTx: () => stepTx,
+  streamSchema: () => streamSchema,
+  streamSignatureRequestInputSchema: () => streamSignatureRequestInputSchema,
+  streamSignatureRequestOutputSchema: () => streamSignatureRequestOutputSchema,
+  streamsQueries: () => streamsQueries,
   supportedChainsQueries: () => supportedChainsQueries,
   supportedChainsResponseSchema: () => supportedChainsResponseSchema,
   supportedTokenSchema: () => supportedTokenSchema,
@@ -121,6 +132,9 @@ __export(index_exports, {
   usePortfolioBalance: () => usePortfolioBalance,
   useProduct: () => useProduct,
   useProducts: () => useProducts,
+  useRequestStreamSignature: () => useRequestStreamSignature,
+  useStreamSupportedChains: () => useStreamSupportedChains,
+  useStreams: () => useStreams,
   useSupportedChains: () => useSupportedChains,
   useSupportedTokens: () => useSupportedTokens,
   useSwapRoute: () => useSwapRoute,
@@ -144,7 +158,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/v2/index.ts
-var import_query_key_factory13 = require("@lukemorales/query-key-factory");
+var import_query_key_factory14 = require("@lukemorales/query-key-factory");
 
 // src/v2/opportunities/queries.ts
 var import_query_key_factory = require("@lukemorales/query-key-factory");
@@ -1011,13 +1025,180 @@ var widgetQueries = (0, import_query_key_factory8.createQueryKeys)("widget", {
   })
 });
 
-// src/v2/supported-chains/queries.ts
+// src/v2/streams/queries.ts
 var import_query_key_factory9 = require("@lukemorales/query-key-factory");
 
-// src/v2/supported-chains/schema.ts
+// src/v2/streams/schemas.ts
 var import_zod10 = require("zod");
-var supportedChainsResponseSchema = import_zod10.z.object({
-  chains: import_zod10.z.array(chainSchema)
+var snapshotSchema = import_zod10.z.object({
+  amountDistributed: import_zod10.z.string(),
+  createdAt: import_zod10.z.string().datetime(),
+  rootHash: import_zod10.z.string().nullable(),
+  timestamp: import_zod10.z.string().datetime(),
+  updatedAt: import_zod10.z.string().datetime(),
+  userCount: import_zod10.z.number().optional()
+});
+var customArgsTokensPerUsdSchema = import_zod10.z.object({
+  tokensPerUSD: import_zod10.z.string(),
+  targetChainId: import_zod10.z.number(),
+  targetTokenAddress: import_zod10.z.string()
+});
+var customArgsAprSchema = import_zod10.z.object({
+  apr: import_zod10.z.string(),
+  targetChainId: import_zod10.z.number(),
+  targetTokenAddress: import_zod10.z.string()
+});
+var streamSchema = import_zod10.z.object({
+  admin: import_zod10.z.string(),
+  chainId: import_zod10.z.number(),
+  chargedFee: import_zod10.z.string(),
+  contractAddress: import_zod10.z.string(),
+  createdAt: import_zod10.z.string().datetime(),
+  customArgs: import_zod10.z.union([customArgsTokensPerUsdSchema, customArgsAprSchema]),
+  deletedAt: import_zod10.z.string().datetime().nullable(),
+  endTimestamp: import_zod10.z.string().datetime(),
+  finalizationTimestamp: import_zod10.z.string().datetime(),
+  id: import_zod10.z.string().uuid(),
+  isPaused: import_zod10.z.boolean(),
+  lastSnapshot: snapshotSchema.nullable(),
+  orgId: import_zod10.z.string().uuid(),
+  rewardToken: import_zod10.z.string(),
+  snapshots: import_zod10.z.array(snapshotSchema).optional(),
+  startTimestamp: import_zod10.z.string().datetime(),
+  strategy: import_zod10.z.string(),
+  totalAmount: import_zod10.z.string(),
+  type: import_zod10.z.number(),
+  updatedAt: import_zod10.z.string().datetime(),
+  userId: import_zod10.z.string().uuid()
+});
+var getStreamsOutputSchema = import_zod10.z.object({
+  streams: import_zod10.z.array(streamSchema)
+});
+var getStreamsSupportedChainsOutputSchema = import_zod10.z.object({
+  success: import_zod10.z.boolean(),
+  chains: import_zod10.z.array(
+    import_zod10.z.object({
+      id: import_zod10.z.string(),
+      name: import_zod10.z.string(),
+      slug: import_zod10.z.string(),
+      chainId: import_zod10.z.number(),
+      logoUrl: import_zod10.z.string(),
+      ecosystem: import_zod10.z.string(),
+      status: import_zod10.z.string(),
+      explorerUrl: import_zod10.z.string(),
+      campaignFactory: import_zod10.z.string()
+      // Address as string
+    })
+  )
+});
+var streamSignatureRequestInputSchema = import_zod10.z.object({
+  campaignType: import_zod10.z.number(),
+  chainId: import_zod10.z.number(),
+  customArgs: import_zod10.z.intersection(
+    import_zod10.z.object({
+      targetChainId: import_zod10.z.number(),
+      targetTokenAddress: import_zod10.z.string()
+    }),
+    import_zod10.z.union([import_zod10.z.object({ tokensPerUsd: import_zod10.z.string() }), import_zod10.z.object({ apr: import_zod10.z.string() })])
+  ),
+  endTimestamp: import_zod10.z.string(),
+  finalizationTimestamp: import_zod10.z.string(),
+  rewardToken: import_zod10.z.string(),
+  startTimestamp: import_zod10.z.string(),
+  totalAmount: import_zod10.z.string(),
+  walletAddress: import_zod10.z.string()
+});
+var streamSignatureRequestOutputSchema = import_zod10.z.object({
+  success: import_zod10.z.boolean(),
+  message: import_zod10.z.string(),
+  txParams: import_zod10.z.object({
+    chainId: import_zod10.z.number(),
+    sender: import_zod10.z.string(),
+    params: import_zod10.z.object({
+      params: import_zod10.z.object({
+        UserId: import_zod10.z.array(import_zod10.z.number()),
+        OrgId: import_zod10.z.array(import_zod10.z.number()),
+        CampaignType: import_zod10.z.number(),
+        RewardToken: import_zod10.z.string(),
+        TotalAmount: import_zod10.z.number(),
+        FeeBps: import_zod10.z.number(),
+        StartTimestamp: import_zod10.z.number(),
+        EndTimestamp: import_zod10.z.number(),
+        FinalizationTimestamp: import_zod10.z.number(),
+        CampaignData: import_zod10.z.string()
+      }),
+      signature: import_zod10.z.string(),
+      salt: import_zod10.z.string(),
+      deadline: import_zod10.z.number()
+    })
+  })
+});
+var getStreamsQuerySchema = import_zod10.z.object({
+  streamId: import_zod10.z.string().optional(),
+  userId: import_zod10.z.string().optional(),
+  organizationId: import_zod10.z.string().optional(),
+  withSnapshots: import_zod10.z.boolean().optional(),
+  usersCount: import_zod10.z.boolean().optional()
+});
+
+// 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) {
+    throw new Error(`Failed to parse streams: ${result.error.message}`);
+  }
+  return result.data.streams;
+}
+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/request_signature/${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_factory9.createQueryKeys)("streams", {
+  list: (query) => ({
+    queryKey: [query ?? "all"],
+    queryFn: () => getStreams(query)
+  }),
+  supportedChains: {
+    queryKey: null,
+    queryFn: () => getStreamsSupportedChains()
+  }
+});
+
+// src/v2/supported-chains/queries.ts
+var import_query_key_factory10 = require("@lukemorales/query-key-factory");
+
+// src/v2/supported-chains/schema.ts
+var import_zod11 = require("zod");
+var supportedChainsResponseSchema = import_zod11.z.object({
+  chains: import_zod11.z.array(chainSchema)
 });
 
 // src/v2/supported-chains/api.ts
@@ -1035,7 +1216,7 @@ async function getSupportedChains(options) {
 }
 
 // src/v2/supported-chains/queries.ts
-var supportedChainsQueries = (0, import_query_key_factory9.createQueryKeys)("supportedChains", {
+var supportedChainsQueries = (0, import_query_key_factory10.createQueryKeys)("supportedChains", {
   all: {
     queryKey: null,
     queryFn: () => getSupportedChains()
@@ -1043,18 +1224,18 @@ var supportedChainsQueries = (0, import_query_key_factory9.createQueryKeys)("sup
 });
 
 // src/v2/supported-tokens/queries.ts
-var import_query_key_factory10 = require("@lukemorales/query-key-factory");
+var import_query_key_factory11 = require("@lukemorales/query-key-factory");
 
 // src/v2/supported-tokens/schema.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 var supportedTokenSchema = tokenSchema.extend({
-  active: import_zod11.z.boolean()
+  active: import_zod12.z.boolean()
 });
-var supportedTokensResponseSchema = import_zod11.z.object({
-  tokens: import_zod11.z.array(supportedTokenSchema),
-  total: import_zod11.z.number().optional(),
-  limit: import_zod11.z.number().optional(),
-  page: import_zod11.z.number().optional()
+var supportedTokensResponseSchema = import_zod12.z.object({
+  tokens: import_zod12.z.array(supportedTokenSchema),
+  total: import_zod12.z.number().optional(),
+  limit: import_zod12.z.number().optional(),
+  page: import_zod12.z.number().optional()
 });
 
 // src/v2/supported-tokens/api.ts
@@ -1078,7 +1259,7 @@ async function getSupportedTokens(filters, options) {
 }
 
 // src/v2/supported-tokens/queries.ts
-var supportedTokensQueries = (0, import_query_key_factory10.createQueryKeys)("supportedTokens", {
+var supportedTokensQueries = (0, import_query_key_factory11.createQueryKeys)("supportedTokens", {
   list: (filters) => ({
     queryKey: [filters],
     queryFn: () => getSupportedTokens(filters)
@@ -1086,72 +1267,72 @@ var supportedTokensQueries = (0, import_query_key_factory10.createQueryKeys)("su
 });
 
 // src/v2/users/queries.ts
-var import_query_key_factory11 = require("@lukemorales/query-key-factory");
+var import_query_key_factory12 = require("@lukemorales/query-key-factory");
 
 // src/v2/users/schemas.ts
-var import_zod12 = require("zod");
-var walletDataSchema = import_zod12.z.object({
-  address: import_zod12.z.string(),
-  totalAmountInUSD: import_zod12.z.string(),
-  tokens: import_zod12.z.array(tokenSchema)
-});
-var holdingsDataSchema = import_zod12.z.object({
-  totalAmountInUSD: import_zod12.z.string(),
-  chains: import_zod12.z.array(chainSchema).nullish(),
-  wallets: import_zod12.z.array(walletDataSchema).nullish()
-});
-var userEarningsSchema = import_zod12.z.object({
-  productId: import_zod12.z.string().uuid(),
-  value: import_zod12.z.number(),
-  referralsEarnings: import_zod12.z.number().nullish(),
-  rewardName: import_zod12.z.string().nullish(),
-  rewardType: import_zod12.z.string().nullish()
-});
-var portfolioSchema = import_zod12.z.object({
-  productsEarnings: import_zod12.z.array(userEarningsSchema),
+var import_zod13 = require("zod");
+var walletDataSchema = import_zod13.z.object({
+  address: import_zod13.z.string(),
+  totalAmountInUSD: import_zod13.z.string(),
+  tokens: import_zod13.z.array(tokenSchema)
+});
+var holdingsDataSchema = import_zod13.z.object({
+  totalAmountInUSD: import_zod13.z.string(),
+  chains: import_zod13.z.array(chainSchema).nullish(),
+  wallets: import_zod13.z.array(walletDataSchema).nullish()
+});
+var userEarningsSchema = import_zod13.z.object({
+  productId: import_zod13.z.string().uuid(),
+  value: import_zod13.z.number(),
+  referralsEarnings: import_zod13.z.number().nullish(),
+  rewardName: import_zod13.z.string().nullish(),
+  rewardType: import_zod13.z.string().nullish()
+});
+var portfolioSchema = import_zod13.z.object({
+  productsEarnings: import_zod13.z.array(userEarningsSchema),
   holdings: holdingsDataSchema.nullish()
 });
-var holdingInfoSchema = import_zod12.z.object({
-  amount: import_zod12.z.number(),
-  usdValue: import_zod12.z.number(),
+var holdingInfoSchema = import_zod13.z.object({
+  amount: import_zod13.z.number(),
+  usdValue: import_zod13.z.number(),
   token: tokenSchema.nullish()
 });
-var walletInfoSchema = import_zod12.z.object({
-  address: import_zod12.z.string().nullish(),
-  ecosystem: import_zod12.z.string().nullish(),
-  isMain: import_zod12.z.boolean().nullish(),
-  holdings: import_zod12.z.array(holdingInfoSchema).nullish()
-});
-var userWithDetailsSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  email: import_zod12.z.string().nullable(),
-  username: import_zod12.z.string().nullish(),
-  firstName: import_zod12.z.string().nullish(),
-  lastName: import_zod12.z.string().nullish(),
-  avatarUrl: import_zod12.z.string().nullish(),
-  telegramHandle: import_zod12.z.string().nullish(),
-  xUsername: import_zod12.z.string().nullish(),
-  role: import_zod12.z.string(),
-  createdAt: import_zod12.z.string(),
-  updatedAt: import_zod12.z.string(),
-  tags: import_zod12.z.array(import_zod12.z.string()).nullish(),
-  wallets: import_zod12.z.array(walletInfoSchema).nullish()
-});
-var getUserTurtlePortfolioInputSchema = import_zod12.z.object({
-  userId: import_zod12.z.string().uuid()
-});
-var getUserTurtlePortfolioOutputSchema = import_zod12.z.object({
+var walletInfoSchema = import_zod13.z.object({
+  address: import_zod13.z.string().nullish(),
+  ecosystem: import_zod13.z.string().nullish(),
+  isMain: import_zod13.z.boolean().nullish(),
+  holdings: import_zod13.z.array(holdingInfoSchema).nullish()
+});
+var userWithDetailsSchema = import_zod13.z.object({
+  id: import_zod13.z.string(),
+  email: import_zod13.z.string().nullable(),
+  username: import_zod13.z.string().nullish(),
+  firstName: import_zod13.z.string().nullish(),
+  lastName: import_zod13.z.string().nullish(),
+  avatarUrl: import_zod13.z.string().nullish(),
+  telegramHandle: import_zod13.z.string().nullish(),
+  xUsername: import_zod13.z.string().nullish(),
+  role: import_zod13.z.string(),
+  createdAt: import_zod13.z.string(),
+  updatedAt: import_zod13.z.string(),
+  tags: import_zod13.z.array(import_zod13.z.string()).nullish(),
+  wallets: import_zod13.z.array(walletInfoSchema).nullish()
+});
+var getUserTurtlePortfolioInputSchema = import_zod13.z.object({
+  userId: import_zod13.z.string().uuid()
+});
+var getUserTurtlePortfolioOutputSchema = import_zod13.z.object({
   portfolio: portfolioSchema
 });
-var getUserTurtlePortfolioPathSchema = import_zod12.z.object({
-  userId: import_zod12.z.string().uuid()
+var getUserTurtlePortfolioPathSchema = import_zod13.z.object({
+  userId: import_zod13.z.string().uuid()
 });
-var getUserByIdInputSchema = import_zod12.z.object({
-  userId: import_zod12.z.string().uuid()
+var getUserByIdInputSchema = import_zod13.z.object({
+  userId: import_zod13.z.string().uuid()
 });
-var getUserByIdOutputSchema = import_zod12.z.object({
+var getUserByIdOutputSchema = import_zod13.z.object({
   user: userWithDetailsSchema.nullable(),
-  error: import_zod12.z.string().optional()
+  error: import_zod13.z.string().optional()
 });
 
 // src/v2/users/api.ts
@@ -1182,7 +1363,7 @@ async function getUserPortfolio(input) {
 }
 
 // src/v2/users/queries.ts
-var usersQueries = (0, import_query_key_factory11.createQueryKeys)("users", {
+var usersQueries = (0, import_query_key_factory12.createQueryKeys)("users", {
   byId: (input) => ({
     queryKey: [input.userId],
     queryFn: () => getUserById(input)
@@ -1207,6 +1388,13 @@ var queryDefaults = {
   refetchOnWindowFocus: false
   // Don't refetch on tab focus
 };
+function createQueryOptions(queryConfig, options) {
+  return {
+    ...queryDefaults,
+    ...queryConfig,
+    ...options
+  };
+}
 
 // src/v2/earn-opportunities/hooks.ts
 function useEarnOpportunities() {
@@ -1438,33 +1626,33 @@ var BalanceSourcePriority = /* @__PURE__ */ ((BalanceSourcePriority2) => {
 })(BalanceSourcePriority || {});
 
 // src/v2/balance/schema.ts
-var import_zod13 = require("zod");
-var portfolioTokenSchema = import_zod13.z.object({
-  id: import_zod13.z.string(),
-  address: import_zod13.z.string(),
-  name: import_zod13.z.string(),
-  symbol: import_zod13.z.string(),
-  decimals: import_zod13.z.number(),
-  isNative: import_zod13.z.boolean(),
-  logoUrl: import_zod13.z.string().nullable(),
-  amount: import_zod13.z.string(),
+var import_zod14 = require("zod");
+var portfolioTokenSchema = import_zod14.z.object({
+  id: import_zod14.z.string(),
+  address: import_zod14.z.string(),
+  name: import_zod14.z.string(),
+  symbol: import_zod14.z.string(),
+  decimals: import_zod14.z.number(),
+  isNative: import_zod14.z.boolean(),
+  logoUrl: import_zod14.z.string().nullable(),
+  amount: import_zod14.z.string(),
   // Portfolio-specific field (decimal format)
-  price: import_zod13.z.string().nullable().transform((val) => val ? parseFloat(val) : null),
+  price: import_zod14.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_zod13.z.object({
-  id: import_zod13.z.string().optional(),
-  address: import_zod13.z.string(),
-  blockchain: import_zod13.z.string().optional(),
-  tokens: import_zod13.z.array(portfolioTokenSchema)
+var portfolioWalletSchema = import_zod14.z.object({
+  id: import_zod14.z.string().optional(),
+  address: import_zod14.z.string(),
+  blockchain: import_zod14.z.string().optional(),
+  tokens: import_zod14.z.array(portfolioTokenSchema)
 });
-var portfolioHoldingsSchema = import_zod13.z.object({
-  wallets: import_zod13.z.array(portfolioWalletSchema)
+var portfolioHoldingsSchema = import_zod14.z.object({
+  wallets: import_zod14.z.array(portfolioWalletSchema)
 });
-var portfolioBalanceResponseSchema = import_zod13.z.object({
-  portfolio: import_zod13.z.object({
+var portfolioBalanceResponseSchema = import_zod14.z.object({
+  portfolio: import_zod14.z.object({
     holdings: portfolioHoldingsSchema
   })
 });
@@ -1485,8 +1673,8 @@ async function getPortfolioBalance(address, options) {
 }
 
 // src/v2/balance/queries.ts
-var import_query_key_factory12 = require("@lukemorales/query-key-factory");
-var balanceQueries = (0, import_query_key_factory12.createQueryKeys)("balance", {
+var import_query_key_factory13 = require("@lukemorales/query-key-factory");
+var balanceQueries = (0, import_query_key_factory13.createQueryKeys)("balance", {
   // Portfolio balance by address
   portfolio: (address) => ({
     queryKey: [address],
@@ -1934,6 +2122,21 @@ function useGeocheck(options = {}) {
   });
 }
 
+// src/v2/streams/hooks.ts
+var import_react_query13 = require("@tanstack/react-query");
+function useStreams({ query, ...options } = {}) {
+  return (0, import_react_query13.useQuery)(createQueryOptions(streamsQueries.list(query), options));
+}
+function useStreamSupportedChains(options) {
+  return (0, import_react_query13.useQuery)(createQueryOptions(streamsQueries.supportedChains, options));
+}
+function useRequestStreamSignature(options) {
+  return (0, import_react_query13.useMutation)({
+    mutationFn: ({ organizationId, data }) => requestStreamSignature(organizationId, data),
+    ...options
+  });
+}
+
 // src/v2/swap/useSwapRoute.ts
 var import_react8 = require("react");
 
@@ -2033,9 +2236,9 @@ function useSwapRoute(isEnabled, userAddress, distributorId, options, referralCo
 }
 
 // src/v2/users/hooks.ts
-var import_react_query13 = require("@tanstack/react-query");
+var import_react_query14 = require("@tanstack/react-query");
 function useUserById({ userId, enabled = true }) {
-  return (0, import_react_query13.useQuery)({
+  return (0, import_react_query14.useQuery)({
     ...usersQueries.byId({ userId }),
     ...queryDefaults,
     enabled
@@ -2043,7 +2246,7 @@ function useUserById({ userId, enabled = true }) {
 }
 function useUserPortfolio({ userId, enabled = true }) {
   const input = { userId };
-  return (0, import_react_query13.useQuery)({
+  return (0, import_react_query14.useQuery)({
     ...usersQueries.portfolio(input),
     ...queryDefaults,
     enabled
@@ -2071,7 +2274,7 @@ function TurtleHooksProvider({
 }
 
 // src/v2/index.ts
-var queries = (0, import_query_key_factory13.mergeQueryKeys)(
+var queries = (0, import_query_key_factory14.mergeQueryKeys)(
   opportunitiesQueries,
   earnOpportunitiesQueries,
   earnRouteQueries,
@@ -2080,6 +2283,7 @@ var queries = (0, import_query_key_factory13.mergeQueryKeys)(
   productsQueries,
   ensoBalancesQueries,
   widgetQueries,
+  streamsQueries,
   supportedChainsQueries,
   supportedTokensQueries,
   usersQueries
@@ -2130,6 +2334,11 @@ var queries = (0, import_query_key_factory13.mergeQueryKeys)(
   getPortfolioBalance,
   getProducts,
   getSourcePriority,
+  getStreams,
+  getStreamsOutputSchema,
+  getStreamsQuerySchema,
+  getStreamsSupportedChains,
+  getStreamsSupportedChainsOutputSchema,
   getSupportedChains,
   getSupportedTokens,
   getUserById,
@@ -2158,10 +2367,16 @@ var queries = (0, import_query_key_factory13.mergeQueryKeys)(
   productSchema,
   productsQueries,
   queries,
+  requestStreamSignature,
   routeToken,
   routerStep,
   routerSubstep,
+  snapshotSchema,
   stepTx,
+  streamSchema,
+  streamSignatureRequestInputSchema,
+  streamSignatureRequestOutputSchema,
+  streamsQueries,
   supportedChainsQueries,
   supportedChainsResponseSchema,
   supportedTokenSchema,
@@ -2187,6 +2402,9 @@ var queries = (0, import_query_key_factory13.mergeQueryKeys)(
   usePortfolioBalance,
   useProduct,
   useProducts,
+  useRequestStreamSignature,
+  useStreamSupportedChains,
+  useStreams,
   useSupportedChains,
   useSupportedTokens,
   useSwapRoute,