@turtleclub/hooks 0.5.0-beta.98 → 0.5.0-beta.99

package/src/v2/streams/hooks.ts

@@ -6,11 +6,9 @@ import {
   DeleteStreamOutput,
   DeleteStreamInput,
   GetStreamsQuery,
-  PauseStreamSnapshotComputationInput,
-  PauseStreamSnapshotComputationOutput,
-  StopStreamInput,
-  StopStreamOutput,
   Stream,
+  UpdateStreamInput,
+  UpdateStreamOutput,
   StreamsSupportedChainsResponse,
   StreamWallet,
   StreamWalletDetails,
@@ -44,17 +42,8 @@ export type UseStreamSupportedChainsOptions = Omit<
   "queryKey" | "queryFn"
 >;
 
-export type UsePauseStreamSnapshotComputationOptions = Omit<
-  UseMutationOptions<
-    PauseStreamSnapshotComputationOutput,
-    Error,
-    PauseStreamSnapshotComputationInput
-  >,
-  "mutationFn"
->;
-
-export type UseStopStreamOptions = Omit<
-  UseMutationOptions<StopStreamOutput, Error, StopStreamInput>,
+export type UseUpdateStreamOptions = Omit<
+  UseMutationOptions<UpdateStreamOutput, Error, UpdateStreamInput>,
   "mutationFn"
 >;
 
@@ -113,18 +102,9 @@ export function useStreamSupportedChains({
   return useQuery(createQueryOptions(streamsQueries.supportedChains, options));
 }
 
-export function usePauseStreamSnapshotComputation(
-  options?: UsePauseStreamSnapshotComputationOptions
-) {
-  return useMutation({
-    mutationFn: streamsMutations.pauseSnapshotComputation,
-    ...options,
-  });
-}
-
-export function useStopStream(options?: UseStopStreamOptions) {
+export function useUpdateStream(options?: UseUpdateStreamOptions) {
   return useMutation({
-    mutationFn: streamsMutations.stop,
+    mutationFn: streamsMutations.update,
     ...options,
   });
 }

package/src/v2/streams/mutations.ts

@@ -1,20 +1,7 @@
-import { deleteStream, pauseStreamSnapshotComputation, stopStream } from "./api";
-import {
-  DeleteStreamInput,
-  PauseStreamSnapshotComputationInput,
-  StopStreamInput,
-} from "./schemas";
+import { deleteStream, updateStream } from "./api";
+import { DeleteStreamInput, UpdateStreamInput } from "./schemas";
 
 export const streamsMutations = {
-  pauseSnapshotComputation: (input: PauseStreamSnapshotComputationInput) =>
-    pauseStreamSnapshotComputation(input.organizationId, {
-      streamId: input.streamId,
-      snapshotComputationPaused: input.snapshotComputationPaused,
-    }),
-  stop: (input: StopStreamInput) =>
-    stopStream(input.organizationId, {
-      streamId: input.streamId,
-      stopStream: input.stopStream,
-    }),
+  update: ({ organizationId, ...body }: UpdateStreamInput) => updateStream(organizationId, body),
   deleteStream: (input: DeleteStreamInput) => deleteStream(input.organizationId, input.streamId),
 };

package/src/v2/streams/schemas.ts

@@ -17,6 +17,12 @@ const snapshotCustomArgsTokensPerDaySchema = customArgsBaseSchema.extend({
   tokensPerDay: z.string(),
 });
 
+const snapshotCustomArgsSchema = z.union([
+  snapshotCustomArgsTokensPerUsdSchema,
+  snapshotCustomArgsAprSchema,
+  snapshotCustomArgsTokensPerDaySchema,
+]);
+
 // Schemes for STREAM (with mandatory targetToken)
 const streamCustomArgsTokensPerUsdSchema = snapshotCustomArgsTokensPerUsdSchema.extend({
   targetToken: supportedTokenSchema,
@@ -28,6 +34,32 @@ const streamCustomArgsTokensPerDaySchema = snapshotCustomArgsTokensPerDaySchema.
   targetToken: supportedTokenSchema,
 });
 
+const streamCustomArgsSchema = z.union([
+  streamCustomArgsTokensPerUsdSchema,
+  streamCustomArgsAprSchema,
+  streamCustomArgsTokensPerDaySchema,
+]);
+
+const updateStreamCustomArgsBaseSchema = z.object({
+  targetTokenId: z.string().uuid().optional(),
+});
+
+const updateStreamCustomArgsTokensPerUsdSchema = updateStreamCustomArgsBaseSchema.extend({
+  tokensPerUSD: z.string(),
+});
+const updateStreamCustomArgsAprSchema = updateStreamCustomArgsBaseSchema.extend({
+  apr: z.string(),
+});
+const updateStreamCustomArgsTokensPerDaySchema = updateStreamCustomArgsBaseSchema.extend({
+  tokensPerDay: z.string(),
+});
+
+export const updateStreamCustomArgsSchema = z.union([
+  updateStreamCustomArgsTokensPerUsdSchema,
+  updateStreamCustomArgsAprSchema,
+  updateStreamCustomArgsTokensPerDaySchema,
+]);
+
 export const snapshotSchema = z.object({
   amountBase: z.string(),
   amountDistributed: z.string(),
@@ -43,13 +75,7 @@ export const snapshotSchema = z.object({
   turtleTvl: z.string().nullable().optional(),
   turtleNetTvl: z.string().nullable().optional(),
   customMetrics: z.record(z.unknown()).optional(),
-  customArgs: z
-    .union([
-      snapshotCustomArgsTokensPerUsdSchema,
-      snapshotCustomArgsAprSchema,
-      snapshotCustomArgsTokensPerDaySchema,
-    ])
-    .optional(),
+  customArgs: snapshotCustomArgsSchema.optional(),
 });
 
 export const streamPointSchema = z.object({
@@ -139,11 +165,7 @@ export const streamSchema = z.object({
   contractAddress: z.string().nullable(),
   createdAt: z.string().datetime(),
   creationConfirmedAt: z.string().datetime().nullable(),
-  customArgs: z.union([
-    streamCustomArgsTokensPerUsdSchema,
-    streamCustomArgsAprSchema,
-    streamCustomArgsTokensPerDaySchema,
-  ]),
+  customArgs: streamCustomArgsSchema,
   endTimestamp: z.string().datetime().nullable(),
   fee: feeSchema.nullable(),
   hashCommitmentPaused: z.boolean(),
@@ -204,16 +226,7 @@ export const getStreamsSupportedChainsOutputSchema = z.object({
 export const streamSignatureRequestInputSchema = z.object({
   adapters: adaptersSchema,
   chainId: z.number().nullable(),
-  customArgs: z.intersection(
-    z.object({
-      targetTokenId: z.string().uuid(),
-    }),
-    z.union([
-      z.object({ tokensPerUSD: z.string() }),
-      z.object({ apr: z.string() }),
-      z.object({ tokensPerDay: z.string() }),
-    ])
-  ),
+  customArgs: snapshotCustomArgsSchema,
   endTimestamp: z.string().nullable(),
   pointId: z.string().uuid().nullable(),
   rewardToken: z.string().nullable(),
@@ -305,40 +318,52 @@ export const getStreamWalletDetailsResponseSchema = z.object({
   wallet: streamWalletDetailsSchema,
 });
 
-export const pauseStreamSnapshotComputationInputSchema = z.object({
-  organizationId: z.string().uuid(),
-  streamId: z.string().uuid(),
-  snapshotComputationPaused: z.boolean(),
+const updateStreamMutableFieldsSchema = z.object({
+  customArgs: updateStreamCustomArgsSchema.optional(),
+  snapshotComputationPaused: z.boolean().optional(),
+  merkleTreeComputationPaused: z.boolean().optional(),
+  hashCommitmentPaused: z.boolean().optional(),
+  stopStream: z.boolean().optional(),
+  endTimestamp: z.string().datetime().nullable().optional(),
+  setNilEndTimestamp: z.boolean().optional(),
 });
 
-export const pauseStreamSnapshotComputationBodySchema = z.object({
+const updateStreamFieldsSchema = z.object({
   streamId: z.string().uuid(),
-  snapshotComputationPaused: z.boolean(),
 });
 
-export const stopStreamInputSchema = z.object({
+const updateStreamBodyBaseSchema = updateStreamFieldsSchema.merge(updateStreamMutableFieldsSchema);
+
+type UpdateStreamMutableFields = z.infer<typeof updateStreamMutableFieldsSchema>;
+
+const hasUpdateStreamFields = (input: UpdateStreamMutableFields) => {
+  return Object.values(input).some((value) => value !== undefined);
+};
+
+export const updateStreamBodySchema = updateStreamBodyBaseSchema.refine(
+  ({ streamId: _streamId, ...updateFields }: z.infer<typeof updateStreamBodyBaseSchema>) =>
+    hasUpdateStreamFields(updateFields),
+  {
+    message: "At least one stream update field must be provided",
+  }
+);
+
+const updateStreamInputBaseSchema = updateStreamBodyBaseSchema.extend({
   organizationId: z.string().uuid(),
-  streamId: z.string().uuid(),
-  stopStream: z.boolean(),
 });
 
-export const stopStreamBodySchema = z.object({
-  streamId: z.string().uuid(),
-  stopStream: z.boolean(),
-});
+export const updateStreamInputSchema = updateStreamInputBaseSchema;
 
 export const deleteStreamInputSchema = z.object({
   organizationId: z.string().uuid(),
   streamId: z.string().uuid(),
 });
 
-const updateStreamOutputSchema = z.object({
+export const updateStreamOutputSchema = z.object({
   success: z.boolean(),
   message: z.string(),
 });
 
-export const pauseStreamSnapshotComputationOutputSchema = updateStreamOutputSchema;
-export const stopStreamOutputSchema = updateStreamOutputSchema;
 export const deleteStreamOutputSchema = updateStreamOutputSchema;
 
 // --- Types ---
@@ -358,17 +383,9 @@ export type StreamWallet = z.infer<typeof streamWalletSchema>;
 export type StreamWalletDetails = z.infer<typeof streamWalletDetailsSchema>;
 export type PaginationSchema = z.infer<typeof paginationSchema>;
 export type GetStreamsWalletsQuery = z.infer<typeof getStreamWalletsQuerySchema>;
-export type PauseStreamSnapshotComputationInput = z.infer<
-  typeof pauseStreamSnapshotComputationInputSchema
->;
-export type PauseStreamSnapshotComputationBody = z.infer<
-  typeof pauseStreamSnapshotComputationBodySchema
->;
-export type PauseStreamSnapshotComputationOutput = z.infer<
-  typeof pauseStreamSnapshotComputationOutputSchema
->;
-export type StopStreamInput = z.infer<typeof stopStreamInputSchema>;
-export type StopStreamBody = z.infer<typeof stopStreamBodySchema>;
-export type StopStreamOutput = z.infer<typeof stopStreamOutputSchema>;
+export type UpdateStreamCustomArgs = z.infer<typeof updateStreamCustomArgsSchema>;
+export type UpdateStreamInput = z.infer<typeof updateStreamInputSchema>;
+export type UpdateStreamBody = z.infer<typeof updateStreamBodySchema>;
+export type UpdateStreamOutput = z.infer<typeof updateStreamOutputSchema>;
 export type DeleteStreamInput = z.infer<typeof deleteStreamInputSchema>;
 export type DeleteStreamOutput = z.infer<typeof deleteStreamOutputSchema>;