@turtleclub/opportunities 0.1.0-beta.6 → 0.1.0-beta.60

package/src/cover-offer/constants.ts

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

package/src/cover-offer/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/cover-offer/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/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

@@ -0,0 +1,101 @@
+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 {
+   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;
+}
+
+export function useExistingCovers(userAddress: string | undefined): UseExistingCoversReturn {
+   const { coverNfts, isLoading: isNftsLoading, refetch: refetchNfts } = useUserCoverNfts(userAddress);
+
+   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/cover-offer/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/cover-offer/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 };
+}

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,
+  };
+}

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

@@ -0,0 +1,26 @@
+import { useUserNfts, type UserNft } from "@turtleclub/hooks";
+import { NEXUS_COVER_NFT_ADDRESS } from "../constants";
+
+export type CoverNft = UserNft;
+
+interface UseUserCoverNftsReturn {
+   coverNfts: CoverNft[];
+   isLoading: boolean;
+   error: string | null;
+   refetch: () => void;
+}
+
+export function useUserCoverNfts(userAddress: string | undefined): UseUserCoverNftsReturn {
+   const { data, isLoading, error, refetch } = useUserNfts({
+      userAddress,
+      chain: 1,
+      tokenAddress: NEXUS_COVER_NFT_ADDRESS,
+   });
+
+   return {
+      coverNfts: data ?? [],
+      isLoading,
+      error: error?.message ?? null,
+      refetch,
+   };
+}

package/src/cover-offer/index.ts

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