@turtleclub/covers 0.1.0-beta.1

package/src/nexus-mutual-cover/components/PurchaseButtonSection.tsx

@@ -0,0 +1,106 @@
+"use client";
+
+import type { ComponentType } from "react";
+import { ExternalLink, type LucideProps } from "lucide-react";
+import { Button, Skeleton, Tooltip, TooltipTrigger, TooltipContent, Card } from "@turtleclub/ui";
+import { NEXUS_MEMBERSHIP_URL } from "../constants";
+
+const ExternalLinkIcon = ExternalLink as ComponentType<LucideProps>;
+
+export interface PurchaseButtonSectionProps {
+  isWrongNetwork: boolean;
+  isMembershipLoading: boolean;
+  isMember: boolean;
+  disabledReason: string | null;
+  purchaseButton: React.ReactNode;
+  onSwitchNetwork: () => void;
+  needsApproval?: boolean;
+  isCheckingApproval?: boolean;
+  onApprove?: () => Promise<void>;
+  isApproving?: boolean;
+  tokenSymbol?: string;
+}
+
+export function PurchaseButtonSection({
+  isWrongNetwork,
+  isMembershipLoading,
+  isMember,
+  disabledReason,
+  purchaseButton,
+  onSwitchNetwork,
+  needsApproval = false,
+  isCheckingApproval = false,
+  onApprove,
+  isApproving = false,
+  tokenSymbol,
+}: PurchaseButtonSectionProps) {
+  if (isWrongNetwork) {
+    return (
+      <Card variant="border" className="h-fit">
+        <Button
+          onClick={onSwitchNetwork}
+          className="text-primary hover:text-primary/80 w-full cursor-pointer font-medium underline transition-colors"
+        >
+          Switch to Ethereum network to Buy Cover
+        </Button>
+      </Card>
+    );
+  }
+
+  if (isMembershipLoading) {
+    return <Skeleton className="h-10 w-full bg-neutral-alpha-10" />;
+  }
+
+  if (!isMember) {
+    return (
+      <div className="space-y-3">
+        <div className="p-3 rounded-lg bg-background/50 border border-border">
+          <p className="text-xs text-muted-foreground leading-relaxed">
+            <span className="text-primary font-medium">Membership required.</span> Join Nexus Mutual
+            to protect your deposit against smart contract exploits, oracle failures, and
+            protocol-specific risks.
+          </p>
+        </div>
+        <Button asChild className="w-full" variant="green">
+          <a
+            href={NEXUS_MEMBERSHIP_URL}
+            target="_blank"
+            rel="noopener noreferrer"
+            className="flex items-center justify-center gap-2"
+          >
+            Become a Member
+            <ExternalLinkIcon className="w-4 h-4" />
+          </a>
+        </Button>
+      </div>
+    );
+  }
+
+  if (needsApproval && tokenSymbol && onApprove) {
+    return (
+      <div className="space-y-3">
+        <Button
+          onClick={onApprove}
+          disabled={isApproving || isCheckingApproval}
+          className="w-full"
+          variant="green"
+        >
+          {isApproving || isCheckingApproval ? "Approving..." : `Approve ${tokenSymbol} spending`}
+        </Button>
+      </div>
+    );
+  }
+
+  if (disabledReason) {
+    return (
+      <Tooltip>
+        <TooltipTrigger asChild>
+          <div>{purchaseButton}</div>
+        </TooltipTrigger>
+        <TooltipContent side="top">{disabledReason}</TooltipContent>
+      </Tooltip>
+    );
+  }
+
+  return <>{purchaseButton}</>;
+}

package/src/nexus-mutual-cover/components/index.ts

@@ -0,0 +1,7 @@
+export { NexusCoverSection } from "./NexusCoverSection";
+export { CoverOfferCard } from "./CoverOfferCard";
+export { CoverRequestForm } from "./CoverRequestForm";
+export { PurchaseButtonSection } from "./PurchaseButtonSection";
+export { ExistingCoverInfo } from "./ExistingCoverInfo";
+export { ExistingCoverRequest } from "./ExistingCoverRequest";
+export { CoveredEventsInfo } from "./CoveredEventsInfo";

package/src/nexus-mutual-cover/constants.ts

@@ -0,0 +1,39 @@
+export const NEXUS_PROTOCOL_COVER_TERMS_URL =
+   "https://api.nexusmutual.io/ipfs/QmQz38DSo6DyrHkRj8uvtGFyx842izVvnx8a3qqF99dctG";
+export const NEXUS_KYC_REQUIREMENTS_URL =
+   "https://docs.nexusmutual.io/overview/membership/#kyc-requirements";
+export const NEXUS_MEMBERSHIP_URL = "https://app.nexusmutual.io/become-member";
+export const NEXUS_COVER_NFT_ADDRESS = "0xcafeaca76be547f14d0220482667b42d8e7bc3eb";
+export const NEXUS_COVER_ROUTER = "0xcafeac0fF5dA0A2777d915531bfA6B29d282Ee62";
+
+// These are the tokens that Nexus Mutual supports.
+export const NEXUS_AVAILABLE_TOKENS = [
+   {
+      symbol: "ETH",
+      name: "Ethereum",
+      address: "0x0000000000000000000000000000000000000000",
+      logoUrl: "https://storage.googleapis.com/turtle-assets/tokens/eth.png",
+      decimals: 18,
+   },
+   {
+      symbol: "USDC",
+      name: "USD Coin",
+      address: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+      logoUrl: "https://storage.googleapis.com/turtle-assets/tokens/usdc.png",
+      decimals: 6,
+   },
+   {
+      symbol: "cbBTC",
+      name: "Coinbase Wrapped BTC",
+      address: "0xcbb7c0000ab88b473b1f5afd9ef808440eed33bf",
+      logoUrl: "https://storage.googleapis.com/turtle-assets/tokens/cbbtc.png",
+      decimals: 8,
+   },
+] as const;
+
+export const PERIOD_OPTIONS = [
+   { label: "28d", days: 28 },
+   { label: "3m", days: 90 },
+   { label: "6m", days: 180 },
+   { label: "1y", days: 365 },
+] as const;

package/src/nexus-mutual-cover/hooks/index.ts

@@ -0,0 +1,9 @@
+export { useNexusProduct, getNexusProductLookup, getProtocolForInsurance } from "./useNexusProduct";
+export { useCheckNexusMembership } from "./useCheckNexusMembership";
+export { useCoverQuote } from "./useCoverQuote";
+export { useNexusPurchase } from "./useNexusPurchase";
+export { useExistingCovers } from "./useExistingCovers";
+export { useUserCoverNfts } from "./useUserCoverNfts";
+export { useCoverTokenSelection } from "./useCoverTokenSelection";
+export { useTokenApproval } from "./useTokenApproval";
+export { useDebouncedValue } from "./useDebouncedValue";

package/src/nexus-mutual-cover/hooks/useCheckNexusMembership.ts

@@ -0,0 +1,32 @@
+import { getAddress } from "viem";
+import type { Abi } from "viem";
+import { useReadContract } from "wagmi";
+import nexusSdk from "@nexusmutual/sdk";
+
+export function useCheckNexusMembership(
+   userAddress: string | undefined,
+   chainId: string | number | undefined
+) {
+   const masterAddress = nexusSdk.addresses?.NXMaster;
+   const masterAbi = nexusSdk.abis?.NXMaster;
+   const numericChainId = typeof chainId === "string" ? parseInt(chainId, 10) : chainId;
+   const isOnEthereum = numericChainId === 1;
+
+   const {
+      data: isMember = false,
+      isLoading,
+      error,
+   } = useReadContract({
+      address: masterAddress ? getAddress(masterAddress) : undefined,
+      abi: masterAbi as Abi,
+      functionName: "isMember",
+      chainId: 1,
+      args: userAddress ? [getAddress(userAddress)] : undefined,
+      query: {
+         enabled: isOnEthereum && !!userAddress && !!masterAddress && !!masterAbi,
+         select: (data) => data as boolean,
+      },
+   });
+
+   return { isMember, isLoading, error };
+}

package/src/nexus-mutual-cover/hooks/useCoverQuote.ts

@@ -0,0 +1,126 @@
+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;
+   coverPeriod: number;
+   tokenSymbol: string;
+   decimals: number | undefined;
+   opportunity: Opportunity;
+}
+
+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;
+
+const TERMS_IPFS_CID = "QmXUzXDMbeKSCewUie34vPD7mCAGnshi4ULRy4h7DLmoRS";
+
+async function getNexusSdk() {
+   if (!nexusSdkInstance) {
+      const { NexusSDK } = await import("@nexusmutual/sdk");
+      nexusSdkInstance = new NexusSDK();
+   }
+   return nexusSdkInstance;
+}
+
+async function fetchNexusQuote(
+   productId: number,
+   buyerAddress: string,
+   amountToCover: string,
+   period: number,
+   coverAsset: CoverAsset
+): Promise<GetQuoteResponse> {
+   const nexusSdk = await getNexusSdk();
+
+   const { result, error } = await nexusSdk.quote.getQuoteAndBuyCoverInputs({
+      productId,
+      amount: amountToCover,
+      period,
+      coverAsset,
+      paymentAsset: coverAsset,
+      buyerAddress,
+      ipfsCidOrContent: TERMS_IPFS_CID,
+   });
+
+
+   if (error) {
+      throw new Error(error.message || "Failed to fetch Nexus quote");
+   }
+
+   return result as GetQuoteResponse;
+}
+
+export function useCoverQuote({
+   productId,
+   buyerAddress,
+   amountToCover,
+   coverPeriod,
+   tokenSymbol,
+   decimals,
+   opportunity,
+}: UseCoverQuoteOptions): UseCoverQuoteReturn {
+   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 {
+      isLoading,
+      error: queryError?.message ?? null,
+      quoteResult: data?.quoteResult ?? null,
+      premium: data?.premium ?? null,
+      originalAPY,
+      adjustedAPY,
+      coverCostPerc,
+      refetch,
+   };
+}

package/src/nexus-mutual-cover/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/nexus-mutual-cover/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/nexus-mutual-cover/hooks/useExistingCovers.ts

@@ -0,0 +1,110 @@
+import { useCallback, useMemo } from "react";
+import { getAddress } from "viem";
+import { useReadContract } from "wagmi";
+import nexusSdk from "@nexusmutual/sdk";
+import { useUserCoverNfts } from "./useUserCoverNfts";
+import type { Abi } from "viem";
+// 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 {
+   const start = Number(raw.start);
+   const period = Number(raw.period);
+   const nowSec = Math.floor(Date.now() / 1000);
+   const expiresSec = start + period;
+
+   return {
+      coverId: raw.coverId,
+      productId: Number(raw.productId),
+      coverAsset: Number(raw.coverAsset),
+      amountPaidOut: raw.amountPaidOut,
+      amount: raw.amount,
+      start,
+      period,
+      gracePeriod: Number(raw.gracePeriod),
+      segmentId: Number(raw.segmentId),
+      expired: nowSec > expiresSec,
+   };
+}
+
+interface UseExistingCoversOptions {
+   pollingInterval?: number | false;
+}
+
+interface UseExistingCoversReturn {
+   covers: CoverData[];
+   isLoading: boolean;
+   error: string | null;
+   hasCoverForProduct: (productId: number) => CoverData | undefined;
+   refetch: () => void;
+}
+
+export function useExistingCovers(userAddress: string | undefined, options?: UseExistingCoversOptions): UseExistingCoversReturn {
+   const { coverNfts, isLoading: isNftsLoading, refetch: refetchNfts } = useUserCoverNfts(userAddress, { pollingInterval: options?.pollingInterval });
+
+   const coverIds = useMemo(
+      () => coverNfts.map((nft) => BigInt(nft.token_id)),
+      [coverNfts]
+   );
+   const coverViewerAddress = nexusSdk.addresses?.CoverViewer;
+   const coverViewerAbi = nexusSdk.abis?.CoverViewer;
+
+   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 => {
+         return covers.find((cover) => cover.productId === productId && !cover.expired);
+      },
+      [covers]
+   );
+
+   return {
+      covers,
+      isLoading: isNftsLoading || isContractLoading,
+      error: contractError?.message ?? null,
+      hasCoverForProduct,
+      refetch: () => {
+         refetchNfts();
+         refetchCovers();
+      },
+   };
+}
+

package/src/nexus-mutual-cover/hooks/useNexusProduct.ts

@@ -0,0 +1,79 @@
+import { useMemo } from "react";
+import { CoverAsset, 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,
+      coverAssets: nexusProduct?.coverAssets ?? [],
+   };
+};
+
+export interface NexusProductLookup {
+   protocolName: string;
+   productId: number | null;
+   coverProductName: string | null;
+   isCoverable: boolean;
+   coverAssets: string[];
+}
+
+export function useNexusProduct(opportunity: Opportunity | null | undefined): NexusProductLookup {
+   return useMemo(() => getNexusProductLookup(opportunity), [opportunity]);
+}
+

package/src/nexus-mutual-cover/hooks/useNexusPurchase.ts

@@ -0,0 +1,67 @@
+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";
+
+type UseNexusPurchaseArgs = {
+   onSuccess?: (message: string) => void;
+   onError?: (message: string) => void;
+};
+
+type UseNexusPurchaseReturn = {
+   purchase: (quoteResult: GetQuoteResponse) => Promise<void>;
+   isPurchasing: boolean;
+};
+
+export function useNexusPurchase({
+   onSuccess,
+   onError,
+}: UseNexusPurchaseArgs): UseNexusPurchaseReturn {
+   const config = useConfig();
+   const { writeContractAsync } = useWriteContract();
+
+   const { mutateAsync, isPending: isPurchasing } = useMutation({
+      mutationFn: async (quoteResult: GetQuoteResponse) => {
+         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 isNativePayment = buyCoverParams.paymentAsset === 0;
+
+         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,
+         });
+      },
+      onSuccess: () => {
+         onSuccess?.("Cover purchased successfully");
+      },
+      onError: (err) => {
+         onError?.(formatPurchaseError(err));
+      },
+   });
+
+   const purchase = useCallback(
+      async (quoteResult: GetQuoteResponse) => {
+         await mutateAsync(quoteResult);
+      },
+      [mutateAsync]
+   );
+
+   return { purchase, isPurchasing };
+}