@turtleclub/covers 0.1.0-beta.1

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

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

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

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

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

@@ -0,0 +1,41 @@
+import { CoverAsset } from "@nexusmutual/sdk";
+import type { Opportunity } from "@turtleclub/hooks";
+import type { Asset } from "@turtleclub/ui";
+
+// The Nexus SDK doesn't export the NexusProduct type, so we need to define it ourselves.
+// The product has more attributes than just id, name, and coverAssets, but this are the only ones we need for now.
+export type NexusProduct = {
+   id: number;
+   name: string;
+   coverAssets: string[];
+};
+
+export interface CoverOfferCardProps {
+   productId: number;
+   opportunity: Opportunity;
+   buyerAddress: string;
+   protocolName: string;
+   coverProductName: string;
+   coverAvailableAssets: string[];
+   onSuccess?: (message: string) => void;
+   onError?: (message: string) => void;
+   startExpanded?: boolean;
+}
+
+export interface NexusCoverSectionProps {
+   opportunity: Opportunity;
+   buyerAddress: string;
+   onSuccess?: (message: string) => void;
+   onError?: (message: string) => void;
+   className?: string;
+   startExpanded?: boolean;
+}
+
+export interface CoverRequestFormProps {
+   protocolName: string;
+   baseApyLabel?: string;
+   onDismiss?: () => void;
+   onSuccess?: (message: string) => void;
+   onError?: (message: string) => void;
+   startExpanded?: boolean;
+}

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

@@ -0,0 +1,95 @@
+import { CoverAsset } from "@nexusmutual/sdk";
+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 nowSec = Math.floor(Date.now() / 1000);
+   const expiresSec = startSec + periodSec;
+   const graceEndsSec = expiresSec + gracePeriodSec;
+   const remainingSec = Math.max(0, expiresSec - nowSec);
+
+   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,
+      remainingDays: Math.ceil(remainingSec / SECS_IN_DAY),
+      isExpired: nowSec > expiresSec,
+      isInGracePeriod: nowSec > expiresSec && nowSec <= graceEndsSec,
+      expiresSec,
+      graceEndsSec,
+   };
+}
+
+export const TOKEN_SYMBOL_TO_COVER_ASSET: Record<string, CoverAsset> = {
+   ETH: CoverAsset.ETH,
+   DAI: CoverAsset.DAI,
+   USDC: CoverAsset.USDC,
+   cbBTC: CoverAsset.cbBTC,
+};

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "jsx": "react-jsx",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "allowImportingTsExtensions": true,
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}