@glowlabs-org/utils 0.1.5 → 0.2.0

package/src/lib/hooks/use-forwarder.ts

@@ -0,0 +1,564 @@
+import { BigNumber, ethers } from "ethers";
+import { FORWARDER_ABI } from "../abis/forwarderABI";
+import { ERC20_ABI } from "../abis/erc20.abi";
+import { getAddresses } from "../../constants/addresses";
+
+export enum ForwarderError {
+  CONTRACT_NOT_AVAILABLE = "Contract not available",
+  SIGNER_NOT_AVAILABLE = "Signer not available",
+  UNKNOWN_ERROR = "Unknown error",
+  INVALID_FORWARD_TYPE = "Invalid forward type",
+  MISSING_REQUIRED_PARAMS = "Missing required parameters",
+}
+
+// Forward types based on API router documentation
+export type ForwardType =
+  | "PayProtocolFeeAndMintGCTLAndStake"
+  | "PayProtocolFee"
+  | "MintGCTLAndStake"
+  | "MintGCTL"
+  | "BuySolarFarm";
+
+// Currency types
+export type Currency = "USDC" | "GLW" | "USDG";
+
+// Forward parameters interface
+export interface ForwardParams {
+  amount: BigNumber;
+  userAddress: string;
+  type: ForwardType;
+  currency?: Currency;
+  applicationId?: string;
+  farmId?: string;
+  regionId?: number;
+}
+
+// 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 ForwarderError.UNKNOWN_ERROR;
+}
+
+// Type-guard style helper to ensure a signer exists throughout the rest of the function.
+function assertSigner(
+  maybeSigner: ethers.providers.JsonRpcSigner | undefined
+): asserts maybeSigner is ethers.providers.JsonRpcSigner {
+  if (!maybeSigner) {
+    throw new Error(ForwarderError.SIGNER_NOT_AVAILABLE);
+  }
+}
+
+export function useForwarder(
+  signer: ethers.providers.JsonRpcSigner | 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 Forwarder
+  function getForwarderContract() {
+    assertSigner(signer);
+    return new ethers.Contract(ADDRESSES.FORWARDER, FORWARDER_ABI, signer);
+  }
+
+  /**
+   * Construct the message for the forward call based on type and parameters
+   */
+  function constructForwardMessage(params: ForwardParams): string {
+    const { type, applicationId, farmId, regionId, userAddress } = params;
+
+    switch (type) {
+      case "PayProtocolFeeAndMintGCTLAndStake":
+        if (!applicationId) {
+          throw new Error(ForwarderError.MISSING_REQUIRED_PARAMS);
+        }
+        return `PayProtocolFeeAndMintGCTLAndStake::${applicationId}`;
+
+      case "PayProtocolFee":
+        if (!applicationId) {
+          throw new Error(ForwarderError.MISSING_REQUIRED_PARAMS);
+        }
+        return `PayProtocolFee::${applicationId}`;
+
+      case "MintGCTLAndStake":
+        if (!regionId) {
+          throw new Error(ForwarderError.MISSING_REQUIRED_PARAMS);
+        }
+        return `MintGCTLAndStake::${regionId}`;
+
+      case "MintGCTL":
+        if (!userAddress) {
+          throw new Error(ForwarderError.MISSING_REQUIRED_PARAMS);
+        }
+        return `MintGCTL::${userAddress}`;
+
+      case "BuySolarFarm":
+        if (!farmId) {
+          throw new Error(ForwarderError.MISSING_REQUIRED_PARAMS);
+        }
+        return `BuySolarFarm::${farmId}`;
+
+      default:
+        throw new Error(ForwarderError.INVALID_FORWARD_TYPE);
+    }
+  }
+
+  /**
+   * Get the appropriate token contract based on currency
+   */
+  function getTokenContract(currency: Currency = "USDC") {
+    assertSigner(signer);
+
+    let tokenAddress: string;
+    switch (currency) {
+      case "USDC":
+        tokenAddress = ADDRESSES.USDC;
+        break;
+      case "GLW":
+        tokenAddress = ADDRESSES.GLW;
+        break;
+      case "USDG":
+        tokenAddress = ADDRESSES.USDG;
+        break;
+      default:
+        throw new Error(
+          `Currency ${currency} not yet supported. Only USDC, GLW, and USDG are currently supported.`
+        );
+    }
+
+    return new ethers.Contract(tokenAddress, ERC20_ABI, signer);
+  }
+
+  /**
+   * Check current token allowance for the forwarder contract
+   * @param owner The wallet address to check allowance for
+   * @param currency The currency to check allowance for
+   */
+  async function checkTokenAllowance(
+    owner: string,
+    currency: Currency = "USDC"
+  ): Promise<BigNumber> {
+    assertSigner(signer);
+
+    try {
+      const tokenContract = getTokenContract(currency);
+      if (!tokenContract)
+        throw new Error(ForwarderError.CONTRACT_NOT_AVAILABLE);
+
+      const allowance: BigNumber = await tokenContract.allowance(
+        owner,
+        ADDRESSES.FORWARDER
+      );
+      return allowance;
+    } catch (error) {
+      throw new Error(parseEthersError(error));
+    }
+  }
+
+  /**
+   * Check user's token balance
+   * @param owner The wallet address to check balance for
+   * @param currency The currency to check balance for
+   */
+  async function checkTokenBalance(
+    owner: string,
+    currency: Currency = "USDC"
+  ): Promise<BigNumber> {
+    assertSigner(signer);
+
+    try {
+      const tokenContract = getTokenContract(currency);
+      if (!tokenContract)
+        throw new Error(ForwarderError.CONTRACT_NOT_AVAILABLE);
+
+      const balance: BigNumber = await tokenContract.balanceOf(owner);
+      return balance;
+    } catch (error) {
+      throw new Error(parseEthersError(error));
+    }
+  }
+
+  /**
+   * Approve tokens for the forwarder contract
+   * @param amount Amount to approve (BigNumber)
+   * @param currency The currency to approve
+   */
+  async function approveToken(
+    amount: BigNumber,
+    currency: Currency = "USDC"
+  ): Promise<boolean> {
+    assertSigner(signer);
+
+    try {
+      const tokenContract = getTokenContract(currency);
+      if (!tokenContract)
+        throw new Error(ForwarderError.CONTRACT_NOT_AVAILABLE);
+
+      setIsProcessing(true);
+
+      // Approve only the specific amount needed
+      const approveTx = await tokenContract.approve(
+        ADDRESSES.FORWARDER,
+        amount
+      );
+      await approveTx.wait();
+
+      return true;
+    } catch (error) {
+      throw new Error(parseEthersError(error));
+    } finally {
+      setIsProcessing(false);
+    }
+  }
+
+  /**
+   * Forward tokens through the forwarder contract with type-specific handling
+   * @param params Forward parameters including type, amount, and required fields
+   */
+  async function forwardTokens(params: ForwardParams): Promise<string> {
+    assertSigner(signer);
+
+    try {
+      const forwarderContract = getForwarderContract();
+      if (!forwarderContract)
+        throw new Error(ForwarderError.CONTRACT_NOT_AVAILABLE);
+
+      setIsProcessing(true);
+
+      const { amount, currency = "USDC" } = params;
+      const tokenContract = getTokenContract(currency);
+      if (!tokenContract)
+        throw new Error(ForwarderError.CONTRACT_NOT_AVAILABLE);
+
+      const owner = await signer.getAddress();
+
+      // Construct the appropriate message for this forward type
+      const message = constructForwardMessage(params);
+
+      // Check allowance and approve if necessary
+      const allowance: BigNumber = await tokenContract.allowance(
+        owner,
+        ADDRESSES.FORWARDER
+      );
+
+      if (allowance.lt(amount)) {
+        try {
+          const approveTx = await tokenContract.approve(
+            ADDRESSES.FORWARDER,
+            ethers.constants.MaxUint256
+          );
+          await approveTx.wait();
+        } catch (approveError) {
+          throw new Error(
+            parseEthersError(approveError) || "Token approval failed"
+          );
+        }
+      }
+
+      // Get the token address based on currency
+      let tokenAddress: string;
+      switch (currency) {
+        case "USDC":
+          tokenAddress = ADDRESSES.USDC;
+          break;
+        case "USDG":
+          tokenAddress = ADDRESSES.USDG;
+          break;
+        case "GLW":
+          tokenAddress = ADDRESSES.GLW;
+          break;
+        default:
+          throw new Error(`Unsupported currency for forwarding: ${currency}`);
+      }
+
+      // Run a static call first to surface any revert reason
+      try {
+        await forwarderContract.callStatic.forward(
+          tokenAddress,
+          ADDRESSES.FOUNDATION_WALLET,
+          amount,
+          message,
+          { from: owner }
+        );
+      } catch (staticError) {
+        throw new Error(parseEthersError(staticError));
+      }
+
+      // Execute the forward transaction
+      const tx = await forwarderContract.forward(
+        tokenAddress,
+        ADDRESSES.FOUNDATION_WALLET,
+        amount,
+        message
+      );
+      await tx.wait();
+
+      return tx.hash;
+    } catch (txError: any) {
+      throw new Error(parseEthersError(txError));
+    } finally {
+      setIsProcessing(false);
+    }
+  }
+
+  /**
+   * Forward tokens for protocol fee payment and GCTL minting with staking
+   */
+  async function payProtocolFeeAndMintGCTLAndStake(
+    amount: BigNumber,
+    userAddress: string,
+    applicationId: string,
+    regionId?: number,
+    currency: Currency = "USDC"
+  ): Promise<string> {
+    assertSigner(signer);
+
+    // GCTL minting only supports USDC and USDG
+    if (currency === "GLW") {
+      throw new Error(
+        "GCTL minting is not supported with GLW payment. Use USDC or USDG."
+      );
+    }
+
+    return forwardTokens({
+      amount,
+      userAddress,
+      type: "PayProtocolFeeAndMintGCTLAndStake",
+      currency,
+      applicationId,
+      regionId,
+    });
+  }
+
+  /**
+   * Forward tokens for protocol fee payment only
+   */
+  async function payProtocolFee(
+    amount: BigNumber,
+    userAddress: string,
+    applicationId: string,
+    currency: Currency = "USDC"
+  ): Promise<string> {
+    assertSigner(signer);
+
+    return forwardTokens({
+      amount,
+      userAddress,
+      type: "PayProtocolFee",
+      currency,
+      applicationId,
+    });
+  }
+
+  /**
+   * Forward USDC to mint GCTL and stake to a region
+   */
+  async function mintGCTLAndStake(
+    amount: BigNumber,
+    userAddress: string,
+    regionId?: number
+  ): Promise<string> {
+    assertSigner(signer);
+
+    return forwardTokens({
+      amount,
+      userAddress,
+      type: "MintGCTLAndStake",
+      currency: "USDC",
+      regionId,
+    });
+  }
+
+  /**
+   * Forward USDC to mint GCTL (existing functionality, keeping for compatibility)
+   */
+  async function mintGCTL(
+    amount: BigNumber,
+    userAddress: string
+  ): Promise<string> {
+    assertSigner(signer);
+
+    return forwardTokens({
+      amount,
+      userAddress,
+      type: "MintGCTL",
+      currency: "USDC",
+    });
+  }
+
+  /**
+   * Forward tokens to buy a solar farm
+   */
+  async function buySolarFarm(
+    amount: BigNumber,
+    userAddress: string,
+    farmId: string,
+    currency: Currency = "USDC"
+  ): Promise<string> {
+    assertSigner(signer);
+
+    return forwardTokens({
+      amount,
+      userAddress,
+      type: "BuySolarFarm",
+      currency,
+      farmId,
+    });
+  }
+
+  /**
+   * Estimate gas for forwarding with type-specific handling
+   * @param params Forward parameters
+   * @param ethPriceInUSD Current ETH price in USD (for cost estimation)
+   */
+  async function estimateGasForForward(
+    params: ForwardParams,
+    ethPriceInUSD: number | null
+  ): Promise<string> {
+    assertSigner(signer);
+
+    try {
+      const forwarderContract = getForwarderContract();
+      if (!forwarderContract)
+        throw new Error(ForwarderError.CONTRACT_NOT_AVAILABLE);
+
+      const { amount, currency = "USDC" } = params;
+
+      // Construct the appropriate message for this forward type
+      const message = constructForwardMessage(params);
+
+      // Get token address
+      let tokenAddress: string;
+      switch (currency) {
+        case "USDC":
+          tokenAddress = ADDRESSES.USDC;
+          break;
+        case "USDG":
+          tokenAddress = ADDRESSES.USDG;
+          break;
+        case "GLW":
+          tokenAddress = ADDRESSES.GLW;
+          break;
+        default:
+          throw new Error(
+            `Unsupported currency for gas estimation: ${currency}`
+          );
+      }
+
+      const gasPrice = await signer.getGasPrice();
+      const estimatedGas = await forwarderContract.estimateGas.forward(
+        tokenAddress,
+        ADDRESSES.FOUNDATION_WALLET,
+        amount,
+        message
+      );
+      const estimatedCost = estimatedGas.mul(gasPrice);
+
+      if (ethPriceInUSD) {
+        const estimatedCostInEth = ethers.utils.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));
+    }
+  }
+
+  /**
+   * Mint test USDC (only works on testnets with mintable USDC contracts)
+   * @param amount Amount of USDC to mint (BigNumber, 6 decimals)
+   * @param recipient Address to mint USDC to
+   */
+  async function mintTestUSDC(
+    amount: BigNumber,
+    recipient: string
+  ): Promise<string> {
+    assertSigner(signer);
+    if (CHAIN_ID !== 11155111) {
+      throw new Error("Minting test USDC is only supported on Sepolia");
+    }
+
+    try {
+      const usdcContract = getTokenContract("USDC"); // Use getTokenContract for consistency
+      if (!usdcContract) throw new Error(ForwarderError.CONTRACT_NOT_AVAILABLE);
+
+      setIsProcessing(true);
+
+      // Try to call mint function (common for test tokens)
+      const tx = await usdcContract.mint(recipient, amount);
+      await tx.wait();
+
+      return tx.hash;
+    } catch (error: any) {
+      // If mint function doesn't exist or fails, provide helpful error
+      const errorMessage = parseEthersError(error);
+      if (errorMessage.includes("mint")) {
+        throw new Error("This USDC contract doesn't support minting");
+      }
+      throw new Error(errorMessage);
+    } finally {
+      setIsProcessing(false);
+    }
+  }
+
+  return {
+    // New methods for different forward types
+    forwardTokens,
+    payProtocolFeeAndMintGCTLAndStake,
+    payProtocolFee,
+    mintGCTLAndStake,
+    mintGCTL,
+    buySolarFarm,
+
+    // Token operations
+    approveToken,
+    checkTokenAllowance,
+    checkTokenBalance,
+
+    // Utility methods
+    estimateGasForForward,
+    mintTestUSDC,
+    constructForwardMessage,
+
+    // State
+    get isProcessing() {
+      return isProcessing;
+    },
+    addresses: ADDRESSES,
+
+    // Signer availability
+    isSignerAvailable: !!signer,
+  };
+}