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

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/useNexusProduct.ts

@@ -0,0 +1,74 @@
+import { useMemo } from "react";
+import { products, ProductTypes } from "@nexusmutual/sdk";
+import type { Opportunity } from "@turtleclub/hooks";
+import { NexusProduct } from "../types";
+
+const getHighestPriorityProduct = (
+   currentBest: NexusProduct | null,
+   newProduct: NexusProduct,
+): boolean => {
+   // Prefer v3 products, and for v3 prefer the highest id
+   if (newProduct.name.includes("v3") && currentBest && !currentBest.name.includes("v3")) {
+      return true;
+   }
+
+   if (newProduct.name.includes("v3") && currentBest?.name.includes("v3") && newProduct.id > currentBest.id) {
+      return true;
+   }
+
+   if (!currentBest) {
+      return true;
+   }
+
+   return false;
+};
+
+const NEXUS_PRODUCT_MAP: Record<string, NexusProduct> = products
+   .filter((x) => !x.isDeprecated && !x.isPrivate && x.productType === ProductTypes.singleProtocol)
+   .reduce((acc: Record<string, NexusProduct>, product: any) => {
+      const protocolNameMatch = product.name.match(/^(\w+)/);
+      const protocolName = protocolNameMatch ? protocolNameMatch[1].toLowerCase() : null;
+
+      if (!protocolName) {
+         return acc;
+      }
+
+      const currentBest = acc[protocolName] || null;
+
+      if (getHighestPriorityProduct(currentBest, product)) {
+         acc[protocolName] = {
+            id: product.id,
+            name: product.name,
+            coverAssets: product.coverAssets,
+         };
+      }
+      return acc;
+   }, {});
+
+export const getProtocolForInsurance = (opportunity: Opportunity | null | undefined) => {
+   return opportunity?.vaultConfig?.infraProvider?.name ?? null;
+};
+
+export const getNexusProductLookup = (opportunity: Opportunity | null | undefined) => {
+   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,
+   };
+};
+
+export interface NexusProductLookup {
+   protocolName: string;
+   productId: number | null;
+   coverProductName: string | null;
+   isCoverable: boolean;
+}
+
+export function useNexusProduct(opportunity: Opportunity | null | undefined): NexusProductLookup {
+   return useMemo(() => getNexusProductLookup(opportunity), [opportunity]);
+}
+

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

@@ -0,0 +1,65 @@
+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

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

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

@@ -0,0 +1,65 @@
+import type { Opportunity } from "@turtleclub/hooks";
+
+/** Result from Nexus SDK quote API */
+export interface NexusQuoteResult {
+   buyCoverInput: {
+      buyCoverParams: unknown;
+      poolAllocationRequests: unknown;
+   };
+   displayInfo: {
+      premiumInAsset: string;
+      yearlyCostPerc: number;
+   };
+}
+export type NexusProduct = {
+   id: number;
+   name: string;
+   coverAssets: number[];
+};
+
+export interface CoverOfferCardProps {
+   productId: number;
+   opportunity: Opportunity;
+   amountToCover: string;
+   buyerAddress: string;
+   protocolName: string;
+   coverProductName: string;
+   onSuccess?: (message: string) => void;
+   onError?: (message: string) => void;
+   startExpanded?: boolean;
+}
+
+export interface CoverQuoteState {
+   isLoading: boolean;
+   error: string | null;
+   quoteResult: NexusQuoteResult | null;
+   coverPeriod: number;
+   premiumEth: string | null;
+   yearlyCostPerc: number | null;
+}
+export interface NexusCoverSectionProps {
+   opportunity: Opportunity;
+   amountToCover: string;
+   buyerAddress: string;
+   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

@@ -0,0 +1,82 @@
+import type { Opportunity } from "@turtleclub/hooks";
+import { BaseError, UserRejectedRequestError } from "viem";
+
+export function getOpportunityAPY(opportunity: Opportunity): number {
+   if (!opportunity.incentives || opportunity.incentives.length === 0) {
+      return 0;
+   }
+
+   return opportunity.incentives.reduce((total, incentive) => {
+      return total + (incentive.yield ?? 0);
+   }, 0);
+}
+
+/**
+ * Calculate the adjusted APY after subtracting the cover cost
+ * @param opportunityAPY - The original APY as a percentage (e.g., 5 for 5%)
+ * @param yearlyCostPerc - The yearly cost as a decimal (e.g., 0.025 for 2.5%)
+ * @returns The adjusted APY as a percentage
+ */
+export function calculateAdjustedAPY(
+   opportunityAPY: number,
+   yearlyCostPerc: number
+): number {
+   const coverCostPercentage = yearlyCostPerc * 100;
+   return Math.max(0, opportunityAPY - coverCostPercentage);
+}
+
+
+export function formatAPY(apy: number): string {
+   return `${apy.toFixed(2)}%`;
+}
+
+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,
+   };
+}

package/src/index.ts

@@ -7,6 +7,9 @@ export * from "./deposit";
 // Transaction Status
 export * from "./transaction-status";
 
+// Cover Offer
+export * from "./cover-offer";
+
 // Opportunity Table
 export * from "./opportunity-table/components";