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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@turtleclub/hooks",
   "type": "module",
-  "version": "0.5.0-beta.6",
+  "version": "0.5.0-beta.8",
   "license": "MIT",
   "exports": {
     ".": {
@@ -54,5 +54,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "5389f1f8eb2c56a1de8f7227b3fd379bfc7ecce9"
+  "gitHead": "0b675d696684bba909e149eb26fb4bba7322a82e"
 }

package/src/v2/lib/query-config.ts

@@ -1,9 +1,21 @@
+import { QueryFunction, UseQueryOptions } from "@tanstack/react-query";
+
 // Default TanStack Query configuration
 // Override per-query as needed
-
 export const queryDefaults = {
   staleTime: 5 * 60 * 1000, // 5 minutes - data is fresh
   gcTime: 10 * 60 * 1000, // 10 minutes - cache garbage collection (formerly cacheTime)
   retry: 1, // Retry failed requests once
   refetchOnWindowFocus: false, // Don't refetch on tab focus
 } as const;
+
+export function createQueryOptions<TData, TError = Error>(
+  queryConfig: { queryKey: readonly unknown[]; queryFn: QueryFunction<TData, any> },
+  options?: Omit<UseQueryOptions<TData, TError>, "queryKey" | "queryFn">
+) {
+  return {
+    ...queryDefaults,
+    ...queryConfig,
+    ...options,
+  } as UseQueryOptions<TData, TError, TData, any>;
+}

package/src/v2/schemas/shared.ts

@@ -21,9 +21,9 @@ export const tokenSchema = z.object({
   logoUrl: z.string().optional(),
   isNative: z.boolean(),
   priceUsd: z.number().optional(),
-  price: z.number().optional(),
-  amount: z.number().optional(),
-  rawAmount: z.number().optional(),
+  price: z.string().optional(),
+  amount: z.string().optional(),
+  rawAmount: z.string().optional(),
 });
 
 export const organizationSchema = z.object({

package/src/v2/streams/api.ts

@@ -0,0 +1,59 @@
+import { apiClient } from "@/v2";
+import {
+  GetStreamsQuery,
+  getStreamsOutputSchema,
+  StreamsSchema,
+  getSupportedChainsOutputSchema,
+  SupportedChainsResponse,
+  SignatureRequestInput,
+  signatureRequestOutputSchema,
+  SignatureRequestOutput,
+} from "./schemas";
+
+export async function getStreams(query?: GetStreamsQuery): Promise<StreamsSchema["streams"]> {
+  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;
+}
+
+export async function getSupportedChains(): Promise<SupportedChainsResponse["chains"]> {
+  const endpoint = "/streams/supported_chains";
+  const data = await apiClient.fetch(endpoint, { method: "GET" });
+  const result = getSupportedChainsOutputSchema.safeParse(data);
+
+  if (!result.success) {
+    throw new Error(`Failed to parse supported chains: ${result.error.message}`);
+  }
+  return result.data.chains;
+}
+
+export async function signatureRequest(
+  organizationId: string,
+  input: SignatureRequestInput
+): Promise<SignatureRequestOutput> {
+  const endpoint = `/streams/request_signature/${organizationId}`;
+  const data = await apiClient.fetch(endpoint, {
+    method: "POST",
+    body: input,
+  });
+
+  const result = signatureRequestOutputSchema.safeParse(data);
+  if (!result.success) {
+    throw new Error(`Failed to parse signature response: ${result.error.message}`);
+  }
+  return result.data;
+}

package/src/v2/streams/hooks.ts

@@ -0,0 +1,43 @@
+import { useQuery, useMutation, UseMutationOptions, UseQueryOptions } from "@tanstack/react-query";
+import { createQueryOptions } from "../lib/query-config";
+import { streamsQueries } from "./queries";
+import { signatureRequest } from "./api";
+import {
+  GetStreamsQuery,
+  SignatureRequestInput,
+  SignatureRequestOutput,
+  Stream,
+  SupportedChainsResponse,
+} from "./schemas";
+
+export interface UseStreamsOptions
+  extends Omit<UseQueryOptions<Stream[], Error>, "queryKey" | "queryFn"> {
+  query?: GetStreamsQuery;
+}
+
+export function useStreams({ query, ...options }: UseStreamsOptions = {}) {
+  return useQuery(createQueryOptions(streamsQueries.list(query), options));
+}
+
+export interface UseStreamSupportedChainsOptions
+  extends Omit<UseQueryOptions<SupportedChainsResponse["chains"], Error>, "queryKey" | "queryFn"> {}
+
+export function useStreamSupportedChains(options?: UseStreamSupportedChainsOptions) {
+  return useQuery(createQueryOptions(streamsQueries.supportedChains, options));
+}
+
+export function useSignatureRequest(
+  options?: Omit<
+    UseMutationOptions<
+      SignatureRequestOutput,
+      Error,
+      { organizationId: string; data: SignatureRequestInput }
+    >,
+    "mutationFn"
+  >
+) {
+  return useMutation({
+    mutationFn: ({ organizationId, data }) => signatureRequest(organizationId, data),
+    ...options,
+  });
+}

package/src/v2/streams/index.ts

@@ -0,0 +1,11 @@
+// Hooks
+export * from "./hooks";
+
+// Query keys
+export * from "./queries";
+
+// API functions
+export * from "./api";
+
+// Schemas and types
+export * from "./schemas";

package/src/v2/streams/queries.ts

@@ -0,0 +1,14 @@
+import { createQueryKeys } from "@lukemorales/query-key-factory";
+import { getStreams, getSupportedChains } from "./api";
+import { GetStreamsQuery } from "./schemas";
+
+export const streamsQueries = createQueryKeys("streams", {
+  list: (query?: GetStreamsQuery) => ({
+    queryKey: [query ?? "all"],
+    queryFn: () => getStreams(query),
+  }),
+  supportedChains: {
+    queryKey: null,
+    queryFn: () => getSupportedChains(),
+  },
+});

package/src/v2/streams/schemas.ts

@@ -0,0 +1,132 @@
+import { z } from "zod";
+
+// --- Shared & Base Schemas ---
+
+export const snapshotSchema = z.object({
+  amountDistributed: z.string(),
+  createdAt: z.string().datetime(),
+  rootHash: z.string().nullable(),
+  timestamp: z.string().datetime(),
+  updatedAt: z.string().datetime(),
+  userCount: z.number().optional(),
+});
+
+const customArgsTokensPerUsdSchema = z.object({
+  tokensPerUSD: z.string(),
+  targetChainId: z.number(),
+  targetTokenAddress: z.string(),
+});
+
+const customArgsAprSchema = z.object({
+  apr: z.string(),
+  targetChainId: z.number(),
+  targetTokenAddress: z.string(),
+});
+
+export const streamSchema = z.object({
+  admin: z.string(),
+  chainId: z.number(),
+  chargedFee: z.string(),
+  contractAddress: z.string(),
+  createdAt: z.string().datetime(),
+  customArgs: z.union([customArgsTokensPerUsdSchema, customArgsAprSchema]),
+  deletedAt: z.string().datetime().nullable(),
+  endTimestamp: z.string().datetime(),
+  finalizationTimestamp: z.string().datetime(),
+  id: z.string().uuid(),
+  isPaused: z.boolean(),
+  lastSnapshot: snapshotSchema.nullable(),
+  orgId: z.string().uuid(),
+  rewardToken: z.string(),
+  snapshots: z.array(snapshotSchema).optional(),
+  startTimestamp: z.string().datetime(),
+  strategy: z.string(),
+  totalAmount: z.string(),
+  type: z.number(),
+  updatedAt: z.string().datetime(),
+  userId: z.string().uuid(),
+});
+
+// --- API Request/Response Schemas ---
+
+export const getStreamsOutputSchema = z.object({
+  streams: z.array(streamSchema),
+});
+
+export const getSupportedChainsOutputSchema = z.object({
+  success: z.boolean(),
+  chains: z.array(
+    z.object({
+      id: z.string(),
+      name: z.string(),
+      slug: z.string(),
+      chainId: z.number(),
+      logoUrl: z.string(),
+      ecosystem: z.string(),
+      status: z.string(),
+      explorerUrl: z.string(),
+      campaignFactory: z.string(), // Address as string
+    })
+  ),
+});
+
+export const signatureRequestInputSchema = z.object({
+  campaignType: z.number(),
+  chainId: z.number(),
+  customArgs: z.intersection(
+    z.object({
+      targetChainId: z.number(),
+      targetTokenAddress: z.string(),
+    }),
+    z.union([z.object({ tokensPerUsd: z.string() }), z.object({ apr: z.string() })])
+  ),
+  endTimestamp: z.string(),
+  finalizationTimestamp: z.string(),
+  rewardToken: z.string(),
+  startTimestamp: z.string(),
+  totalAmount: z.string(),
+  walletAddress: z.string(),
+});
+
+export const signatureRequestOutputSchema = z.object({
+  success: z.boolean(),
+  message: z.string(),
+  txParams: z.object({
+    chainId: z.number(),
+    sender: z.string(),
+    params: z.object({
+      params: z.object({
+        UserId: z.array(z.number()),
+        OrgId: z.array(z.number()),
+        CampaignType: z.number(),
+        RewardToken: z.string(),
+        TotalAmount: z.number(),
+        FeeBps: z.number(),
+        StartTimestamp: z.number(),
+        EndTimestamp: z.number(),
+        FinalizationTimestamp: z.number(),
+        CampaignData: z.string(),
+      }),
+      signature: z.string(),
+      salt: z.string(),
+      deadline: z.number(),
+    }),
+  }),
+});
+
+export const getStreamsQuerySchema = z.object({
+  streamId: z.string().optional(),
+  userId: z.string().optional(),
+  organizationId: z.string().optional(),
+  withSnapshots: z.boolean().optional(),
+  usersCount: z.boolean().optional(),
+});
+
+// --- Types ---
+
+export type Stream = z.infer<typeof streamSchema>;
+export type StreamsSchema = z.infer<typeof getStreamsOutputSchema>;
+export type SupportedChainsResponse = z.infer<typeof getSupportedChainsOutputSchema>;
+export type SignatureRequestInput = z.infer<typeof signatureRequestInputSchema>;
+export type SignatureRequestOutput = z.infer<typeof signatureRequestOutputSchema>;
+export type GetStreamsQuery = z.infer<typeof getStreamsQuerySchema>;