@turtleclub/opportunities 0.1.0-beta.13 → 0.1.0-beta.15

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

@@ -0,0 +1,126 @@
+import { useState, useEffect, useCallback } from "react";
+import { createPublicClient, http, getAddress } from "viem";
+import { mainnet } from "viem/chains";
+import nexusSdk from "@nexusmutual/sdk";
+import { useUserCoverNfts, type CoverNft } from "./useUserCoverNfts";
+
+// Raw cover data from contract (all numbers are BigInt)
+interface RawCoverData {
+   coverId: bigint;
+   productId: bigint;
+   coverAsset: bigint;
+   amountPaidOut: bigint;
+   amount: bigint;
+   start: bigint;
+   period: bigint;
+   gracePeriod: bigint;
+   segmentId: bigint;
+   expired: boolean;
+}
+
+export interface CoverData {
+   coverId: bigint;
+   productId: number;
+   coverAsset: number;
+   amountPaidOut: bigint;
+   amount: bigint;
+   start: number;
+   period: number;
+   gracePeriod: number;
+   segmentId: number;
+   expired: boolean;
+}
+
+function parseCoverData(raw: RawCoverData): CoverData {
+   return {
+      coverId: raw.coverId,
+      productId: Number(raw.productId),
+      coverAsset: Number(raw.coverAsset),
+      amountPaidOut: raw.amountPaidOut,
+      amount: raw.amount,
+      start: Number(raw.start),
+      period: Number(raw.period),
+      gracePeriod: Number(raw.gracePeriod),
+      segmentId: Number(raw.segmentId),
+      expired: raw.expired,
+   };
+}
+
+interface UseExistingCoversReturn {
+   covers: CoverData[];
+   isLoading: boolean;
+   error: string | null;
+   hasCoverForProduct: (productId: number) => CoverData | undefined;
+   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]);
+
+   useEffect(() => {
+      fetchCovers();
+   }, [fetchCovers]);
+
+   const hasCoverForProduct = useCallback(
+      (productId: number): CoverData | undefined => {
+         return covers.find((cover) => cover.productId === productId && !cover.expired);
+      },
+      [covers]
+   );
+
+   return {
+      covers,
+      isLoading: isLoading || isNftsLoading,
+      error,
+      hasCoverForProduct,
+      refetch: () => {
+         refetchNfts();
+         fetchCovers();
+      },
+   };
+}
+

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

@@ -1,94 +1,65 @@
-import { useCallback, useState } from "react";
-import nexusSdk from "@nexusmutual/sdk";
-import * as ethers from "ethers";
-import type { NexusQuoteResult } from "../types";
-
-type UseNexusPurchaseArgs = {
-   buyerAddress: string;
-   productId: number;
-   amountToCover: string;
-   onSuccess?: (result: NexusPurchaseResult) => void;
-   onError?: (error: unknown) => void;
-};
-
-type NexusPurchaseTxRequest = {
-   to: `0x${string}`;
-   data: `0x${string}`;
-   value: bigint;
-   account?: `0x${string}`;
-};
-
-type NexusPurchaseResult = {
-   txRequest: NexusPurchaseTxRequest;
-   quoteResult: NexusQuoteResult;
-   meta: {
-      buyerAddress: string;
-      productId: number;
-      amountToCover: string;
-      coverPeriod: number;
-   };
-};
-
-type UseNexusPurchaseReturn = {
-   purchase: (quoteResult: NexusQuoteResult, coverPeriod: number) => Promise<NexusPurchaseResult>;
-   isPurchasing: boolean;
-   error: unknown | null;
-   result: NexusPurchaseResult | null;
-};
-
-/** Encapsulate Nexus buyCover prep to mirror executeNexusTransaction flow */
-export function useNexusPurchase(args: UseNexusPurchaseArgs): UseNexusPurchaseReturn {
-   const { buyerAddress, productId, amountToCover, onSuccess, onError } = args;
-   const [isPurchasing, setIsPurchasing] = useState(false);
-   const [error, setError] = useState<unknown | null>(null);
-   const [result, setResult] = useState<NexusPurchaseResult | null>(null);
-
-   const purchase = useCallback(
-      async (quoteResult: NexusQuoteResult, coverPeriod: number) => {
-         try {
-            setIsPurchasing(true);
-            setError(null);
-
-            const { buyCoverParams, poolAllocationRequests } = quoteResult.buyCoverInput;
-            const coverBrokerInterface = new ethers.Interface(nexusSdk.abis?.CoverBroker);
-            const data = coverBrokerInterface.encodeFunctionData("buyCover", [
-               buyCoverParams,
-               poolAllocationRequests,
-            ]);
-
-            const txRequest: NexusPurchaseTxRequest = {
-               to: nexusSdk.addresses?.CoverBroker as `0x${string}`,
-               data: data as `0x${string}`,
-               value: BigInt(quoteResult.displayInfo.premiumInAsset),
-               account: buyerAddress as `0x${string}`,
-            };
-
-            const purchaseResult: NexusPurchaseResult = {
-               txRequest,
-               quoteResult,
-               meta: {
-                  buyerAddress,
-                  productId,
-                  amountToCover,
-                  coverPeriod,
-               },
-            };
-
-            setResult(purchaseResult);
-            onSuccess?.(purchaseResult);
-            return purchaseResult;
-         } catch (err) {
-            setError(err);
-
-            onError?.(err);
-            throw err;
-         } finally {
-            setIsPurchasing(false);
-         }
-      },
-      [amountToCover, buyerAddress, onError, onSuccess, productId]
-   );
-
-   return { purchase, isPurchasing, error, result };
-}
-
+import { useCallback, useState } from "react";
+import nexusSdk from "@nexusmutual/sdk";
+import { getAddress } 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;
+   onError?: (message: string) => void;
+};
+
+type UseNexusPurchaseReturn = {
+   purchase: (quoteResult: NexusQuoteResult) => Promise<string>;
+   isPurchasing: boolean;
+};
+
+export function useNexusPurchase(args: UseNexusPurchaseArgs): UseNexusPurchaseReturn {
+   const { onSuccess, onError } = args;
+   const config = useConfig();
+   const { writeContractAsync } = useWriteContract();
+   const [isPurchasing, setIsPurchasing] = useState(false);
+
+   const purchase = useCallback(
+      async (quoteResult: NexusQuoteResult): Promise<string> => {
+         try {
+            setIsPurchasing(true);
+
+
+            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.');
+            }
+
+            const txHash = await writeContractAsync({
+               address: getAddress(coverAddress),
+               abi: coverAbi as any,
+               functionName: "buyCover",
+               args: [buyCoverParams, poolAllocationRequests],
+               value: BigInt(quoteResult.displayInfo.premiumInAsset),
+               chainId: 1,
+            });
+
+            await waitForTransactionReceipt(config, {
+               hash: txHash,
+               confirmations: 1,
+            });
+
+            onSuccess?.("Cover purchased successfully");
+            return txHash;
+         } catch (err) {
+            onError?.(formatPurchaseError(err));
+            throw err;
+         } finally {
+            setIsPurchasing(false);
+         }
+      },
+      [config, writeContractAsync, onError, onSuccess]
+   );
+
+   return { purchase, isPurchasing };
+}

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

@@ -0,0 +1,83 @@
+import { useState, useEffect, useCallback } from "react";
+import { NEXUS_COVER_NFT_ADDRESS, USER_NFTS_API_URL } from "../constants";
+
+interface UserNft {
+   user: string;
+   chain: number;
+   token: string;
+   token_id: string;
+   last_transfer: string;
+}
+
+export type CoverNft = UserNft;
+
+interface UseUserCoverNftsReturn {
+   coverNfts: CoverNft[];
+   isLoading: boolean;
+   error: string | null;
+   refetch: () => void;
+}
+
+async function fetchUserNfts(userAddress: string): Promise<UserNft[]> {
+   const response = await fetch(USER_NFTS_API_URL, {
+      method: "POST",
+      headers: {
+         "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+         user: userAddress,
+         chain: 1,
+      }),
+   });
+
+
+
+   if (!response.ok) {
+      throw new Error("Failed to fetch user NFTs");
+   }
+
+   return response.json();
+}
+
+export function useUserCoverNfts(userAddress: string | undefined): UseUserCoverNftsReturn {
+   const [coverNfts, setCoverNfts] = useState<CoverNft[]>([]);
+   const [isLoading, setIsLoading] = useState(false);
+   const [error, setError] = useState<string | null>(null);
+
+   const fetchCoverNfts = useCallback(async () => {
+      if (!userAddress) {
+         setCoverNfts([]);
+         return;
+      }
+
+      setIsLoading(true);
+      setError(null);
+
+      try {
+         const nfts = await fetchUserNfts(userAddress);
+         const filtered = nfts.filter(
+            (nft) => nft.token.toLowerCase() === NEXUS_COVER_NFT_ADDRESS.toLowerCase()
+         );
+         setCoverNfts(filtered);
+      } catch (err: unknown) {
+         const errorMessage = err instanceof Error ? err.message : "Failed to fetch cover NFTs";
+         console.error("Cover NFTs fetch error:", err);
+         setError(errorMessage);
+         setCoverNfts([]);
+      } finally {
+         setIsLoading(false);
+      }
+   }, [userAddress]);
+
+   useEffect(() => {
+      fetchCoverNfts();
+   }, [fetchCoverNfts]);
+
+   return {
+      coverNfts,
+      isLoading,
+      error,
+      refetch: fetchCoverNfts,
+   };
+}
+

package/src/cover-offer/index.ts

@@ -1,6 +1,4 @@
 export { NexusCoverSection } from "./components/NexusCoverSection";
 export type { NexusCoverSectionProps, NexusQuoteResult } from "./types";
 
-export { useCoverQuote } from "./hooks/useCoverQuote";
-export { useNexusPurchase } from "./hooks/useNexusPurchase";
 export { useNexusProduct, getNexusProductLookup, getProtocolForInsurance } from "./hooks/useNexusProduct";

package/src/cover-offer/types/index.ts

@@ -22,12 +22,11 @@ export interface CoverOfferCardProps {
    opportunity: Opportunity;
    amountToCover: string;
    buyerAddress: string;
-
-   onPurchase: (quoteResult: NexusQuoteResult, coverPeriod: number) => void;
-   isPurchasing?: boolean;
-   purchaseError?: unknown;
-
-   onDismiss?: () => void;
+   protocolName: string;
+   coverProductName: string;
+   onSuccess?: (message: string) => void;
+   onError?: (message: string) => void;
+   startExpanded?: boolean;
 }
 
 export interface CoverQuoteState {
@@ -42,8 +41,25 @@ export interface NexusCoverSectionProps {
    opportunity: Opportunity;
    amountToCover: string;
    buyerAddress: string;
-   onSuccess: (res: any) => void;
-   onError: (err: any) => void;
-   onDismiss?: () => void;
+   onSuccess?: (message: string) => void;
+   onError?: (message: string) => void;
    className?: string;
+   startExpanded?: boolean;
 }
+
+export interface CoverRequestData {
+   protocolName: string;
+   coverageAmount: number;
+   periodDays: number;
+   desiredApySacrifice: number;
+   estimatedPremium: number;
+}
+export interface CoverRequestFormProps {
+   protocolName: string;
+   depositedAmount?: string;
+   baseApyLabel?: string;
+   onDismiss?: () => void;
+   onSuccess?: (message: string) => void;
+   onError?: (message: string) => void;
+   startExpanded?: boolean;
+}

package/src/cover-offer/utils/index.ts

@@ -1,8 +1,6 @@
 import type { Opportunity } from "@turtleclub/hooks";
+import { BaseError, UserRejectedRequestError } from "viem";
 
-/**
- * Calculate the total APY from an opportunity's incentives
- */
 export function getOpportunityAPY(opportunity: Opportunity): number {
    if (!opportunity.incentives || opportunity.incentives.length === 0) {
       return 0;
@@ -27,19 +25,58 @@ export function calculateAdjustedAPY(
    return Math.max(0, opportunityAPY - coverCostPercentage);
 }
 
-/**
- * Format APY for display
- */
+
 export function formatAPY(apy: number): string {
    return `${apy.toFixed(2)}%`;
 }
 
-/**
- * Format ETH amount for display
- */
 export function formatEthAmount(amount: string, decimals: number = 6): string {
    const num = parseFloat(amount);
    if (isNaN(num)) return "0";
    return num.toFixed(decimals);
 }
 
+
+export const formatPurchaseError = (err: unknown): string => {
+   console.error("Purchase error:", err, typeof err);
+   if (err instanceof UserRejectedRequestError) {
+      return "Transaction cancelled";
+   }
+
+   if (err instanceof BaseError) {
+      const userRejected =
+         typeof err.walk === "function"
+            ? err.walk((error) => error instanceof UserRejectedRequestError)
+            : false;
+      if (userRejected) {
+         return "Transaction cancelled";
+      }
+
+      return err.shortMessage || err.message;
+   }
+
+   if (err instanceof Error) {
+      return err.message;
+   }
+
+   return "Failed to purchase cover";
+};
+
+
+
+const SECS_IN_DAY = 24 * 60 * 60;
+
+export function parseCoverTiming(startSec: number, periodSec: number, gracePeriodSec: number = 0) {
+   const expiresSec = startSec + periodSec;
+   const graceEndsSec = expiresSec + gracePeriodSec;
+
+   return {
+      startDate: new Date(startSec * 1000),
+      expiresDate: new Date(expiresSec * 1000),
+      graceEndsDate: new Date(graceEndsSec * 1000),
+      periodDays: periodSec / SECS_IN_DAY,
+      graceDays: gracePeriodSec / SECS_IN_DAY,
+      expiresSec,
+      graceEndsSec,
+   };
+}