@turtleclub/hooks 0.5.0-beta.12 → 0.5.0-beta.14

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@turtleclub/hooks",
   "type": "module",
-  "version": "0.5.0-beta.12",
+  "version": "0.5.0-beta.14",
   "license": "MIT",
   "exports": {
     ".": {
@@ -54,5 +54,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "aa9845b493cc2633e82bb9f94d76a9bc117af7fb"
+  "gitHead": "1c079d74e9530d05b212ee03ee221e668ae3ce96"
 }

package/src/v2/covers/api.ts

@@ -0,0 +1,23 @@
+import { apiClient } from "../lib/api-client";
+import type { CoverRequestData, SubmitCoverRequestResponse } from "./schema";
+import { submitCoverRequestResponseSchema } from "./schema";
+
+// POST /turtle/nexus-cover-requests
+export async function submitCoverRequest(
+   data: CoverRequestData
+): Promise<SubmitCoverRequestResponse> {
+   const response = await apiClient.fetch("/turtle/nexus-cover-requests", {
+      method: "POST",
+      body: data,
+   });
+
+   const result = submitCoverRequestResponseSchema.safeParse(response);
+
+   if (!result.success) {
+      console.log("[ZOD ERROR]", result.error);
+      throw new Error(`Failed to submit cover request due to an invalid server response.`);
+   }
+
+   return result.data;
+}
+

package/src/v2/covers/hooks.ts

@@ -0,0 +1,20 @@
+import { useMutation } from "@tanstack/react-query";
+import { submitCoverRequest } from "./api";
+
+export interface UseSubmitCoverRequestOptions {
+   onSuccess?: (message: string) => void;
+   onError?: (message: string) => void;
+}
+
+export function useSubmitCoverRequest(options?: UseSubmitCoverRequestOptions) {
+   return useMutation({
+      mutationFn: submitCoverRequest,
+      onSuccess: () => {
+         options?.onSuccess?.("Cover request submitted successfully!");
+      },
+      onError: (error) => {
+         console.error("[useSubmitCoverRequest]", error);
+         options?.onError?.("Failed to submit Cover Request");
+      },
+   });
+}

package/src/v2/covers/index.ts

@@ -0,0 +1,13 @@
+// Hooks
+export { useSubmitCoverRequest } from "./hooks";
+export type { UseSubmitCoverRequestOptions } from "./hooks";
+
+// API functions
+export { submitCoverRequest } from "./api";
+
+// Schemas
+export { coverRequestDataSchema, submitCoverRequestResponseSchema } from "./schema";
+
+// Types
+export type { CoverRequestData, SubmitCoverRequestResponse } from "./schema";
+

package/src/v2/covers/schema.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+
+export const coverRequestDataSchema = z.object({
+   protocolName: z.string(),
+   coverageAmount: z.string(),
+   periodDays: z.number(),
+   desiredApySacrifice: z.string(),
+   calculatedEstimatedPremium: z.string(),
+   tokenSymbol: z.string(),
+});
+
+
+export const submitCoverRequestResponseSchema = z.object({
+   success: z.boolean(),
+});
+
+
+export type CoverRequestData = z.infer<typeof coverRequestDataSchema>;
+export type SubmitCoverRequestResponse = z.infer<typeof submitCoverRequestResponseSchema>;
+

package/src/v2/earn-interactions/api.ts

@@ -0,0 +1,70 @@
+import { apiClient } from "../lib/api-client";
+import {
+  interactionResponseSchema,
+  type InteractionResponse,
+  type InteractionParams,
+} from "./schema";
+
+// Supported interaction types
+type InteractionType = "deposit" | "withdraw" | "claimWithdraw";
+
+// Helper to build query string from interaction params
+function buildInteractionQuery(
+  params: Omit<InteractionParams, "opportunityId">
+): string {
+  const searchParams = new URLSearchParams({
+    userAddress: params.userAddress,
+    tokenIn: params.tokenIn,
+    amount: params.amount,
+    distributorId: params.distributorId,
+  });
+
+  if (params.referralCode) {
+    searchParams.set("referralCode", params.referralCode);
+  }
+
+  if (params.slippageBps !== undefined) {
+    searchParams.set("slippageBps", params.slippageBps.toString());
+  }
+
+  return searchParams.toString();
+}
+
+// Generic interaction creator - DRY helper
+async function createInteraction(
+  interactionType: InteractionType,
+  params: InteractionParams
+): Promise<InteractionResponse> {
+  const { opportunityId, ...queryParams } = params;
+  const query = buildInteractionQuery(queryParams);
+
+  const data = await apiClient.fetch(
+    `/v1/interactions/${interactionType}/${opportunityId}?${query}`,
+    {
+      method: "POST",
+      domain: "earn",
+    }
+  );
+
+  const result = interactionResponseSchema.safeParse(data);
+
+  if (result.success === false) {
+    console.log("[ZOD ERROR]", result.error);
+    throw new Error(
+      `Failed to parse ${interactionType} interaction: ${result.error.message}`
+    );
+  }
+  return result.data;
+}
+
+// POST /v1/interactions/deposit/{opportunityId}
+export const createDepositInteraction = (params: InteractionParams) =>
+  createInteraction("deposit", params);
+
+// POST /v1/interactions/withdraw/{opportunityId}
+export const createWithdrawInteraction = (params: InteractionParams) =>
+  createInteraction("withdraw", params);
+
+// POST /v1/interactions/claimWithdraw/{opportunityId}
+export const createClaimWithdrawInteraction = (params: InteractionParams) =>
+  createInteraction("claimWithdraw", params);

package/src/v2/earn-interactions/hooks.ts

@@ -0,0 +1,57 @@
+import { useMutation, type UseMutationOptions } from "@tanstack/react-query";
+import {
+  createDepositInteraction,
+  createWithdrawInteraction,
+  createClaimWithdrawInteraction,
+} from "./api";
+import type { InteractionResponse, InteractionParams } from "./schema";
+
+// Re-export param types for convenience
+export type {
+  InteractionParams,
+  CreateDepositInteractionParams,
+  CreateWithdrawInteractionParams,
+  CreateClaimWithdrawInteractionParams,
+} from "./schema";
+
+// Hook options type alias for cleaner signatures
+type InteractionMutationOptions = Omit<
+  UseMutationOptions<InteractionResponse, Error, InteractionParams>,
+  "mutationFn"
+>;
+
+// Higher-order function to create interaction hooks - DRY helper
+function createInteractionHook(
+  mutationFn: (params: InteractionParams) => Promise<InteractionResponse>
+) {
+  return function useInteraction(options?: InteractionMutationOptions) {
+    return useMutation({
+      mutationFn,
+      ...options,
+    });
+  };
+}
+
+/**
+ * Hook for creating a deposit interaction
+ * POST /v1/interactions/deposit/{opportunityId}
+ */
+export const useCreateDepositInteraction = createInteractionHook(
+  createDepositInteraction
+);
+
+/**
+ * Hook for creating a withdraw interaction
+ * POST /v1/interactions/withdraw/{opportunityId}
+ */
+export const useCreateWithdrawInteraction = createInteractionHook(
+  createWithdrawInteraction
+);
+
+/**
+ * Hook for creating a claim withdraw interaction
+ * POST /v1/interactions/claimWithdraw/{opportunityId}
+ */
+export const useCreateClaimWithdrawInteraction = createInteractionHook(
+  createClaimWithdrawInteraction
+);

package/src/v2/earn-interactions/index.ts

@@ -0,0 +1,4 @@
+export * from "./schema";
+export * from "./api";
+export * from "./queries";
+export * from "./hooks";

package/src/v2/earn-interactions/queries.ts

@@ -0,0 +1,8 @@
+import { createQueryKeys } from "@lukemorales/query-key-factory";
+// Note: Interactions are mutations (POST), so no query keys are needed for fetching.
+// This file exists for consistency and potential future GET endpoints.
+
+export const earnInteractionsQueries = createQueryKeys("earnInteractions", {
+  // Placeholder for potential future GET endpoints
+  // e.g., getting interaction history
+});

package/src/v2/earn-interactions/schema.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+
+// ============================================================================
+// Response Schemas
+// ============================================================================
+
+// Transaction schema - matches V1InteractionResponse.transactions[].transaction
+export const transactionSchema = z.object({
+  chainId: z.number().int(),
+  data: z.string(),
+  to: z.string(),
+  value: z.string(),
+  gasLimit: z.string().optional(),
+});
+
+// Transaction response item - matches TypesTxResponseItem
+export const txResponseItemSchema = z.object({
+  type: z.string().optional(),
+  description: z.string().optional(),
+  transaction: transactionSchema,
+});
+
+// Interaction response - matches V1InteractionResponse
+export const interactionResponseSchema = z.object({
+  transactions: z.array(txResponseItemSchema).nullable(),
+});
+
+// ============================================================================
+// Request Params (shared base - all interactions use same params)
+// ============================================================================
+
+export interface InteractionParams {
+  /** Opportunity unique identifier (path param) */
+  opportunityId: string;
+  /** User wallet address */
+  userAddress: string;
+  /** Input token address */
+  tokenIn: string;
+  /** Amount in smallest unit (wei) */
+  amount: string;
+  /** Distributor ID */
+  distributorId: string;
+  /** Optional referral code */
+  referralCode?: string;
+  /** Slippage tolerance in basis points (default: 50 = 0.5%) */
+  slippageBps?: number;
+}
+
+// Type aliases for semantic clarity
+export type CreateDepositInteractionParams = InteractionParams;
+export type CreateWithdrawInteractionParams = InteractionParams;
+export type CreateClaimWithdrawInteractionParams = InteractionParams;
+
+// ============================================================================
+// Type Exports
+// ============================================================================
+
+export type Transaction = z.infer<typeof transactionSchema>;
+export type TxResponseItem = z.infer<typeof txResponseItemSchema>;
+export type InteractionResponse = z.infer<typeof interactionResponseSchema>;

package/src/v2/index.ts

@@ -4,6 +4,7 @@ import { earnOpportunitiesQueries } from "./earn-opportunities/queries";
 import { earnRouteQueries } from "./earn-route/queries";
 import { earnMembershipQueries } from "./earn-membership/queries";
 import { earnDepositsQueries } from "./earn-deposits/queries";
+import { earnInteractionsQueries } from "./earn-interactions/queries";
 import { productsQueries } from "./products/queries";
 import { ensoBalancesQueries } from "./enso-balances/queries";
 import { widgetQueries } from "./widget/queries";
@@ -11,6 +12,7 @@ import { streamsQueries } from "./streams/queries";
 import { supportedChainsQueries } from "./supported-chains/queries";
 import { supportedTokensQueries } from "./supported-tokens/queries";
 import { usersQueries } from "./users/queries";
+import { nftsQueries } from "./nfts/queries";
 
 // Merged query keys for cache invalidation
 export const queries = mergeQueryKeys(
@@ -19,13 +21,15 @@ export const queries = mergeQueryKeys(
   earnRouteQueries,
   earnMembershipQueries,
   earnDepositsQueries,
+  earnInteractionsQueries,
   productsQueries,
   ensoBalancesQueries,
   widgetQueries,
   streamsQueries,
   supportedChainsQueries,
   supportedTokensQueries,
-  usersQueries
+  usersQueries,
+  nftsQueries
 );
 
 // Features - Earn API
@@ -33,6 +37,7 @@ export * from "./earn-opportunities";
 export * from "./earn-route";
 export * from "./earn-membership";
 export * from "./earn-deposits";
+export * from "./earn-interactions";
 export * from "./enso-balances";
 
 // Features
@@ -46,6 +51,8 @@ export * from "./geocheck";
 export * from "./streams";
 export * from "./swap";
 export * from "./users";
+export * from "./nfts";
+export * from "./covers";
 
 // Shared schemas
 export * from "./schemas/shared";

package/src/v2/nfts/api.ts

@@ -0,0 +1,25 @@
+import type { UserNft } from "./schema";
+
+
+const LUMON_API_BASE_URL = "https://lumon.turtle.xyz";
+
+export async function fetchUserNfts(userAddress: string, chain: number): Promise<UserNft[]> {
+   const endpoint = `${LUMON_API_BASE_URL}/query/token/erc721_portfolio`;
+   const response = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+         "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+         user: userAddress,
+         chain,
+      }),
+   });
+
+   if (!response.ok) {
+      throw new Error("Failed to fetch user NFTs");
+   }
+
+   return response.json();
+}
+

package/src/v2/nfts/hooks.ts

@@ -0,0 +1,24 @@
+import { skipToken, useQuery } from "@tanstack/react-query";
+import { createQueryOptions } from "../lib/query-config";
+import { nftsQueries } from "./queries";
+import type { UserNft } from "./schema";
+
+export interface UseUserNftsOptions {
+   userAddress: string | undefined;
+   chain: number;
+   tokenAddress?: string;
+}
+
+export function useUserNfts({ userAddress, chain, tokenAddress }: UseUserNftsOptions) {
+   return useQuery(
+      userAddress
+         ? createQueryOptions(nftsQueries.byUser(userAddress, chain), {
+            select: (data: UserNft[]) =>
+               tokenAddress
+                  ? data.filter((nft) => nft.token.toLowerCase() === tokenAddress.toLowerCase())
+                  : data,
+         })
+         : { queryKey: ["nfts", "byUser", "skip"], queryFn: skipToken }
+   );
+}
+

package/src/v2/nfts/index.ts

@@ -0,0 +1,13 @@
+// Hooks
+export { useUserNfts } from "./hooks";
+export type { UseUserNftsOptions } from "./hooks";
+
+// Query keys
+export { nftsQueries } from "./queries";
+
+// API functions
+export { fetchUserNfts } from "./api";
+
+// Types
+export type { UserNft, UserNftsFilters } from "./schema";
+

package/src/v2/nfts/queries.ts

@@ -0,0 +1,10 @@
+import { createQueryKeys } from "@lukemorales/query-key-factory";
+import { fetchUserNfts } from "./api";
+
+export const nftsQueries = createQueryKeys("nfts", {
+   byUser: (userAddress: string, chain: number) => ({
+      queryKey: [userAddress, chain],
+      queryFn: () => fetchUserNfts(userAddress, chain),
+   }),
+});
+

package/src/v2/nfts/schema.ts

@@ -0,0 +1,12 @@
+export interface UserNft {
+   user: string;
+   chain: number;
+   token: string;
+   token_id: string;
+   last_transfer: string;
+}
+
+export interface UserNftsFilters {
+   tokenAddress?: string;
+}
+