@glowlabs-org/utils 0.2.95 → 0.2.96

package/src/lib/hooks/use-offchain-fractions.ts

@@ -0,0 +1,737 @@
+import { Contract, type Signer } from "ethers";
+import { OFFCHAIN_FRACTIONS_ABI } from "../abis/offchainFractions";
+import { ERC20_ABI } from "../abis/erc20.abi";
+import { getAddresses } from "../../constants/addresses";
+import { formatEther } from "viem";
+
+export enum OffchainFractionsError {
+  CONTRACT_NOT_AVAILABLE = "Contract not available",
+  SIGNER_NOT_AVAILABLE = "Signer not available",
+  UNKNOWN_ERROR = "Unknown error",
+  INVALID_PARAMETERS = "Invalid parameters",
+  FRACTION_NOT_FOUND = "Fraction not found",
+  INSUFFICIENT_BALANCE = "Insufficient balance",
+  INSUFFICIENT_ALLOWANCE = "Insufficient allowance",
+}
+
+// Fraction data structure matching the contract
+export interface FractionData {
+  token: string;
+  expiration: number;
+  manuallyClosed: boolean;
+  minSharesToRaise: bigint;
+  useCounterfactualAddress: boolean;
+  claimedFromMinSharesToRaise: boolean;
+  owner: string;
+  step: bigint;
+  to: string;
+  soldSteps: bigint;
+  totalSteps: bigint;
+}
+
+// Parameters for creating a new fraction
+export interface CreateFractionParams {
+  id: string; // bytes32 as hex string
+  token: string;
+  step: bigint; // Price per step in wei
+  totalSteps: bigint;
+  expiration: number; // Unix timestamp
+  to: string; // Recipient address
+  useCounterfactualAddress: boolean;
+  minSharesToRaise: bigint; // 0 for no minimum
+}
+
+// Parameters for buying fractions
+export interface BuyFractionsParams {
+  creator: string;
+  id: string; // bytes32 as hex string
+  stepsToBuy: bigint;
+  minStepsToBuy: bigint;
+}
+
+// Utility to extract the most useful revert reason from an ethers error object
+function parseEthersError(error: unknown): string {
+  if (!error) return "Unknown error";
+  const possibleError: any = error;
+
+  // If the error originates from a callStatic it will often be found at `error?.error?.body`
+  if (possibleError?.error?.body) {
+    try {
+      const body = JSON.parse(possibleError.error.body);
+      // Hardhat style errors
+      if (body?.error?.message) return body.error.message as string;
+    } catch {}
+  }
+
+  // Found on MetaMask/Alchemy shape errors
+  if (possibleError?.data?.message) return possibleError.data.message as string;
+  if (possibleError?.error?.message)
+    return possibleError.error.message as string;
+
+  // Standard ethers v5 message
+  if (possibleError?.reason) return possibleError.reason as string;
+  if (possibleError?.message) return possibleError.message as string;
+
+  return OffchainFractionsError.UNKNOWN_ERROR;
+}
+
+// Type-guard style helper to ensure a signer exists throughout the rest of the function.
+function assertSigner(
+  maybeSigner: Signer | undefined
+): asserts maybeSigner is Signer {
+  if (!maybeSigner) {
+    throw new Error(OffchainFractionsError.SIGNER_NOT_AVAILABLE);
+  }
+}
+
+export function useOffchainFractions(
+  signer: Signer | undefined,
+  CHAIN_ID: number
+) {
+  // Use dynamic addresses based on chain configuration
+  const ADDRESSES = getAddresses(CHAIN_ID);
+
+  // Framework-agnostic processing flag
+  let isProcessing = false;
+  const setIsProcessing = (value: boolean) => {
+    isProcessing = value;
+  };
+
+  // Returns a contract instance for OffchainFractions
+  function getOffchainFractionsContract() {
+    assertSigner(signer);
+    return new Contract(
+      ADDRESSES.OFFCHAIN_FRACTIONS,
+      OFFCHAIN_FRACTIONS_ABI,
+      signer
+    );
+  }
+
+  /**
+   * Get the appropriate token contract
+   */
+  function getTokenContract(tokenAddress: string) {
+    assertSigner(signer);
+    return new Contract(tokenAddress, ERC20_ABI, signer);
+  }
+
+  /**
+   * Check current token allowance for the offchain fractions contract
+   * @param owner The wallet address to check allowance for
+   * @param tokenAddress The token contract address
+   */
+  async function checkTokenAllowance(
+    owner: string,
+    tokenAddress: string
+  ): Promise<bigint> {
+    assertSigner(signer);
+
+    try {
+      const tokenContract = getTokenContract(tokenAddress);
+      if (!tokenContract)
+        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+
+      const allowance: bigint = await tokenContract.allowance(
+        owner,
+        ADDRESSES.OFFCHAIN_FRACTIONS
+      );
+      return allowance;
+    } catch (error) {
+      throw new Error(parseEthersError(error));
+    }
+  }
+
+  /**
+   * Check user's token balance
+   * @param owner The wallet address to check balance for
+   * @param tokenAddress The token contract address
+   */
+  async function checkTokenBalance(
+    owner: string,
+    tokenAddress: string
+  ): Promise<bigint> {
+    assertSigner(signer);
+
+    try {
+      const tokenContract = getTokenContract(tokenAddress);
+      if (!tokenContract)
+        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+
+      const balance: bigint = await tokenContract.balanceOf(owner);
+      return balance;
+    } catch (error) {
+      throw new Error(parseEthersError(error));
+    }
+  }
+
+  /**
+   * Approve tokens for the offchain fractions contract
+   * @param tokenAddress The token contract address
+   * @param amount Amount to approve (BigNumber)
+   */
+  async function approveToken(
+    tokenAddress: string,
+    amount: bigint
+  ): Promise<boolean> {
+    assertSigner(signer);
+
+    try {
+      const tokenContract = getTokenContract(tokenAddress);
+      if (!tokenContract)
+        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+
+      setIsProcessing(true);
+
+      const approveTx = await tokenContract.approve(
+        ADDRESSES.OFFCHAIN_FRACTIONS,
+        amount
+      );
+      await approveTx.wait();
+
+      return true;
+    } catch (error) {
+      throw new Error(parseEthersError(error));
+    } finally {
+      setIsProcessing(false);
+    }
+  }
+
+  /**
+   * Create a new fractional token sale
+   * @param params Parameters for creating the fraction
+   */
+  async function createFraction(params: CreateFractionParams): Promise<string> {
+    assertSigner(signer);
+
+    try {
+      const contract = getOffchainFractionsContract();
+      if (!contract)
+        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+
+      setIsProcessing(true);
+
+      const {
+        id,
+        token,
+        step,
+        totalSteps,
+        expiration,
+        to,
+        useCounterfactualAddress,
+        minSharesToRaise,
+      } = params;
+
+      // Validate parameters
+      if (!id || !token || !to) {
+        throw new Error(OffchainFractionsError.INVALID_PARAMETERS);
+      }
+
+      if (step === 0n || totalSteps === 0n) {
+        throw new Error("Step and totalSteps must be greater than zero");
+      }
+
+      if (minSharesToRaise > totalSteps) {
+        throw new Error("minSharesToRaise cannot be greater than totalSteps");
+      }
+
+      // Run a static call first to surface any revert reason
+      try {
+        await contract
+          .getFunction("createFraction")
+          .staticCall(
+            id,
+            token,
+            step,
+            totalSteps,
+            expiration,
+            to,
+            useCounterfactualAddress,
+            minSharesToRaise
+          );
+      } catch (staticError) {
+        throw new Error(parseEthersError(staticError));
+      }
+
+      // Execute the transaction
+      const tx = await contract.getFunction("createFraction")(
+        id,
+        token,
+        step,
+        totalSteps,
+        expiration,
+        to,
+        useCounterfactualAddress,
+        minSharesToRaise
+      );
+      await tx.wait();
+
+      return tx.hash;
+    } catch (error) {
+      throw new Error(parseEthersError(error));
+    } finally {
+      setIsProcessing(false);
+    }
+  }
+
+  /**
+   * Buy fractions in an existing sale
+   * @param params Parameters for buying fractions
+   */
+  async function buyFractions(params: BuyFractionsParams): Promise<string> {
+    assertSigner(signer);
+
+    try {
+      const contract = getOffchainFractionsContract();
+      if (!contract)
+        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+
+      setIsProcessing(true);
+
+      const { creator, id, stepsToBuy, minStepsToBuy } = params;
+
+      // Validate parameters
+      if (!creator || !id) {
+        throw new Error(OffchainFractionsError.INVALID_PARAMETERS);
+      }
+
+      if (stepsToBuy === 0n) {
+        throw new Error("stepsToBuy must be greater than zero");
+      }
+
+      // Get fraction data to calculate required amount
+      const fractionData = await getFraction(creator, id);
+      const requiredAmount = stepsToBuy * fractionData.step;
+
+      const owner = await signer.getAddress();
+
+      // Check token balance
+      const balance = await checkTokenBalance(owner, fractionData.token);
+      if (balance < requiredAmount) {
+        throw new Error(OffchainFractionsError.INSUFFICIENT_BALANCE);
+      }
+
+      // Check and approve tokens if necessary
+      const allowance = await checkTokenAllowance(owner, fractionData.token);
+      if (allowance < requiredAmount) {
+        const tokenContract = getTokenContract(fractionData.token);
+        const approveTx = await tokenContract.approve(
+          ADDRESSES.OFFCHAIN_FRACTIONS,
+          requiredAmount
+        );
+        await approveTx.wait();
+      }
+
+      // Run a static call first to surface any revert reason
+      try {
+        await contract
+          .getFunction("buyFractions")
+          .staticCall(creator, id, stepsToBuy, minStepsToBuy, {
+            from: owner,
+          });
+      } catch (staticError) {
+        throw new Error(parseEthersError(staticError));
+      }
+
+      // Execute the transaction
+      const tx = await contract.getFunction("buyFractions")(
+        creator,
+        id,
+        stepsToBuy,
+        minStepsToBuy
+      );
+      await tx.wait();
+
+      return tx.hash;
+    } catch (error) {
+      throw new Error(parseEthersError(error));
+    } finally {
+      setIsProcessing(false);
+    }
+  }
+
+  /**
+   * Claim refund from an unfilled sale
+   * @param creator The address that created the fraction sale
+   * @param id The unique identifier of the fraction sale
+   */
+  async function claimRefund(creator: string, id: string): Promise<string> {
+    assertSigner(signer);
+
+    try {
+      const contract = getOffchainFractionsContract();
+      if (!contract)
+        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+
+      setIsProcessing(true);
+
+      // Validate parameters
+      if (!creator || !id) {
+        throw new Error(OffchainFractionsError.INVALID_PARAMETERS);
+      }
+
+      const owner = await signer.getAddress();
+
+      // Check if user has steps purchased
+      const userSteps = await getStepsPurchased(owner, creator, id);
+      if (userSteps === 0n) {
+        throw new Error("No steps purchased for this fraction");
+      }
+
+      // Run a static call first to surface any revert reason
+      try {
+        await contract.getFunction("claimRefund").staticCall(creator, id, {
+          from: owner,
+        });
+      } catch (staticError) {
+        throw new Error(parseEthersError(staticError));
+      }
+
+      // Execute the transaction
+      const tx = await contract.getFunction("claimRefund")(creator, id);
+      await tx.wait();
+
+      return tx.hash;
+    } catch (error) {
+      throw new Error(parseEthersError(error));
+    } finally {
+      setIsProcessing(false);
+    }
+  }
+
+  /**
+   * Close a fraction sale manually (only by owner)
+   * @param id The unique identifier of the fraction sale to close
+   */
+  async function closeFraction(id: string): Promise<string> {
+    assertSigner(signer);
+
+    try {
+      const contract = getOffchainFractionsContract();
+      if (!contract)
+        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+
+      setIsProcessing(true);
+
+      // Validate parameters
+      if (!id) {
+        throw new Error(OffchainFractionsError.INVALID_PARAMETERS);
+      }
+
+      const owner = await signer.getAddress();
+
+      // Run a static call first to surface any revert reason
+      try {
+        await contract.getFunction("closeFraction").staticCall(id, {
+          from: owner,
+        });
+      } catch (staticError) {
+        throw new Error(parseEthersError(staticError));
+      }
+
+      // Execute the transaction
+      const tx = await contract.getFunction("closeFraction")(id);
+      await tx.wait();
+
+      return tx.hash;
+    } catch (error) {
+      throw new Error(parseEthersError(error));
+    } finally {
+      setIsProcessing(false);
+    }
+  }
+
+  /**
+   * Get fraction data for a specific creator and ID
+   * @param creator The address that created the fraction sale
+   * @param id The unique identifier of the fraction sale
+   */
+  async function getFraction(
+    creator: string,
+    id: string
+  ): Promise<FractionData> {
+    assertSigner(signer);
+
+    try {
+      const contract = getOffchainFractionsContract();
+      if (!contract)
+        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+
+      const result = await contract.getFraction(creator, id);
+
+      return {
+        token: result.token,
+        expiration: Number(result.expiration),
+        manuallyClosed: result.manuallyClosed,
+        minSharesToRaise: result.minSharesToRaise,
+        useCounterfactualAddress: result.useCounterfactualAddress,
+        claimedFromMinSharesToRaise: result.claimedFromMinSharesToRaise,
+        owner: result.owner,
+        step: result.step,
+        to: result.to,
+        soldSteps: result.soldSteps,
+        totalSteps: result.totalSteps,
+      };
+    } catch (error) {
+      throw new Error(parseEthersError(error));
+    }
+  }
+
+  /**
+   * Get the number of steps purchased by a user for a specific fraction
+   * @param user The user address
+   * @param creator The address that created the fraction sale
+   * @param id The unique identifier of the fraction sale
+   */
+  async function getStepsPurchased(
+    user: string,
+    creator: string,
+    id: string
+  ): Promise<bigint> {
+    assertSigner(signer);
+
+    try {
+      const contract = getOffchainFractionsContract();
+      if (!contract)
+        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+
+      const result = await contract.stepsPurchased(user, creator, id);
+      return result;
+    } catch (error) {
+      throw new Error(parseEthersError(error));
+    }
+  }
+
+  /**
+   * Check if a fraction sale is expired
+   * @param creator The address that created the fraction sale
+   * @param id The unique identifier of the fraction sale
+   */
+  async function isFractionExpired(
+    creator: string,
+    id: string
+  ): Promise<boolean> {
+    try {
+      const fraction = await getFraction(creator, id);
+      return Date.now() / 1000 > fraction.expiration;
+    } catch (error) {
+      throw new Error(parseEthersError(error));
+    }
+  }
+
+  /**
+   * Check if a fraction sale has reached its minimum shares threshold
+   * @param creator The address that created the fraction sale
+   * @param id The unique identifier of the fraction sale
+   */
+  async function hasReachedMinimumShares(
+    creator: string,
+    id: string
+  ): Promise<boolean> {
+    try {
+      const fraction = await getFraction(creator, id);
+      return fraction.soldSteps >= fraction.minSharesToRaise;
+    } catch (error) {
+      throw new Error(parseEthersError(error));
+    }
+  }
+
+  /**
+   * Check if a fraction sale is completely filled
+   * @param creator The address that created the fraction sale
+   * @param id The unique identifier of the fraction sale
+   */
+  async function isFractionCompletelyFilled(
+    creator: string,
+    id: string
+  ): Promise<boolean> {
+    try {
+      const fraction = await getFraction(creator, id);
+      return fraction.soldSteps >= fraction.totalSteps;
+    } catch (error) {
+      throw new Error(parseEthersError(error));
+    }
+  }
+
+  /**
+   * Calculate the total amount raised for a fraction
+   * @param creator The address that created the fraction sale
+   * @param id The unique identifier of the fraction sale
+   */
+  async function getTotalAmountRaised(
+    creator: string,
+    id: string
+  ): Promise<bigint> {
+    try {
+      const fraction = await getFraction(creator, id);
+      return fraction.soldSteps * fraction.step;
+    } catch (error) {
+      throw new Error(parseEthersError(error));
+    }
+  }
+
+  /**
+   * Calculate the remaining steps available for purchase
+   * @param creator The address that created the fraction sale
+   * @param id The unique identifier of the fraction sale
+   */
+  async function getRemainingSteps(
+    creator: string,
+    id: string
+  ): Promise<bigint> {
+    try {
+      const fraction = await getFraction(creator, id);
+      return fraction.totalSteps - fraction.soldSteps;
+    } catch (error) {
+      throw new Error(parseEthersError(error));
+    }
+  }
+
+  /**
+   * Estimate gas for creating a fraction
+   * @param params Parameters for creating the fraction
+   * @param ethPriceInUSD Current ETH price in USD (for cost estimation)
+   */
+  async function estimateGasForCreateFraction(
+    params: CreateFractionParams,
+    ethPriceInUSD: number | null
+  ): Promise<string> {
+    assertSigner(signer);
+
+    try {
+      const contract = getOffchainFractionsContract();
+      if (!contract)
+        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+
+      const {
+        id,
+        token,
+        step,
+        totalSteps,
+        expiration,
+        to,
+        useCounterfactualAddress,
+        minSharesToRaise,
+      } = params;
+
+      const feeData = await signer.provider?.getFeeData();
+      const gasPrice =
+        feeData?.gasPrice ?? feeData?.maxFeePerGas ?? (0n as bigint);
+      if (gasPrice === 0n) {
+        throw new Error("Could not fetch gas price to estimate cost.");
+      }
+
+      const estimatedGas: bigint = await contract
+        .getFunction("createFraction")
+        .estimateGas(
+          id,
+          token,
+          step,
+          totalSteps,
+          expiration,
+          to,
+          useCounterfactualAddress,
+          minSharesToRaise
+        );
+
+      const estimatedCost: bigint = estimatedGas * gasPrice;
+
+      if (ethPriceInUSD) {
+        const estimatedCostInEth = formatEther(estimatedCost);
+        const estimatedCostInUSD = (
+          parseFloat(estimatedCostInEth) * ethPriceInUSD
+        ).toFixed(2);
+        return estimatedCostInUSD;
+      } else {
+        throw new Error(
+          "Could not fetch the ETH price to calculate cost in USD."
+        );
+      }
+    } catch (error: any) {
+      throw new Error(parseEthersError(error));
+    }
+  }
+
+  /**
+   * Estimate gas for buying fractions
+   * @param params Parameters for buying fractions
+   * @param ethPriceInUSD Current ETH price in USD (for cost estimation)
+   */
+  async function estimateGasForBuyFractions(
+    params: BuyFractionsParams,
+    ethPriceInUSD: number | null
+  ): Promise<string> {
+    assertSigner(signer);
+
+    try {
+      const contract = getOffchainFractionsContract();
+      if (!contract)
+        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+
+      const { creator, id, stepsToBuy, minStepsToBuy } = params;
+
+      const feeData = await signer.provider?.getFeeData();
+      const gasPrice =
+        feeData?.gasPrice ?? feeData?.maxFeePerGas ?? (0n as bigint);
+      if (gasPrice === 0n) {
+        throw new Error("Could not fetch gas price to estimate cost.");
+      }
+
+      const estimatedGas: bigint = await contract
+        .getFunction("buyFractions")
+        .estimateGas(creator, id, stepsToBuy, minStepsToBuy);
+
+      const estimatedCost: bigint = estimatedGas * gasPrice;
+
+      if (ethPriceInUSD) {
+        const estimatedCostInEth = formatEther(estimatedCost);
+        const estimatedCostInUSD = (
+          parseFloat(estimatedCostInEth) * ethPriceInUSD
+        ).toFixed(2);
+        return estimatedCostInUSD;
+      } else {
+        throw new Error(
+          "Could not fetch the ETH price to calculate cost in USD."
+        );
+      }
+    } catch (error: any) {
+      throw new Error(parseEthersError(error));
+    }
+  }
+
+  return {
+    // Core contract functions
+    createFraction,
+    buyFractions,
+    claimRefund,
+    closeFraction,
+
+    // View functions
+    getFraction,
+    getStepsPurchased,
+
+    // Token operations
+    approveToken,
+    checkTokenAllowance,
+    checkTokenBalance,
+
+    // Utility functions
+    isFractionExpired,
+    hasReachedMinimumShares,
+    isFractionCompletelyFilled,
+    getTotalAmountRaised,
+    getRemainingSteps,
+
+    // Gas estimation
+    estimateGasForCreateFraction,
+    estimateGasForBuyFractions,
+
+    // State
+    get isProcessing() {
+      return isProcessing;
+    },
+    addresses: ADDRESSES,
+
+    // Signer availability
+    isSignerAvailable: !!signer,
+  };
+}