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

package/dist/index.js

@@ -866,13 +866,180 @@ var widgetQueries = createQueryKeys8("widget", {
   })
 });
 
-// src/v2/supported-chains/queries.ts
+// src/v2/streams/queries.ts
 import { createQueryKeys as createQueryKeys9 } from "@lukemorales/query-key-factory";
 
-// src/v2/supported-chains/schema.ts
+// src/v2/streams/schemas.ts
 import { z as z10 } from "zod";
-var supportedChainsResponseSchema = z10.object({
-  chains: z10.array(chainSchema)
+var snapshotSchema = z10.object({
+  amountDistributed: z10.string(),
+  createdAt: z10.string().datetime(),
+  rootHash: z10.string().nullable(),
+  timestamp: z10.string().datetime(),
+  updatedAt: z10.string().datetime(),
+  userCount: z10.number().optional()
+});
+var customArgsTokensPerUsdSchema = z10.object({
+  tokensPerUSD: z10.string(),
+  targetChainId: z10.number(),
+  targetTokenAddress: z10.string()
+});
+var customArgsAprSchema = z10.object({
+  apr: z10.string(),
+  targetChainId: z10.number(),
+  targetTokenAddress: z10.string()
+});
+var streamSchema = z10.object({
+  admin: z10.string(),
+  chainId: z10.number(),
+  chargedFee: z10.string(),
+  contractAddress: z10.string(),
+  createdAt: z10.string().datetime(),
+  customArgs: z10.union([customArgsTokensPerUsdSchema, customArgsAprSchema]),
+  deletedAt: z10.string().datetime().nullable(),
+  endTimestamp: z10.string().datetime(),
+  finalizationTimestamp: z10.string().datetime(),
+  id: z10.string().uuid(),
+  isPaused: z10.boolean(),
+  lastSnapshot: snapshotSchema.nullable(),
+  orgId: z10.string().uuid(),
+  rewardToken: z10.string(),
+  snapshots: z10.array(snapshotSchema).optional(),
+  startTimestamp: z10.string().datetime(),
+  strategy: z10.string(),
+  totalAmount: z10.string(),
+  type: z10.number(),
+  updatedAt: z10.string().datetime(),
+  userId: z10.string().uuid()
+});
+var getStreamsOutputSchema = z10.object({
+  streams: z10.array(streamSchema)
+});
+var getStreamsSupportedChainsOutputSchema = z10.object({
+  success: z10.boolean(),
+  chains: z10.array(
+    z10.object({
+      id: z10.string(),
+      name: z10.string(),
+      slug: z10.string(),
+      chainId: z10.number(),
+      logoUrl: z10.string(),
+      ecosystem: z10.string(),
+      status: z10.string(),
+      explorerUrl: z10.string(),
+      campaignFactory: z10.string()
+      // Address as string
+    })
+  )
+});
+var streamSignatureRequestInputSchema = z10.object({
+  campaignType: z10.number(),
+  chainId: z10.number(),
+  customArgs: z10.intersection(
+    z10.object({
+      targetChainId: z10.number(),
+      targetTokenAddress: z10.string()
+    }),
+    z10.union([z10.object({ tokensPerUsd: z10.string() }), z10.object({ apr: z10.string() })])
+  ),
+  endTimestamp: z10.string(),
+  finalizationTimestamp: z10.string(),
+  rewardToken: z10.string(),
+  startTimestamp: z10.string(),
+  totalAmount: z10.string(),
+  walletAddress: z10.string()
+});
+var streamSignatureRequestOutputSchema = z10.object({
+  success: z10.boolean(),
+  message: z10.string(),
+  txParams: z10.object({
+    chainId: z10.number(),
+    sender: z10.string(),
+    params: z10.object({
+      params: z10.object({
+        UserId: z10.array(z10.number()),
+        OrgId: z10.array(z10.number()),
+        CampaignType: z10.number(),
+        RewardToken: z10.string(),
+        TotalAmount: z10.number(),
+        FeeBps: z10.number(),
+        StartTimestamp: z10.number(),
+        EndTimestamp: z10.number(),
+        FinalizationTimestamp: z10.number(),
+        CampaignData: z10.string()
+      }),
+      signature: z10.string(),
+      salt: z10.string(),
+      deadline: z10.number()
+    })
+  })
+});
+var getStreamsQuerySchema = z10.object({
+  streamId: z10.string().optional(),
+  userId: z10.string().optional(),
+  organizationId: z10.string().optional(),
+  withSnapshots: z10.boolean().optional(),
+  usersCount: z10.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 = createQueryKeys9("streams", {
+  list: (query) => ({
+    queryKey: [query ?? "all"],
+    queryFn: () => getStreams(query)
+  }),
+  supportedChains: {
+    queryKey: null,
+    queryFn: () => getStreamsSupportedChains()
+  }
+});
+
+// src/v2/supported-chains/queries.ts
+import { createQueryKeys as createQueryKeys10 } from "@lukemorales/query-key-factory";
+
+// src/v2/supported-chains/schema.ts
+import { z as z11 } from "zod";
+var supportedChainsResponseSchema = z11.object({
+  chains: z11.array(chainSchema)
 });
 
 // src/v2/supported-chains/api.ts
@@ -890,7 +1057,7 @@ async function getSupportedChains(options) {
 }
 
 // src/v2/supported-chains/queries.ts
-var supportedChainsQueries = createQueryKeys9("supportedChains", {
+var supportedChainsQueries = createQueryKeys10("supportedChains", {
   all: {
     queryKey: null,
     queryFn: () => getSupportedChains()
@@ -898,18 +1065,18 @@ var supportedChainsQueries = createQueryKeys9("supportedChains", {
 });
 
 // src/v2/supported-tokens/queries.ts
-import { createQueryKeys as createQueryKeys10 } from "@lukemorales/query-key-factory";
+import { createQueryKeys as createQueryKeys11 } from "@lukemorales/query-key-factory";
 
 // src/v2/supported-tokens/schema.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var supportedTokenSchema = tokenSchema.extend({
-  active: z11.boolean()
+  active: z12.boolean()
 });
-var supportedTokensResponseSchema = z11.object({
-  tokens: z11.array(supportedTokenSchema),
-  total: z11.number().optional(),
-  limit: z11.number().optional(),
-  page: z11.number().optional()
+var supportedTokensResponseSchema = z12.object({
+  tokens: z12.array(supportedTokenSchema),
+  total: z12.number().optional(),
+  limit: z12.number().optional(),
+  page: z12.number().optional()
 });
 
 // src/v2/supported-tokens/api.ts
@@ -933,7 +1100,7 @@ async function getSupportedTokens(filters, options) {
 }
 
 // src/v2/supported-tokens/queries.ts
-var supportedTokensQueries = createQueryKeys10("supportedTokens", {
+var supportedTokensQueries = createQueryKeys11("supportedTokens", {
   list: (filters) => ({
     queryKey: [filters],
     queryFn: () => getSupportedTokens(filters)
@@ -941,72 +1108,72 @@ var supportedTokensQueries = createQueryKeys10("supportedTokens", {
 });
 
 // src/v2/users/queries.ts
-import { createQueryKeys as createQueryKeys11 } from "@lukemorales/query-key-factory";
+import { createQueryKeys as createQueryKeys12 } from "@lukemorales/query-key-factory";
 
 // src/v2/users/schemas.ts
-import { z as z12 } from "zod";
-var walletDataSchema = z12.object({
-  address: z12.string(),
-  totalAmountInUSD: z12.string(),
-  tokens: z12.array(tokenSchema)
-});
-var holdingsDataSchema = z12.object({
-  totalAmountInUSD: z12.string(),
-  chains: z12.array(chainSchema).nullish(),
-  wallets: z12.array(walletDataSchema).nullish()
-});
-var userEarningsSchema = z12.object({
-  productId: z12.string().uuid(),
-  value: z12.number(),
-  referralsEarnings: z12.number().nullish(),
-  rewardName: z12.string().nullish(),
-  rewardType: z12.string().nullish()
-});
-var portfolioSchema = z12.object({
-  productsEarnings: z12.array(userEarningsSchema),
+import { z as z13 } from "zod";
+var walletDataSchema = z13.object({
+  address: z13.string(),
+  totalAmountInUSD: z13.string(),
+  tokens: z13.array(tokenSchema)
+});
+var holdingsDataSchema = z13.object({
+  totalAmountInUSD: z13.string(),
+  chains: z13.array(chainSchema).nullish(),
+  wallets: z13.array(walletDataSchema).nullish()
+});
+var userEarningsSchema = z13.object({
+  productId: z13.string().uuid(),
+  value: z13.number(),
+  referralsEarnings: z13.number().nullish(),
+  rewardName: z13.string().nullish(),
+  rewardType: z13.string().nullish()
+});
+var portfolioSchema = z13.object({
+  productsEarnings: z13.array(userEarningsSchema),
   holdings: holdingsDataSchema.nullish()
 });
-var holdingInfoSchema = z12.object({
-  amount: z12.number(),
-  usdValue: z12.number(),
+var holdingInfoSchema = z13.object({
+  amount: z13.number(),
+  usdValue: z13.number(),
   token: tokenSchema.nullish()
 });
-var walletInfoSchema = z12.object({
-  address: z12.string().nullish(),
-  ecosystem: z12.string().nullish(),
-  isMain: z12.boolean().nullish(),
-  holdings: z12.array(holdingInfoSchema).nullish()
-});
-var userWithDetailsSchema = z12.object({
-  id: z12.string(),
-  email: z12.string().nullable(),
-  username: z12.string().nullish(),
-  firstName: z12.string().nullish(),
-  lastName: z12.string().nullish(),
-  avatarUrl: z12.string().nullish(),
-  telegramHandle: z12.string().nullish(),
-  xUsername: z12.string().nullish(),
-  role: z12.string(),
-  createdAt: z12.string(),
-  updatedAt: z12.string(),
-  tags: z12.array(z12.string()).nullish(),
-  wallets: z12.array(walletInfoSchema).nullish()
-});
-var getUserTurtlePortfolioInputSchema = z12.object({
-  userId: z12.string().uuid()
-});
-var getUserTurtlePortfolioOutputSchema = z12.object({
+var walletInfoSchema = z13.object({
+  address: z13.string().nullish(),
+  ecosystem: z13.string().nullish(),
+  isMain: z13.boolean().nullish(),
+  holdings: z13.array(holdingInfoSchema).nullish()
+});
+var userWithDetailsSchema = z13.object({
+  id: z13.string(),
+  email: z13.string().nullable(),
+  username: z13.string().nullish(),
+  firstName: z13.string().nullish(),
+  lastName: z13.string().nullish(),
+  avatarUrl: z13.string().nullish(),
+  telegramHandle: z13.string().nullish(),
+  xUsername: z13.string().nullish(),
+  role: z13.string(),
+  createdAt: z13.string(),
+  updatedAt: z13.string(),
+  tags: z13.array(z13.string()).nullish(),
+  wallets: z13.array(walletInfoSchema).nullish()
+});
+var getUserTurtlePortfolioInputSchema = z13.object({
+  userId: z13.string().uuid()
+});
+var getUserTurtlePortfolioOutputSchema = z13.object({
   portfolio: portfolioSchema
 });
-var getUserTurtlePortfolioPathSchema = z12.object({
-  userId: z12.string().uuid()
+var getUserTurtlePortfolioPathSchema = z13.object({
+  userId: z13.string().uuid()
 });
-var getUserByIdInputSchema = z12.object({
-  userId: z12.string().uuid()
+var getUserByIdInputSchema = z13.object({
+  userId: z13.string().uuid()
 });
-var getUserByIdOutputSchema = z12.object({
+var getUserByIdOutputSchema = z13.object({
   user: userWithDetailsSchema.nullable(),
-  error: z12.string().optional()
+  error: z13.string().optional()
 });
 
 // src/v2/users/api.ts
@@ -1037,7 +1204,7 @@ async function getUserPortfolio(input) {
 }
 
 // src/v2/users/queries.ts
-var usersQueries = createQueryKeys11("users", {
+var usersQueries = createQueryKeys12("users", {
   byId: (input) => ({
     queryKey: [input.userId],
     queryFn: () => getUserById(input)
@@ -1062,6 +1229,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() {
@@ -1293,33 +1467,33 @@ var BalanceSourcePriority = /* @__PURE__ */ ((BalanceSourcePriority2) => {
 })(BalanceSourcePriority || {});
 
 // src/v2/balance/schema.ts
-import { z as z13 } from "zod";
-var portfolioTokenSchema = z13.object({
-  id: z13.string(),
-  address: z13.string(),
-  name: z13.string(),
-  symbol: z13.string(),
-  decimals: z13.number(),
-  isNative: z13.boolean(),
-  logoUrl: z13.string().nullable(),
-  amount: z13.string(),
+import { z as z14 } from "zod";
+var portfolioTokenSchema = z14.object({
+  id: z14.string(),
+  address: z14.string(),
+  name: z14.string(),
+  symbol: z14.string(),
+  decimals: z14.number(),
+  isNative: z14.boolean(),
+  logoUrl: z14.string().nullable(),
+  amount: z14.string(),
   // Portfolio-specific field (decimal format)
-  price: z13.string().nullable().transform((val) => val ? parseFloat(val) : null),
+  price: z14.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 = z13.object({
-  id: z13.string().optional(),
-  address: z13.string(),
-  blockchain: z13.string().optional(),
-  tokens: z13.array(portfolioTokenSchema)
+var portfolioWalletSchema = z14.object({
+  id: z14.string().optional(),
+  address: z14.string(),
+  blockchain: z14.string().optional(),
+  tokens: z14.array(portfolioTokenSchema)
 });
-var portfolioHoldingsSchema = z13.object({
-  wallets: z13.array(portfolioWalletSchema)
+var portfolioHoldingsSchema = z14.object({
+  wallets: z14.array(portfolioWalletSchema)
 });
-var portfolioBalanceResponseSchema = z13.object({
-  portfolio: z13.object({
+var portfolioBalanceResponseSchema = z14.object({
+  portfolio: z14.object({
     holdings: portfolioHoldingsSchema
   })
 });
@@ -1340,8 +1514,8 @@ async function getPortfolioBalance(address, options) {
 }
 
 // src/v2/balance/queries.ts
-import { createQueryKeys as createQueryKeys12 } from "@lukemorales/query-key-factory";
-var balanceQueries = createQueryKeys12("balance", {
+import { createQueryKeys as createQueryKeys13 } from "@lukemorales/query-key-factory";
+var balanceQueries = createQueryKeys13("balance", {
   // Portfolio balance by address
   portfolio: (address) => ({
     queryKey: [address],
@@ -1789,6 +1963,21 @@ function useGeocheck(options = {}) {
   });
 }
 
+// src/v2/streams/hooks.ts
+import { useQuery as useQuery12, useMutation as useMutation3 } from "@tanstack/react-query";
+function useStreams({ query, ...options } = {}) {
+  return useQuery12(createQueryOptions(streamsQueries.list(query), options));
+}
+function useStreamSupportedChains(options) {
+  return useQuery12(createQueryOptions(streamsQueries.supportedChains, options));
+}
+function useRequestStreamSignature(options) {
+  return useMutation3({
+    mutationFn: ({ organizationId, data }) => requestStreamSignature(organizationId, data),
+    ...options
+  });
+}
+
 // src/v2/swap/useSwapRoute.ts
 import { useMemo as useMemo8 } from "react";
 
@@ -1888,9 +2077,9 @@ function useSwapRoute(isEnabled, userAddress, distributorId, options, referralCo
 }
 
 // src/v2/users/hooks.ts
-import { useQuery as useQuery12 } from "@tanstack/react-query";
+import { useQuery as useQuery13 } from "@tanstack/react-query";
 function useUserById({ userId, enabled = true }) {
-  return useQuery12({
+  return useQuery13({
     ...usersQueries.byId({ userId }),
     ...queryDefaults,
     enabled
@@ -1898,7 +2087,7 @@ function useUserById({ userId, enabled = true }) {
 }
 function useUserPortfolio({ userId, enabled = true }) {
   const input = { userId };
-  return useQuery12({
+  return useQuery13({
     ...usersQueries.portfolio(input),
     ...queryDefaults,
     enabled
@@ -1935,6 +2124,7 @@ var queries = mergeQueryKeys(
   productsQueries,
   ensoBalancesQueries,
   widgetQueries,
+  streamsQueries,
   supportedChainsQueries,
   supportedTokensQueries,
   usersQueries
@@ -1984,6 +2174,11 @@ export {
   getPortfolioBalance,
   getProducts,
   getSourcePriority,
+  getStreams,
+  getStreamsOutputSchema,
+  getStreamsQuerySchema,
+  getStreamsSupportedChains,
+  getStreamsSupportedChainsOutputSchema,
   getSupportedChains,
   getSupportedTokens,
   getUserById,
@@ -2012,10 +2207,16 @@ export {
   productSchema,
   productsQueries,
   queries,
+  requestStreamSignature,
   routeToken,
   routerStep,
   routerSubstep,
+  snapshotSchema,
   stepTx,
+  streamSchema,
+  streamSignatureRequestInputSchema,
+  streamSignatureRequestOutputSchema,
+  streamsQueries,
   supportedChainsQueries,
   supportedChainsResponseSchema,
   supportedTokenSchema,
@@ -2041,6 +2242,9 @@ export {
   usePortfolioBalance,
   useProduct,
   useProducts,
+  useRequestStreamSignature,
+  useStreamSupportedChains,
+  useStreams,
   useSupportedChains,
   useSupportedTokens,
   useSwapRoute,