@turtleclub/hooks 0.5.0-beta.1 → 0.5.0-beta.10

package/dist/index.cjs

@@ -22,7 +22,7 @@ var index_exports = {};
 __export(index_exports, {
   ApiError: () => ApiError,
   BalanceSourcePriority: () => BalanceSourcePriority,
-  TurtleProvider: () => TurtleProvider,
+  TurtleHooksProvider: () => TurtleHooksProvider,
   apiClient: () => apiClient,
   approveStep: () => approveStep,
   asset: () => asset,
@@ -64,28 +64,49 @@ __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,
+  getUserByIdInputSchema: () => getUserByIdInputSchema,
+  getUserByIdOutputSchema: () => getUserByIdOutputSchema,
+  getUserPortfolio: () => getUserPortfolio,
+  getUserTurtlePortfolioInputSchema: () => getUserTurtlePortfolioInputSchema,
+  getUserTurtlePortfolioOutputSchema: () => getUserTurtlePortfolioOutputSchema,
+  getUserTurtlePortfolioPathSchema: () => getUserTurtlePortfolioPathSchema,
   getWalletBalances: () => getWalletBalances,
   getWidgetOpportunities: () => getWidgetOpportunities,
+  holdingsDataSchema: () => holdingsDataSchema,
   incentiveSchema: () => incentiveSchema,
   lendingConfigSchema: () => lendingConfigSchema,
   mergeBalancesByPriority: () => mergeBalancesByPriority,
   opportunitiesQueries: () => opportunitiesQueries,
   opportunitySchema: () => opportunitySchema,
   organizationSchema: () => organizationSchema,
+  paginationMetadataSchema: () => paginationMetadataSchema,
   portfolioBalanceResponseSchema: () => portfolioBalanceResponseSchema,
   portfolioHoldingsSchema: () => portfolioHoldingsSchema,
+  portfolioSchema: () => portfolioSchema,
   portfolioTokenSchema: () => portfolioTokenSchema,
   portfolioWalletSchema: () => portfolioWalletSchema,
   processRouteDetails: () => processRouteDetails,
   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,
@@ -111,16 +132,25 @@ __export(index_exports, {
   usePortfolioBalance: () => usePortfolioBalance,
   useProduct: () => useProduct,
   useProducts: () => useProducts,
+  useRequestStreamSignature: () => useRequestStreamSignature,
+  useStreamSupportedChains: () => useStreamSupportedChains,
+  useStreams: () => useStreams,
   useSupportedChains: () => useSupportedChains,
   useSupportedTokens: () => useSupportedTokens,
   useSwapRoute: () => useSwapRoute,
   useTokenBalance: () => useTokenBalance,
   useUpdateProduct: () => useUpdateProduct,
   useUploadProductLogo: () => useUploadProductLogo,
+  useUserById: () => useUserById,
+  useUserPortfolio: () => useUserPortfolio,
   useWidgetOpportunities: () => useWidgetOpportunities,
+  userEarningsSchema: () => userEarningsSchema,
+  userWithDetailsSchema: () => userWithDetailsSchema,
+  usersQueries: () => usersQueries,
   vaultConfigSchema: () => vaultConfigSchema,
   walletBalanceSchema: () => walletBalanceSchema,
   walletBalancesResponseSchema: () => walletBalancesResponseSchema,
+  walletDataSchema: () => walletDataSchema,
   walletEcosystemEnum: () => walletEcosystemEnum,
   widgetOpportunitiesResponseSchema: () => widgetOpportunitiesResponseSchema,
   widgetQueries: () => widgetQueries
@@ -128,14 +158,14 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/v2/index.ts
-var import_query_key_factory12 = 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");
 
 // src/v2/lib/api-client.ts
-var API_BASE_URL = "https://api.turtle.club";
-var EARN_BASE_URL = "https://earn.turtle.club";
+var API_BASE_URL = "https://api.turtle.xyz";
+var EARN_BASE_URL = "https://earn.turtle.xyz";
 var ApiError = class extends Error {
   constructor(message, status, response) {
     super(message);
@@ -216,11 +246,7 @@ var ApiClient = class _ApiClient {
       if (error instanceof ApiError) {
         throw error;
       }
-      throw new ApiError(
-        error instanceof Error ? error.message : "Unknown error",
-        0,
-        error
-      );
+      throw new ApiError(error instanceof Error ? error.message : "Unknown error", 0, error);
     }
   }
 };
@@ -247,7 +273,10 @@ var tokenSchema = import_zod.z.object({
   decimals: import_zod.z.number(),
   logoUrl: import_zod.z.string().optional(),
   isNative: import_zod.z.boolean(),
-  priceUsd: import_zod.z.number().optional()
+  priceUsd: import_zod.z.number().optional(),
+  price: import_zod.z.string().optional(),
+  amount: import_zod.z.string().optional(),
+  rawAmount: import_zod.z.string().optional()
 });
 var organizationSchema = import_zod.z.object({
   id: import_zod.z.string(),
@@ -320,8 +349,8 @@ var incentiveSchema = import_zod.z.object({
   tokenSupplyAllocation: import_zod.z.number().nullable(),
   yield: import_zod.z.number().nullable()
 });
-var opportunityTypeEnum = import_zod.z.enum(["vault", "lending", "staking"]);
-var opportunityStatusEnum = import_zod.z.enum(["active", "paused", "deprecated"]);
+var opportunityTypeEnum = import_zod.z.enum(["vault", "lending", "staking", "stablecoin", ""]);
+var opportunityStatusEnum = import_zod.z.enum(["active", "paused", "deprecated", "draft", "ended"]);
 var opportunitySchema = import_zod.z.object({
   id: import_zod.z.string().uuid().optional(),
   name: import_zod.z.string(),
@@ -359,6 +388,14 @@ var opportunitySchema = import_zod.z.object({
   exposure: import_zod.z.array(import_zod.z.string()),
   explorerUrl: import_zod.z.string().nullable()
 });
+var paginationMetadataSchema = import_zod.z.object({
+  page: import_zod.z.number().int().min(1).catch(1),
+  limit: import_zod.z.number().int().min(1).max(100),
+  total: import_zod.z.number().int().min(0),
+  total_pages: import_zod.z.number().int().min(1),
+  has_next: import_zod.z.boolean(),
+  has_previous: import_zod.z.boolean()
+});
 
 // src/v2/opportunities/schema.ts
 var import_zod2 = require("zod");
@@ -805,7 +842,7 @@ async function getProducts(filters) {
   const params = new URLSearchParams();
   if (filters?.organizationId) params.append("organizationId", filters.organizationId);
   const queryString = params.toString();
-  const endpoint = `/admin/products${queryString ? `?${queryString}` : ""}`;
+  const endpoint = `/turtle/products${queryString ? `?${queryString}` : ""}`;
   const data = await apiClient.fetch(endpoint, {
     method: "GET"
   });
@@ -817,7 +854,7 @@ async function getProducts(filters) {
   return result.data;
 }
 async function getProduct(id) {
-  const endpoint = `/admin/products/${id}`;
+  const endpoint = `/turtle/products/${id}`;
   const data = await apiClient.fetch(endpoint, {
     method: "GET"
   });
@@ -984,13 +1021,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
@@ -1008,7 +1212,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()
@@ -1016,18 +1220,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
@@ -1051,13 +1255,121 @@ 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)
   })
 });
 
+// src/v2/users/queries.ts
+var import_query_key_factory12 = require("@lukemorales/query-key-factory");
+
+// src/v2/users/schemas.ts
+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_zod13.z.object({
+  amount: import_zod13.z.number(),
+  usdValue: import_zod13.z.number(),
+  token: tokenSchema.nullish()
+});
+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_zod13.z.object({
+  userId: import_zod13.z.string().uuid()
+});
+var getUserByIdInputSchema = import_zod13.z.object({
+  userId: import_zod13.z.string().uuid()
+});
+var getUserByIdOutputSchema = import_zod13.z.object({
+  user: userWithDetailsSchema.nullable(),
+  error: import_zod13.z.string().optional()
+});
+
+// src/v2/users/api.ts
+async function getUserById(input) {
+  console.log("input", input);
+  const endpoint = `/admin/users/${input.userId}`;
+  const data = await apiClient.fetch(endpoint, {
+    method: "GET"
+  });
+  const result = getUserByIdOutputSchema.safeParse(data);
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to parse user: ${result.error.message}`);
+  }
+  return result.data;
+}
+async function getUserPortfolio(input) {
+  const endpoint = `/admin/users/${input.userId}/portfolio`;
+  const data = await apiClient.fetch(endpoint, {
+    method: "GET"
+  });
+  const result = getUserTurtlePortfolioOutputSchema.safeParse(data);
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(`Failed to parse user portfolio: ${result.error.message}`);
+  }
+  return result.data;
+}
+
+// src/v2/users/queries.ts
+var usersQueries = (0, import_query_key_factory12.createQueryKeys)("users", {
+  byId: (input) => ({
+    queryKey: [input.userId],
+    queryFn: () => getUserById(input)
+  }),
+  portfolio: (input) => ({
+    queryKey: ["portfolio", input.userId],
+    queryFn: () => getUserPortfolio(input)
+  })
+});
+
 // src/v2/earn-opportunities/hooks.ts
 var import_react_query = require("@tanstack/react-query");
 
@@ -1072,6 +1384,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() {
@@ -1303,33 +1622,33 @@ var BalanceSourcePriority = /* @__PURE__ */ ((BalanceSourcePriority2) => {
 })(BalanceSourcePriority || {});
 
 // src/v2/balance/schema.ts
-var import_zod12 = require("zod");
-var portfolioTokenSchema = import_zod12.z.object({
-  id: import_zod12.z.string(),
-  address: import_zod12.z.string(),
-  name: import_zod12.z.string(),
-  symbol: import_zod12.z.string(),
-  decimals: import_zod12.z.number(),
-  isNative: import_zod12.z.boolean(),
-  logoUrl: import_zod12.z.string().nullable(),
-  amount: import_zod12.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_zod12.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_zod12.z.object({
-  id: import_zod12.z.string().optional(),
-  address: import_zod12.z.string(),
-  blockchain: import_zod12.z.string().optional(),
-  tokens: import_zod12.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_zod12.z.object({
-  wallets: import_zod12.z.array(portfolioWalletSchema)
+var portfolioHoldingsSchema = import_zod14.z.object({
+  wallets: import_zod14.z.array(portfolioWalletSchema)
 });
-var portfolioBalanceResponseSchema = import_zod12.z.object({
-  portfolio: import_zod12.z.object({
+var portfolioBalanceResponseSchema = import_zod14.z.object({
+  portfolio: import_zod14.z.object({
     holdings: portfolioHoldingsSchema
   })
 });
@@ -1350,8 +1669,8 @@ async function getPortfolioBalance(address, options) {
 }
 
 // src/v2/balance/queries.ts
-var import_query_key_factory11 = require("@lukemorales/query-key-factory");
-var balanceQueries = (0, import_query_key_factory11.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],
@@ -1799,6 +2118,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");
 
@@ -1897,10 +2231,28 @@ function useSwapRoute(isEnabled, userAddress, distributorId, options, referralCo
   };
 }
 
+// src/v2/users/hooks.ts
+var import_react_query14 = require("@tanstack/react-query");
+function useUserById({ userId, enabled = true }) {
+  return (0, import_react_query14.useQuery)({
+    ...usersQueries.byId({ userId }),
+    ...queryDefaults,
+    enabled
+  });
+}
+function useUserPortfolio({ userId, enabled = true }) {
+  const input = { userId };
+  return (0, import_react_query14.useQuery)({
+    ...usersQueries.portfolio(input),
+    ...queryDefaults,
+    enabled
+  });
+}
+
 // src/v2/lib/turtle-provider.tsx
 var import_react9 = require("react");
 var import_jsx_runtime = require("react/jsx-runtime");
-function TurtleProvider({
+function TurtleHooksProvider({
   children,
   apiUrl,
   earnUrl,
@@ -1918,7 +2270,7 @@ function TurtleProvider({
 }
 
 // src/v2/index.ts
-var queries = (0, import_query_key_factory12.mergeQueryKeys)(
+var queries = (0, import_query_key_factory14.mergeQueryKeys)(
   opportunitiesQueries,
   earnOpportunitiesQueries,
   earnRouteQueries,
@@ -1927,14 +2279,16 @@ var queries = (0, import_query_key_factory12.mergeQueryKeys)(
   productsQueries,
   ensoBalancesQueries,
   widgetQueries,
+  streamsQueries,
   supportedChainsQueries,
-  supportedTokensQueries
+  supportedTokensQueries,
+  usersQueries
 );
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ApiError,
   BalanceSourcePriority,
-  TurtleProvider,
+  TurtleHooksProvider,
   apiClient,
   approveStep,
   asset,
@@ -1976,28 +2330,49 @@ var queries = (0, import_query_key_factory12.mergeQueryKeys)(
   getPortfolioBalance,
   getProducts,
   getSourcePriority,
+  getStreams,
+  getStreamsOutputSchema,
+  getStreamsQuerySchema,
+  getStreamsSupportedChains,
+  getStreamsSupportedChainsOutputSchema,
   getSupportedChains,
   getSupportedTokens,
+  getUserById,
+  getUserByIdInputSchema,
+  getUserByIdOutputSchema,
+  getUserPortfolio,
+  getUserTurtlePortfolioInputSchema,
+  getUserTurtlePortfolioOutputSchema,
+  getUserTurtlePortfolioPathSchema,
   getWalletBalances,
   getWidgetOpportunities,
+  holdingsDataSchema,
   incentiveSchema,
   lendingConfigSchema,
   mergeBalancesByPriority,
   opportunitiesQueries,
   opportunitySchema,
   organizationSchema,
+  paginationMetadataSchema,
   portfolioBalanceResponseSchema,
   portfolioHoldingsSchema,
+  portfolioSchema,
   portfolioTokenSchema,
   portfolioWalletSchema,
   processRouteDetails,
   productSchema,
   productsQueries,
   queries,
+  requestStreamSignature,
   routeToken,
   routerStep,
   routerSubstep,
+  snapshotSchema,
   stepTx,
+  streamSchema,
+  streamSignatureRequestInputSchema,
+  streamSignatureRequestOutputSchema,
+  streamsQueries,
   supportedChainsQueries,
   supportedChainsResponseSchema,
   supportedTokenSchema,
@@ -2023,16 +2398,25 @@ var queries = (0, import_query_key_factory12.mergeQueryKeys)(
   usePortfolioBalance,
   useProduct,
   useProducts,
+  useRequestStreamSignature,
+  useStreamSupportedChains,
+  useStreams,
   useSupportedChains,
   useSupportedTokens,
   useSwapRoute,
   useTokenBalance,
   useUpdateProduct,
   useUploadProductLogo,
+  useUserById,
+  useUserPortfolio,
   useWidgetOpportunities,
+  userEarningsSchema,
+  userWithDetailsSchema,
+  usersQueries,
   vaultConfigSchema,
   walletBalanceSchema,
   walletBalancesResponseSchema,
+  walletDataSchema,
   walletEcosystemEnum,
   widgetOpportunitiesResponseSchema,
   widgetQueries