@turtleclub/opportunities 0.1.0-beta.20 → 0.1.0-beta.22

package/src/cover-offer/hooks/useCoverQuote.ts

@@ -1,122 +1,126 @@
-import { useState, useEffect, useCallback } from "react";
-import { parseEther, formatEther } from "viem";
-import type { NexusQuoteResult, CoverQuoteState } from "../types";
-import { CoverAsset, NexusSDK } from "@nexusmutual/sdk";
+import { parseUnits, formatUnits } from "viem";
+import { useQuery } from "@tanstack/react-query";
+import { CoverAsset, GetQuoteResponse } from "@nexusmutual/sdk";
+import { TOKEN_SYMBOL_TO_COVER_ASSET, getOpportunityAPY, calculateAdjustedAPY } from "../utils";
+import type { Opportunity } from "@turtleclub/hooks";
 
 interface UseCoverQuoteOptions {
    productId: number;
    buyerAddress: string;
    amountToCover: string;
-   /** Debounce delay in ms */
-   debounceMs?: number;
+   coverPeriod: number;
+   tokenSymbol: string;
+   decimals: number | undefined;
+   opportunity: Opportunity;
 }
 
-interface UseCoverQuoteReturn extends CoverQuoteState {
-   setCoverPeriod: (period: number) => void;
+interface UseCoverQuoteReturn {
+   isLoading: boolean;
+   error: string | null;
+   quoteResult: GetQuoteResponse | null;
+   premium: string | null;
+   originalAPY: number;
+   adjustedAPY: number | null;
+   coverCostPerc: number | null;
    refetch: () => void;
 }
 
 let nexusSdkInstance: import("@nexusmutual/sdk").NexusSDK | null = null;
-let coverAssetEnum: typeof import("@nexusmutual/sdk").CoverAsset | null = null;
 
 const TERMS_IPFS_CID = "QmXUzXDMbeKSCewUie34vPD7mCAGnshi4ULRy4h7DLmoRS";
 
 async function getNexusSdk() {
-   if (!nexusSdkInstance || !coverAssetEnum) {
-      const { NexusSDK, CoverAsset } = await import("@nexusmutual/sdk");
+   if (!nexusSdkInstance) {
+      const { NexusSDK } = await import("@nexusmutual/sdk");
       nexusSdkInstance = new NexusSDK();
-      coverAssetEnum = CoverAsset;
    }
-
-   return { nexusSdk: nexusSdkInstance, CoverAsset: coverAssetEnum };
+   return nexusSdkInstance;
 }
 
-
 async function fetchNexusQuote(
    productId: number,
    buyerAddress: string,
-   amount: string,
-   period: number
-): Promise<NexusQuoteResult> {
-
-   const { nexusSdk } = await getNexusSdk();
-   const amountWei = parseEther(amount).toString();
+   amountToCover: string,
+   period: number,
+   coverAsset: CoverAsset
+): Promise<GetQuoteResponse> {
+   const nexusSdk = await getNexusSdk();
 
    const { result, error } = await nexusSdk.quote.getQuoteAndBuyCoverInputs({
       productId,
-      amount: amountWei,
+      amount: amountToCover,
       period,
-      coverAsset: CoverAsset.ETH,
-      paymentAsset: CoverAsset.ETH,
+      coverAsset,
+      paymentAsset: coverAsset,
       buyerAddress,
       ipfsCidOrContent: TERMS_IPFS_CID,
    });
 
+
    if (error) {
       throw new Error(error.message || "Failed to fetch Nexus quote");
    }
 
-   return result as NexusQuoteResult;
+   return result as GetQuoteResponse;
 }
 
 export function useCoverQuote({
    productId,
    buyerAddress,
    amountToCover,
-   debounceMs = 500,
+   coverPeriod,
+   tokenSymbol,
+   decimals,
+   opportunity,
 }: UseCoverQuoteOptions): UseCoverQuoteReturn {
-   const [coverPeriod, setCoverPeriod] = useState(30);
-   const [isLoading, setIsLoading] = useState(false);
-   const [error, setError] = useState<string | null>(null);
-   const [quoteResult, setQuoteResult] = useState<NexusQuoteResult | null>(null);
-   const [premiumEth, setPremiumEth] = useState<string | null>(null);
-   const [yearlyCostPerc, setYearlyCostPerc] = useState<number | null>(null);
-
-   const fetchQuote = useCallback(async () => {
-      if (!productId || !buyerAddress || !amountToCover || parseFloat(amountToCover) <= 0) {
-         console.error("Validation failed", productId, buyerAddress, amountToCover, coverPeriod);
-         return;
-      }
-
-      setIsLoading(true);
-      setError(null);
-
-      try {
-         const result = await fetchNexusQuote(productId, buyerAddress, amountToCover, coverPeriod);
-
-         setQuoteResult(result);
-         setPremiumEth(formatEther(BigInt(result.displayInfo.premiumInAsset)));
-         setYearlyCostPerc(result.displayInfo.yearlyCostPerc);
-      } catch (err: unknown) {
-         const errorMessage = err instanceof Error ? err.message : "Failed to fetch quote";
-         console.error("Cover quote error:", err);
-         setError(errorMessage);
-         setQuoteResult(null);
-         setPremiumEth(null);
-         setYearlyCostPerc(null);
-      } finally {
-         setIsLoading(false);
-      }
-   }, [productId, buyerAddress, amountToCover, coverPeriod]);
-
-   // Debounced fetch on input changes
-   useEffect(() => {
-      const timeoutId = setTimeout(() => {
-         fetchQuote();
-      }, debounceMs);
-
-      return () => clearTimeout(timeoutId);
-   }, [fetchQuote, debounceMs]);
+   const coverAsset = TOKEN_SYMBOL_TO_COVER_ASSET[tokenSymbol] ?? CoverAsset.ETH;
+   const originalAPY = getOpportunityAPY(opportunity);
+
+   if (!decimals) {
+      return {
+         isLoading: false,
+         error: "Decimals are required",
+         quoteResult: null,
+         premium: null,
+         originalAPY,
+         adjustedAPY: null,
+         coverCostPerc: null,
+         refetch: () => { },
+      };
+   }
+   const isValidInput =
+      !!productId && !!buyerAddress && !!amountToCover && parseFloat(amountToCover) > 0 && decimals !== undefined;
+
+   const parsedAmount = parseUnits(amountToCover, decimals);
+
+   const {
+      data,
+      isLoading,
+      error: queryError,
+      refetch,
+   } = useQuery({
+      queryKey: ["coverQuote", productId, buyerAddress, parsedAmount.toString(), coverPeriod, tokenSymbol],
+      queryFn: () => fetchNexusQuote(productId, buyerAddress, parsedAmount.toString(), coverPeriod, coverAsset),
+      enabled: isValidInput,
+      select: (result: GetQuoteResponse) => ({
+         quoteResult: result,
+         premium: formatUnits(BigInt(result.displayInfo.premiumInAsset), decimals),
+         yearlyCostPerc: result.displayInfo.yearlyCostPerc,
+      }),
+   });
+
+   const yearlyCostPerc = data?.yearlyCostPerc ?? null;
+   const adjustedAPY = yearlyCostPerc !== null ? calculateAdjustedAPY(originalAPY, yearlyCostPerc) : null;
+   const coverCostPerc = yearlyCostPerc !== null ? yearlyCostPerc * 100 : null;
 
    return {
-      coverPeriod,
-      setCoverPeriod,
       isLoading,
-      error,
-      quoteResult,
-      premiumEth,
-      yearlyCostPerc,
-      refetch: fetchQuote,
+      error: queryError?.message ?? null,
+      quoteResult: data?.quoteResult ?? null,
+      premium: data?.premium ?? null,
+      originalAPY,
+      adjustedAPY,
+      coverCostPerc,
+      refetch,
    };
 }
-

package/src/cover-offer/hooks/useCoverTokenSelection.ts

@@ -0,0 +1,84 @@
+import { useState, useMemo } from "react";
+import { usePortfolioBalance, useTokenBalance } from "@turtleclub/hooks";
+import { NEXUS_AVAILABLE_TOKENS } from "../constants";
+
+type NexusToken = (typeof NEXUS_AVAILABLE_TOKENS)[number];
+
+interface UseCoverTokenSelectionParams {
+  buyerAddress: string;
+  coverAvailableAssets: string[] | undefined;
+  amount: string;
+  setAmount: (amount: string) => void;
+}
+
+interface UseCoverTokenSelectionReturn {
+  filteredTokens: NexusToken[];
+  selectedTokenAddress: string;
+  setSelectedTokenAddress: (address: string) => void;
+  selectedTokenSymbol: string;
+  selectedTokenDecimals: number;
+  selectedTokenBalance: ReturnType<typeof usePortfolioBalance>["balances"][number] | null;
+  usdValue: string | undefined;
+  handleMaxClick: () => void;
+}
+
+export function useCoverTokenSelection({
+  buyerAddress,
+  coverAvailableAssets,
+  amount,
+  setAmount,
+}: UseCoverTokenSelectionParams): UseCoverTokenSelectionReturn {
+  const filteredTokens = useMemo(
+    () =>
+      NEXUS_AVAILABLE_TOKENS.filter((token) =>
+        coverAvailableAssets?.includes(token.symbol)
+      ),
+    [coverAvailableAssets]
+  );
+
+  const [selectedTokenAddress, setSelectedTokenAddress] = useState<string>(
+    filteredTokens[0]?.address || ""
+  );
+
+  const { balances } = usePortfolioBalance({
+    address: buyerAddress,
+  });
+
+  const userEthereumBalances = useMemo(
+    () => balances.filter((balance) => balance.token.chain.chainId === "1"),
+    [balances]
+  );
+
+  const selectedTokenBalance = useMemo(
+    () =>
+      userEthereumBalances.find(
+        (balance) => balance.token.address === selectedTokenAddress
+      ) ?? null,
+    [userEthereumBalances, selectedTokenAddress]
+  );
+
+  const { usdValue, handleMaxClick } = useTokenBalance({
+    tokenBalance: selectedTokenBalance,
+    amount: amount || undefined,
+    setAmount: (newAmount) => setAmount(newAmount ?? ""),
+  });
+
+  const selectedToken = useMemo(
+    () => filteredTokens.find((t) => t.address === selectedTokenAddress),
+    [filteredTokens, selectedTokenAddress]
+  );
+
+  const selectedTokenSymbol = selectedToken?.symbol ?? "ETH";
+  const selectedTokenDecimals = selectedToken?.decimals ?? 18;
+
+  return {
+    filteredTokens,
+    selectedTokenAddress,
+    setSelectedTokenAddress,
+    selectedTokenSymbol,
+    selectedTokenDecimals,
+    selectedTokenBalance,
+    usdValue,
+    handleMaxClick,
+  };
+}

package/src/cover-offer/hooks/useDebouncedValue.ts

@@ -0,0 +1,12 @@
+import { useEffect, useState } from "react";
+
+export function useDebouncedValue<T>(value: T, delay: number): T {
+  const [debouncedValue, setDebouncedValue] = useState(value);
+
+  useEffect(() => {
+    const timer = setTimeout(() => setDebouncedValue(value), delay);
+    return () => clearTimeout(timer);
+  }, [value, delay]);
+
+  return debouncedValue;
+}

package/src/cover-offer/hooks/useExistingCovers.ts

@@ -1,9 +1,9 @@
-import { useState, useEffect, useCallback } from "react";
-import { createPublicClient, http, getAddress } from "viem";
-import { mainnet } from "viem/chains";
+import { useCallback, useMemo } from "react";
+import { getAddress } from "viem";
+import { useReadContract } from "wagmi";
 import nexusSdk from "@nexusmutual/sdk";
-import { useUserCoverNfts, type CoverNft } from "./useUserCoverNfts";
-
+import { useUserCoverNfts } from "./useUserCoverNfts";
+import type { Abi } from "viem";
 // Raw cover data from contract (all numbers are BigInt)
 interface RawCoverData {
    coverId: bigint;
@@ -54,56 +54,31 @@ interface UseExistingCoversReturn {
    refetch: () => void;
 }
 
-const publicClient = createPublicClient({
-   chain: mainnet,
-   transport: http(),
-});
-
 export function useExistingCovers(userAddress: string | undefined): UseExistingCoversReturn {
    const { coverNfts, isLoading: isNftsLoading, refetch: refetchNfts } = useUserCoverNfts(userAddress);
-   const [covers, setCovers] = useState<CoverData[]>([]);
-   const [isLoading, setIsLoading] = useState(false);
-   const [error, setError] = useState<string | null>(null);
-
-   const fetchCovers = useCallback(async () => {
-      if (isNftsLoading || coverNfts.length === 0) {
-         setCovers([]);
-         return;
-      }
-
-      setIsLoading(true);
-      setError(null);
 
-      try {
-         const coverIds = coverNfts.map((nft) => BigInt(nft.token_id));
-         const coverViewerAddress = nexusSdk.addresses?.CoverViewer;
-         const coverViewerAbi = nexusSdk.abis?.CoverViewer;
-         if (!coverViewerAddress || !coverViewerAbi) {
-            throw new Error('Nexus SDK not configured correctly for CoverViewer.');
-         }
-         const result = await publicClient.readContract({
-            address: getAddress(coverViewerAddress),
-            abi: coverViewerAbi as any,
-            functionName: "getCovers",
-            args: [coverIds],
-         });
-
-         const rawCovers = result as RawCoverData[];
-         const parsedCovers = rawCovers.map(parseCoverData);
-         setCovers(parsedCovers);
-      } catch (err: unknown) {
-         const errorMessage = err instanceof Error ? err.message : "Failed to fetch cover details";
-         console.error("Cover details fetch error:", err);
-         setError(errorMessage);
-         setCovers([]);
-      } finally {
-         setIsLoading(false);
-      }
-   }, [coverNfts, isNftsLoading]);
+   const coverIds = useMemo(
+      () => coverNfts.map((nft) => BigInt(nft.token_id)),
+      [coverNfts]
+   );
+   const coverViewerAddress = nexusSdk.addresses?.CoverViewer;
+   const coverViewerAbi = nexusSdk.abis?.CoverViewer;
 
-   useEffect(() => {
-      fetchCovers();
-   }, [fetchCovers]);
+   const {
+      data: covers = [],
+      isLoading: isContractLoading,
+      error: contractError,
+      refetch: refetchCovers,
+   } = useReadContract({
+      address: coverViewerAddress ? getAddress(coverViewerAddress) : undefined,
+      abi: coverViewerAbi as Abi,
+      functionName: "getCovers",
+      args: [coverIds],
+      query: {
+         enabled: !isNftsLoading && coverNfts.length > 0 && !!coverViewerAddress && !!coverViewerAbi,
+         select: (data) => (data as RawCoverData[]).map(parseCoverData),
+      },
+   });
 
    const hasCoverForProduct = useCallback(
       (productId: number): CoverData | undefined => {
@@ -114,12 +89,12 @@ export function useExistingCovers(userAddress: string | undefined): UseExistingC
 
    return {
       covers,
-      isLoading: isLoading || isNftsLoading,
-      error,
+      isLoading: isNftsLoading || isContractLoading,
+      error: contractError?.message ?? null,
       hasCoverForProduct,
       refetch: () => {
          refetchNfts();
-         fetchCovers();
+         refetchCovers();
       },
    };
 }

package/src/cover-offer/hooks/useNexusProduct.ts

@@ -1,5 +1,5 @@
 import { useMemo } from "react";
-import { products, ProductTypes } from "@nexusmutual/sdk";
+import { CoverAsset, products, ProductTypes } from "@nexusmutual/sdk";
 import type { Opportunity } from "@turtleclub/hooks";
 import { NexusProduct } from "../types";
 
@@ -53,11 +53,15 @@ export const getNexusProductLookup = (opportunity: Opportunity | null | undefine
    const protocolName = getProtocolForInsurance(opportunity);
    const nexusProduct = protocolName ? NEXUS_PRODUCT_MAP[protocolName.toLowerCase()] : null;
 
+
+
+
    return {
       protocolName: protocolName ?? "Unknown",
       productId: nexusProduct?.id ?? null,
       coverProductName: nexusProduct?.name ?? null,
       isCoverable: !!nexusProduct,
+      coverAssets: nexusProduct?.coverAssets ?? [],
    };
 };
 
@@ -66,6 +70,7 @@ export interface NexusProductLookup {
    productId: number | null;
    coverProductName: string | null;
    isCoverable: boolean;
+   coverAssets: string[];
 }
 
 export function useNexusProduct(opportunity: Opportunity | null | undefined): NexusProductLookup {

package/src/cover-offer/hooks/useNexusPurchase.ts

@@ -1,10 +1,10 @@
-import { useCallback, useState } from "react";
-import nexusSdk from "@nexusmutual/sdk";
-import { getAddress } from "viem";
+import { useCallback } from "react";
+import { useMutation } from "@tanstack/react-query";
+import nexusSdk, { GetQuoteResponse } from "@nexusmutual/sdk";
+import { getAddress, type Abi } from "viem";
 import { useWriteContract, useConfig } from "wagmi";
 import { waitForTransactionReceipt } from "wagmi/actions";
 import { formatPurchaseError } from "../utils";
-import type { NexusQuoteResult } from "../types";
 
 type UseNexusPurchaseArgs = {
    onSuccess?: (message: string) => void;
@@ -12,53 +12,55 @@ type UseNexusPurchaseArgs = {
 };
 
 type UseNexusPurchaseReturn = {
-   purchase: (quoteResult: NexusQuoteResult) => Promise<string>;
+   purchase: (quoteResult: GetQuoteResponse) => Promise<void>;
    isPurchasing: boolean;
 };
 
-export function useNexusPurchase(args: UseNexusPurchaseArgs): UseNexusPurchaseReturn {
-   const { onSuccess, onError } = args;
+export function useNexusPurchase({
+   onSuccess,
+   onError,
+}: UseNexusPurchaseArgs): UseNexusPurchaseReturn {
    const config = useConfig();
    const { writeContractAsync } = useWriteContract();
-   const [isPurchasing, setIsPurchasing] = useState(false);
-
-   const purchase = useCallback(
-      async (quoteResult: NexusQuoteResult): Promise<string> => {
-         try {
-            setIsPurchasing(true);
 
+   const { mutateAsync, isPending: isPurchasing } = useMutation({
+      mutationFn: async (quoteResult: GetQuoteResponse) => {
+         const { buyCoverParams, poolAllocationRequests } = quoteResult.buyCoverInput;
+         const coverAddress = nexusSdk.addresses?.Cover;
+         const coverAbi = nexusSdk.abis?.Cover;
 
-            const { buyCoverParams, poolAllocationRequests } = quoteResult.buyCoverInput;
-            const coverAddress = nexusSdk.addresses?.Cover;
-            const coverAbi = nexusSdk.abis?.Cover;
-            if (!coverAddress || !coverAbi) {
-               throw new Error('Nexus SDK not configured correctly for Cover.');
-            }
+         if (!coverAddress || !coverAbi) {
+            throw new Error("Nexus SDK not configured correctly for Cover.");
+         }
+         const isNativePayment = buyCoverParams.paymentAsset === 0;
 
-            const txHash = await writeContractAsync({
-               address: getAddress(coverAddress),
-               abi: coverAbi as any,
-               functionName: "buyCover",
-               args: [buyCoverParams, poolAllocationRequests],
-               value: BigInt(quoteResult.displayInfo.premiumInAsset),
-               chainId: 1,
-            });
+         const txHash = await writeContractAsync({
+            address: getAddress(coverAddress),
+            abi: coverAbi as Abi,
+            functionName: "buyCover",
+            args: [buyCoverParams, poolAllocationRequests],
+            value: isNativePayment ? BigInt(quoteResult.displayInfo.premiumInAsset) : undefined,
+            chainId: 1,
+         });
 
-            await waitForTransactionReceipt(config, {
-               hash: txHash,
-               confirmations: 1,
-            });
+         await waitForTransactionReceipt(config, {
+            hash: txHash,
+            confirmations: 1,
+         });
+      },
+      onSuccess: () => {
+         onSuccess?.("Cover purchased successfully");
+      },
+      onError: (err) => {
+         onError?.(formatPurchaseError(err));
+      },
+   });
 
-            onSuccess?.("Cover purchased successfully");
-            return txHash;
-         } catch (err) {
-            onError?.(formatPurchaseError(err));
-            throw err;
-         } finally {
-            setIsPurchasing(false);
-         }
+   const purchase = useCallback(
+      async (quoteResult: GetQuoteResponse) => {
+         await mutateAsync(quoteResult);
       },
-      [config, writeContractAsync, onError, onSuccess]
+      [mutateAsync]
    );
 
    return { purchase, isPurchasing };

package/src/cover-offer/hooks/useTokenApproval.ts

@@ -0,0 +1,118 @@
+import { useCallback } from "react";
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import { useConfig, useWriteContract } from "wagmi";
+import { readContract, waitForTransactionReceipt } from "wagmi/actions";
+import { erc20Abi } from "viem";
+
+interface UseTokenApprovalParams {
+  userAddress: `0x${string}` | undefined;
+  tokenAddress: `0x${string}`;
+  spenderAddress: `0x${string}`;
+  chainId: number;
+  amount: bigint | null | undefined;
+}
+
+interface UseTokenApprovalReturn {
+  needsApproval: boolean;
+  isCheckingApproval: boolean;
+  approve: () => Promise<void>;
+  isApproving: boolean;
+  refetchApprovalStatus: () => void;
+}
+
+export const NATIVE_TOKEN_ADDRESS_ZERO =
+  "0x0000000000000000000000000000000000000000" as const;
+export const NATIVE_TOKEN_ADDRESS_EEEE =
+  "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee" as const;
+
+function isNativeTokenAddress(address: string): boolean {
+  const lower = address.toLowerCase();
+  return lower === NATIVE_TOKEN_ADDRESS_ZERO || lower === NATIVE_TOKEN_ADDRESS_EEEE;
+}
+
+export function useTokenApproval({
+  userAddress,
+  tokenAddress,
+  spenderAddress,
+  chainId,
+  amount,
+}: UseTokenApprovalParams): UseTokenApprovalReturn {
+  const config = useConfig();
+  const queryClient = useQueryClient();
+  const { writeContractAsync } = useWriteContract();
+
+  const isNativeToken = isNativeTokenAddress(tokenAddress);
+  const hasValidAmount = !!amount && amount > 0n;
+  const isEnabled = !!userAddress && hasValidAmount && !isNativeToken;
+
+  const queryKey = [
+    "tokenApproval",
+    userAddress,
+    tokenAddress,
+    spenderAddress,
+    amount?.toString(),
+    chainId,
+  ];
+
+  const {
+    data: needsApproval = false,
+    isLoading: isCheckingApproval,
+    refetch,
+  } = useQuery({
+    queryKey,
+    queryFn: async () => {
+      if (!userAddress || !amount) return false;
+
+      const currentAllowance = await readContract(config, {
+        address: tokenAddress,
+        abi: erc20Abi,
+        functionName: "allowance",
+        args: [userAddress, spenderAddress],
+        chainId,
+      });
+
+      return currentAllowance < amount;
+    },
+    enabled: isEnabled,
+  });
+
+  const { mutateAsync: approveAsync, isPending: isApproving } = useMutation({
+    mutationFn: async () => {
+      if (!userAddress || !amount) {
+        throw new Error("User address and amount are required");
+      }
+
+      const approvalHash = await writeContractAsync({
+        address: tokenAddress,
+        abi: erc20Abi,
+        functionName: "approve",
+        args: [spenderAddress, amount],
+        chainId,
+      });
+
+      await waitForTransactionReceipt(config, {
+        hash: approvalHash,
+        chainId,
+      });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey });
+    },
+  });
+
+  const approve = useCallback(async () => {
+    await approveAsync();
+  }, [approveAsync]);
+
+  const refetchApprovalStatus = useCallback(() => {
+    refetch();
+  }, [refetch]);
+
+  return {
+    needsApproval,
+    isCheckingApproval,
+    approve,
+    isApproving,
+    refetchApprovalStatus,
+  };
+}