@glowlabs-org/utils 0.2.109 → 0.2.110

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

@@ -22,7 +22,6 @@ export interface FractionData {
   minSharesToRaise: bigint;
   useCounterfactualAddress: boolean;
   claimedFromMinSharesToRaise: boolean;
-  owner: string;
   step: bigint;
   to: string;
   soldSteps: bigint;
@@ -49,6 +48,15 @@ export interface BuyFractionsParams {
   id: string; // bytes32 as hex string
   stepsToBuy: bigint;
   minStepsToBuy: bigint;
+  refundTo: string; // Address to receive refunds if needed
+  creditTo: string; // Address to credit the purchase to
+  useCounterfactualAddressForRefund: boolean; // Whether to use counterfactual address for refunds
+}
+
+// Refund details structure matching the contract
+export interface RefundDetails {
+  refundTo: string;
+  useCounterfactualAddress: boolean;
 }
 
 // Utility to extract the most useful revert reason from an ethers error object
@@ -292,10 +300,18 @@ export function useOffchainFractions(
 
       setIsProcessing(true);
 
-      const { creator, id, stepsToBuy, minStepsToBuy } = params;
+      const {
+        creator,
+        id,
+        stepsToBuy,
+        minStepsToBuy,
+        refundTo,
+        creditTo,
+        useCounterfactualAddressForRefund,
+      } = params;
 
       // Validate parameters
-      if (!creator || !id) {
+      if (!creator || !id || !refundTo || !creditTo) {
         throw new Error(OffchainFractionsError.INVALID_PARAMETERS);
       }
 
@@ -303,6 +319,10 @@ export function useOffchainFractions(
         throw new Error("stepsToBuy must be greater than zero");
       }
 
+      if (minStepsToBuy === 0n) {
+        throw new Error("minStepsToBuy must be greater than zero");
+      }
+
       // Get fraction data to calculate required amount
       const fractionData = await getFraction(creator, id);
       const requiredAmount = stepsToBuy * fractionData.step;
@@ -330,9 +350,18 @@ export function useOffchainFractions(
       try {
         await contract
           .getFunction("buyFractions")
-          .staticCall(creator, id, stepsToBuy, minStepsToBuy, {
-            from: owner,
-          });
+          .staticCall(
+            creator,
+            id,
+            stepsToBuy,
+            minStepsToBuy,
+            refundTo,
+            creditTo,
+            useCounterfactualAddressForRefund,
+            {
+              from: owner,
+            }
+          );
       } catch (staticError) {
         throw new Error(parseEthersError(staticError));
       }
@@ -342,7 +371,10 @@ export function useOffchainFractions(
         creator,
         id,
         stepsToBuy,
-        minStepsToBuy
+        minStepsToBuy,
+        refundTo,
+        creditTo,
+        useCounterfactualAddressForRefund
       );
       await tx.wait();
 
@@ -356,10 +388,15 @@ export function useOffchainFractions(
 
   /**
    * Claim refund from an unfilled sale
+   * @param user The user address claiming the refund
    * @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> {
+  async function claimRefund(
+    user: string,
+    creator: string,
+    id: string
+  ): Promise<string> {
     assertSigner(signer);
 
     try {
@@ -370,29 +407,31 @@ export function useOffchainFractions(
       setIsProcessing(true);
 
       // Validate parameters
-      if (!creator || !id) {
+      if (!user || !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);
+      const userSteps = await getStepsPurchased(user, 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,
-        });
+        await contract
+          .getFunction("claimRefund")
+          .staticCall(user, creator, id, {
+            from: owner,
+          });
       } catch (staticError) {
         throw new Error(parseEthersError(staticError));
       }
 
       // Execute the transaction
-      const tx = await contract.getFunction("claimRefund")(creator, id);
+      const tx = await contract.getFunction("claimRefund")(user, creator, id);
       await tx.wait();
 
       return tx.hash;
@@ -471,7 +510,6 @@ export function useOffchainFractions(
         minSharesToRaise: result.minSharesToRaise,
         useCounterfactualAddress: result.useCounterfactualAddress,
         claimedFromMinSharesToRaise: result.claimedFromMinSharesToRaise,
-        owner: result.owner,
         step: result.step,
         to: result.to,
         soldSteps: result.soldSteps,
@@ -512,6 +550,217 @@ export function useOffchainFractions(
     }
   }
 
+  /**
+   * Get the refund wildcard operator address
+   * @returns The wildcard operator address that can perform refunds for any user
+   */
+  async function getRefundWildcardOperator(): Promise<string> {
+    assertSigner(signer);
+
+    try {
+      const contract = getOffchainFractionsContract();
+      if (!contract)
+        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+
+      const result = await contract.getFunction("REFUND_WILDCARD_OPERATOR")();
+      return result;
+    } catch (error) {
+      throw new Error(parseEthersError(error));
+    }
+  }
+
+  /**
+   * Get refund details for a user's purchase
+   * @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 getRefundDetails(
+    user: string,
+    creator: string,
+    id: string
+  ): Promise<RefundDetails> {
+    assertSigner(signer);
+
+    try {
+      const contract = getOffchainFractionsContract();
+      if (!contract)
+        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+
+      const result = await contract.getFunction("getRefundDetails")(
+        user,
+        creator,
+        id
+      );
+      return {
+        refundTo: result.refundTo,
+        useCounterfactualAddress: result.useCounterfactualAddress,
+      };
+    } catch (error) {
+      throw new Error(parseEthersError(error));
+    }
+  }
+
+  /**
+   * Set refund details for a user's purchase
+   * @param creator The address that created the fraction sale
+   * @param id The unique identifier of the fraction sale
+   * @param refundTo The address to receive refunds
+   * @param useCounterfactualAddress Whether to use counterfactual address for refunds
+   */
+  async function setRefundDetails(
+    creator: string,
+    id: string,
+    refundTo: string,
+    useCounterfactualAddress: boolean
+  ): Promise<string> {
+    assertSigner(signer);
+
+    try {
+      const contract = getOffchainFractionsContract();
+      if (!contract)
+        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+
+      setIsProcessing(true);
+
+      // Validate parameters
+      if (!creator || !id || !refundTo) {
+        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("setRefundDetails")
+          .staticCall(creator, id, refundTo, useCounterfactualAddress, {
+            from: owner,
+          });
+      } catch (staticError) {
+        throw new Error(parseEthersError(staticError));
+      }
+
+      // Execute the transaction
+      const tx = await contract.getFunction("setRefundDetails")(
+        creator,
+        id,
+        refundTo,
+        useCounterfactualAddress
+      );
+      await tx.wait();
+
+      return tx.hash;
+    } catch (error) {
+      throw new Error(parseEthersError(error));
+    } finally {
+      setIsProcessing(false);
+    }
+  }
+
+  /**
+   * Set refund operator approval status
+   * @param refundOperator The address of the refund operator
+   * @param isApproved Whether to approve or revoke the operator
+   */
+  async function setRefundOperatorStatus(
+    refundOperator: string,
+    isApproved: boolean
+  ): Promise<string> {
+    assertSigner(signer);
+
+    try {
+      const contract = getOffchainFractionsContract();
+      if (!contract)
+        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+
+      setIsProcessing(true);
+
+      // Validate parameters
+      if (!refundOperator) {
+        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("setRefundOperatorStatus")
+          .staticCall(refundOperator, isApproved, {
+            from: owner,
+          });
+      } catch (staticError) {
+        throw new Error(parseEthersError(staticError));
+      }
+
+      // Execute the transaction
+      const tx = await contract.getFunction("setRefundOperatorStatus")(
+        refundOperator,
+        isApproved
+      );
+      await tx.wait();
+
+      return tx.hash;
+    } catch (error) {
+      throw new Error(parseEthersError(error));
+    } finally {
+      setIsProcessing(false);
+    }
+  }
+
+  /**
+   * Check if a refund operator is approved for a user
+   * @param user The user address
+   * @param refundOperator The refund operator address
+   */
+  async function isRefundOperatorApproved(
+    user: string,
+    refundOperator: string
+  ): Promise<boolean> {
+    assertSigner(signer);
+
+    try {
+      const contract = getOffchainFractionsContract();
+      if (!contract)
+        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+
+      const result = await contract.getFunction("isRefundOperatorApproved")(
+        user,
+        refundOperator
+      );
+      return result;
+    } catch (error) {
+      throw new Error(parseEthersError(error));
+    }
+  }
+
+  /**
+   * Get refund approval status for a user and operator
+   * @param user The user address
+   * @param refundOperator The refund operator address
+   */
+  async function getRefundApprovalStatus(
+    user: string,
+    refundOperator: string
+  ): Promise<boolean> {
+    assertSigner(signer);
+
+    try {
+      const contract = getOffchainFractionsContract();
+      if (!contract)
+        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
+
+      const result = await contract.getFunction("refundApprovals")(
+        user,
+        refundOperator
+      );
+      return result.isApproved;
+    } catch (error) {
+      throw new Error(parseEthersError(error));
+    }
+  }
+
   /**
    * Check if a fraction sale is expired
    * @param creator The address that created the fraction sale
@@ -680,7 +929,15 @@ export function useOffchainFractions(
       if (!contract)
         throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
 
-      const { creator, id, stepsToBuy, minStepsToBuy } = params;
+      const {
+        creator,
+        id,
+        stepsToBuy,
+        minStepsToBuy,
+        refundTo,
+        creditTo,
+        useCounterfactualAddressForRefund,
+      } = params;
 
       const feeData = await signer.provider?.getFeeData();
       const gasPrice =
@@ -691,7 +948,15 @@ export function useOffchainFractions(
 
       const estimatedGas: bigint = await contract
         .getFunction("buyFractions")
-        .estimateGas(creator, id, stepsToBuy, minStepsToBuy);
+        .estimateGas(
+          creator,
+          id,
+          stepsToBuy,
+          minStepsToBuy,
+          refundTo,
+          creditTo,
+          useCounterfactualAddressForRefund
+        );
 
       const estimatedCost: bigint = estimatedGas * gasPrice;
 
@@ -722,6 +987,14 @@ export function useOffchainFractions(
     getFraction,
     getStepsPurchased,
 
+    // Refund management functions
+    getRefundWildcardOperator,
+    getRefundDetails,
+    setRefundDetails,
+    setRefundOperatorStatus,
+    isRefundOperatorApproved,
+    getRefundApprovalStatus,
+
     // Token operations
     approveToken,
     checkTokenAllowance,