@glowlabs-org/utils 0.2.113 → 0.2.115

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

@@ -1,8 +1,12 @@
-import { Contract, type Signer } from "ethers";
+import {
+  type WalletClient,
+  type PublicClient,
+  type Address,
+  formatEther,
+} from "viem";
 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",
@@ -59,43 +63,46 @@ export interface RefundDetails {
   useCounterfactualAddress: boolean;
 }
 
-// Utility to extract the most useful revert reason from an ethers error object
-function parseEthersError(error: unknown): string {
+// Utility to extract the most useful revert reason from a viem error object
+function parseViemError(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 {}
-  }
+  // Check if it's a viem BaseError
+  if (error instanceof Error) {
+    // For contract revert errors
+    if ((error as any).cause?.reason) {
+      return (error as any).cause.reason;
+    }
 
-  // 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;
+    // For viem's shortMessage
+    if ((error as any).shortMessage) {
+      return (error as any).shortMessage;
+    }
 
-  // Standard ethers v5 message
-  if (possibleError?.reason) return possibleError.reason as string;
-  if (possibleError?.message) return possibleError.message as string;
+    // Fallback to regular message
+    if (error.message) {
+      return error.message;
+    }
+  }
 
   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) {
+// Type-guard style helper to ensure a wallet client exists throughout the rest of the function.
+function assertWalletClient(
+  maybeWalletClient: WalletClient | undefined
+): asserts maybeWalletClient is WalletClient {
+  if (!maybeWalletClient) {
     throw new Error(OffchainFractionsError.SIGNER_NOT_AVAILABLE);
   }
+  if (!maybeWalletClient.account) {
+    throw new Error("Wallet client must have an account");
+  }
 }
 
 export function useOffchainFractions(
-  signer: Signer | undefined,
+  walletClient: WalletClient | undefined,
+  publicClient: PublicClient | undefined,
   CHAIN_ID: number
 ) {
   // Use dynamic addresses based on chain configuration
@@ -107,22 +114,13 @@ export function useOffchainFractions(
     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);
+  // Helper to assert public client is available
+  function assertPublicClient(
+    maybePublicClient: PublicClient | undefined
+  ): asserts maybePublicClient is PublicClient {
+    if (!maybePublicClient) {
+      throw new Error("Public client not available");
+    }
   }
 
   /**
@@ -134,20 +132,18 @@ export function useOffchainFractions(
     owner: string,
     tokenAddress: string
   ): Promise<bigint> {
-    assertSigner(signer);
+    assertPublicClient(publicClient);
 
     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;
+      const allowance = await publicClient.readContract({
+        address: tokenAddress as Address,
+        abi: ERC20_ABI,
+        functionName: "allowance",
+        args: [owner as Address, ADDRESSES.OFFCHAIN_FRACTIONS as Address],
+      });
+      return allowance as bigint;
     } catch (error) {
-      throw new Error(parseEthersError(error));
+      throw new Error(parseViemError(error));
     }
   }
 
@@ -160,17 +156,18 @@ export function useOffchainFractions(
     owner: string,
     tokenAddress: string
   ): Promise<bigint> {
-    assertSigner(signer);
+    assertPublicClient(publicClient);
 
     try {
-      const tokenContract = getTokenContract(tokenAddress);
-      if (!tokenContract)
-        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
-
-      const balance: bigint = await tokenContract.balanceOf(owner);
-      return balance;
+      const balance = await publicClient.readContract({
+        address: tokenAddress as Address,
+        abi: ERC20_ABI,
+        functionName: "balanceOf",
+        args: [owner as Address],
+      });
+      return balance as bigint;
     } catch (error) {
-      throw new Error(parseEthersError(error));
+      throw new Error(parseViemError(error));
     }
   }
 
@@ -183,24 +180,28 @@ export function useOffchainFractions(
     tokenAddress: string,
     amount: bigint
   ): Promise<boolean> {
-    assertSigner(signer);
+    assertWalletClient(walletClient);
+    assertPublicClient(publicClient);
 
     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();
+      const hash = await walletClient.writeContract({
+        address: tokenAddress as Address,
+        abi: ERC20_ABI,
+        functionName: "approve",
+        args: [ADDRESSES.OFFCHAIN_FRACTIONS as Address, amount],
+        chain: walletClient.chain,
+        account: walletClient.account!,
+      });
+
+      await publicClient.waitForTransactionReceipt({
+        hash,
+      });
 
       return true;
     } catch (error) {
-      throw new Error(parseEthersError(error));
+      throw new Error(parseViemError(error));
     } finally {
       setIsProcessing(false);
     }
@@ -211,13 +212,10 @@ export function useOffchainFractions(
    * @param params Parameters for creating the fraction
    */
   async function createFraction(params: CreateFractionParams): Promise<string> {
-    assertSigner(signer);
+    assertWalletClient(walletClient);
+    assertPublicClient(publicClient);
 
     try {
-      const contract = getOffchainFractionsContract();
-      if (!contract)
-        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
-
       setIsProcessing(true);
 
       const {
@@ -245,42 +243,56 @@ export function useOffchainFractions(
         throw new Error("minSharesToRaise cannot be greater than totalSteps");
       }
 
-      // Run a static call first to surface any revert reason
+      // Run a simulation first to surface any revert reason
       try {
-        await contract
-          .getFunction("createFraction")
-          .staticCall(
-            id,
-            token,
+        await publicClient.simulateContract({
+          address: ADDRESSES.OFFCHAIN_FRACTIONS as Address,
+          abi: OFFCHAIN_FRACTIONS_ABI,
+          functionName: "createFraction",
+          args: [
+            id as `0x${string}`,
+            token as Address,
             step,
             totalSteps,
             expiration,
-            to,
+            to as Address,
             useCounterfactualAddress,
             minSharesToRaise,
-            closer
-          );
-      } catch (staticError) {
-        throw new Error(parseEthersError(staticError));
+            closer as Address,
+          ],
+          account: walletClient.account!,
+        });
+      } catch (simulationError) {
+        throw new Error(parseViemError(simulationError));
       }
 
       // Execute the transaction
-      const tx = await contract.getFunction("createFraction")(
-        id,
-        token,
-        step,
-        totalSteps,
-        expiration,
-        to,
-        useCounterfactualAddress,
-        minSharesToRaise,
-        closer
-      );
-      await tx.wait();
+      const hash = await walletClient.writeContract({
+        address: ADDRESSES.OFFCHAIN_FRACTIONS as Address,
+        abi: OFFCHAIN_FRACTIONS_ABI,
+        functionName: "createFraction",
+        args: [
+          id as `0x${string}`,
+          token as Address,
+          step,
+          totalSteps,
+          expiration,
+          to as Address,
+          useCounterfactualAddress,
+          minSharesToRaise,
+          closer as Address,
+        ],
+        chain: walletClient.chain,
+        account: walletClient.account!,
+      });
+
+      await publicClient.waitForTransactionReceipt({
+        hash,
+      });
 
-      return tx.hash;
+      return hash;
     } catch (error) {
-      throw new Error(parseEthersError(error));
+      throw new Error(parseViemError(error));
     } finally {
       setIsProcessing(false);
     }
@@ -291,13 +303,10 @@ export function useOffchainFractions(
    * @param params Parameters for buying fractions
    */
   async function buyFractions(params: BuyFractionsParams): Promise<string> {
-    assertSigner(signer);
+    assertWalletClient(walletClient);
+    assertPublicClient(publicClient);
 
     try {
-      const contract = getOffchainFractionsContract();
-      if (!contract)
-        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
-
       setIsProcessing(true);
 
       const {
@@ -327,7 +336,10 @@ export function useOffchainFractions(
       const fractionData = await getFraction(creator, id);
       const requiredAmount = stepsToBuy * fractionData.step;
 
-      const owner = await signer.getAddress();
+      const owner = walletClient.account?.address;
+      if (!owner) {
+        throw new Error("No account found in wallet client");
+      }
 
       // Check token balance
       const balance = await checkTokenBalance(owner, fractionData.token);
@@ -338,49 +350,65 @@ export function useOffchainFractions(
       // 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();
+        const approveHash = await walletClient.writeContract({
+          address: fractionData.token as Address,
+          abi: ERC20_ABI,
+          functionName: "approve",
+          args: [ADDRESSES.OFFCHAIN_FRACTIONS as Address, requiredAmount],
+          chain: walletClient.chain,
+          account: walletClient.account!,
+        });
+        await publicClient.waitForTransactionReceipt({
+          hash: approveHash,
+        });
       }
 
-      // Run a static call first to surface any revert reason
+      // Run a simulation first to surface any revert reason
       try {
-        await contract
-          .getFunction("buyFractions")
-          .staticCall(
-            creator,
-            id,
+        await publicClient.simulateContract({
+          address: ADDRESSES.OFFCHAIN_FRACTIONS as Address,
+          abi: OFFCHAIN_FRACTIONS_ABI,
+          functionName: "buyFractions",
+          args: [
+            creator as Address,
+            id as `0x${string}`,
             stepsToBuy,
             minStepsToBuy,
-            refundTo,
-            creditTo,
+            refundTo as Address,
+            creditTo as Address,
             useCounterfactualAddressForRefund,
-            {
-              from: owner,
-            }
-          );
-      } catch (staticError) {
-        throw new Error(parseEthersError(staticError));
+          ],
+          account: walletClient.account!,
+        });
+      } catch (simulationError) {
+        throw new Error(parseViemError(simulationError));
       }
 
       // Execute the transaction
-      const tx = await contract.getFunction("buyFractions")(
-        creator,
-        id,
-        stepsToBuy,
-        minStepsToBuy,
-        refundTo,
-        creditTo,
-        useCounterfactualAddressForRefund
-      );
-      await tx.wait();
+      const hash = await walletClient.writeContract({
+        address: ADDRESSES.OFFCHAIN_FRACTIONS as Address,
+        abi: OFFCHAIN_FRACTIONS_ABI,
+        functionName: "buyFractions",
+        args: [
+          creator as Address,
+          id as `0x${string}`,
+          stepsToBuy,
+          minStepsToBuy,
+          refundTo as Address,
+          creditTo as Address,
+          useCounterfactualAddressForRefund,
+        ],
+        chain: walletClient.chain,
+        account: walletClient.account!,
+      });
 
-      return tx.hash;
+      await publicClient.waitForTransactionReceipt({
+        hash,
+      });
+
+      return hash;
     } catch (error) {
-      throw new Error(parseEthersError(error));
+      throw new Error(parseViemError(error));
     } finally {
       setIsProcessing(false);
     }
@@ -397,13 +425,10 @@ export function useOffchainFractions(
     creator: string,
     id: string
   ): Promise<string> {
-    assertSigner(signer);
+    assertWalletClient(walletClient);
+    assertPublicClient(publicClient);
 
     try {
-      const contract = getOffchainFractionsContract();
-      if (!contract)
-        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
-
       setIsProcessing(true);
 
       // Normalize addresses to lowercase for consistency
@@ -427,7 +452,10 @@ export function useOffchainFractions(
         throw new Error(OffchainFractionsError.INVALID_PARAMETERS);
       }
 
-      const owner = await signer.getAddress();
+      const owner = walletClient.account?.address;
+      if (!owner) {
+        throw new Error("No account found in wallet client");
+      }
 
       // Check if user has steps purchased
       const userSteps = await getStepsPurchased(user, creator, id);
@@ -435,9 +463,9 @@ export function useOffchainFractions(
         throw new Error("No steps purchased for this fraction");
       }
 
-      // Run a static call first to surface any revert reason
+      // Run a simulation first to surface any revert reason
       try {
-        console.log("Calling claimRefund static call with:", {
+        console.log("Calling claimRefund simulation with:", {
           user,
           creator,
           id,
@@ -445,22 +473,35 @@ export function useOffchainFractions(
           contractMethod: "claimRefund",
         });
 
-        // Ethers v6 syntax
-        await contract.claimRefund.staticCall(user, creator, id, {
-          from: owner,
+        await publicClient.simulateContract({
+          address: ADDRESSES.OFFCHAIN_FRACTIONS as Address,
+          abi: OFFCHAIN_FRACTIONS_ABI,
+          functionName: "claimRefund",
+          args: [user as Address, creator as Address, id as `0x${string}`],
+          account: walletClient.account!,
         });
-      } catch (staticError) {
-        console.error("Static call failed:", staticError);
-        throw new Error(parseEthersError(staticError));
+      } catch (simulationError) {
+        console.error("Simulation failed:", simulationError);
+        throw new Error(parseViemError(simulationError));
       }
 
-      // Execute the transaction (ethers v6 syntax)
-      const tx = await contract.claimRefund(user, creator, id);
-      await tx.wait();
+      // Execute the transaction
+      const hash = await walletClient.writeContract({
+        address: ADDRESSES.OFFCHAIN_FRACTIONS as Address,
+        abi: OFFCHAIN_FRACTIONS_ABI,
+        functionName: "claimRefund",
+        args: [user as Address, creator as Address, id as `0x${string}`],
+        chain: walletClient.chain,
+        account: walletClient.account!,
+      });
 
-      return tx.hash;
+      await publicClient.waitForTransactionReceipt({
+        hash,
+      });
+
+      return hash;
     } catch (error) {
-      throw new Error(parseEthersError(error));
+      throw new Error(parseViemError(error));
     } finally {
       setIsProcessing(false);
     }
@@ -472,13 +513,10 @@ export function useOffchainFractions(
    * @param id The unique identifier of the fraction sale to close
    */
   async function closeFraction(creator: string, id: string): Promise<string> {
-    assertSigner(signer);
+    assertWalletClient(walletClient);
+    assertPublicClient(publicClient);
 
     try {
-      const contract = getOffchainFractionsContract();
-      if (!contract)
-        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
-
       setIsProcessing(true);
 
       // Validate parameters
@@ -486,24 +524,41 @@ export function useOffchainFractions(
         throw new Error(OffchainFractionsError.INVALID_PARAMETERS);
       }
 
-      const owner = await signer.getAddress();
+      const owner = walletClient.account?.address;
+      if (!owner) {
+        throw new Error("No account found in wallet client");
+      }
 
-      // Run a static call first to surface any revert reason
+      // Run a simulation first to surface any revert reason
       try {
-        await contract.getFunction("closeFraction").staticCall(creator, id, {
-          from: owner,
+        await publicClient.simulateContract({
+          address: ADDRESSES.OFFCHAIN_FRACTIONS as Address,
+          abi: OFFCHAIN_FRACTIONS_ABI,
+          functionName: "closeFraction",
+          args: [creator as Address, id as `0x${string}`],
+          account: walletClient.account!,
         });
-      } catch (staticError) {
-        throw new Error(parseEthersError(staticError));
+      } catch (simulationError) {
+        throw new Error(parseViemError(simulationError));
       }
 
       // Execute the transaction
-      const tx = await contract.getFunction("closeFraction")(creator, id);
-      await tx.wait();
+      const hash = await walletClient.writeContract({
+        address: ADDRESSES.OFFCHAIN_FRACTIONS as Address,
+        abi: OFFCHAIN_FRACTIONS_ABI,
+        functionName: "closeFraction",
+        args: [creator as Address, id as `0x${string}`],
+        chain: walletClient.chain,
+        account: walletClient.account!,
+      });
+
+      await publicClient.waitForTransactionReceipt({
+        hash,
+      });
 
-      return tx.hash;
+      return hash;
     } catch (error) {
-      throw new Error(parseEthersError(error));
+      throw new Error(parseViemError(error));
     } finally {
       setIsProcessing(false);
     }
@@ -518,14 +573,15 @@ export function useOffchainFractions(
     creator: string,
     id: string
   ): Promise<FractionData> {
-    assertSigner(signer);
+    assertPublicClient(publicClient);
 
     try {
-      const contract = getOffchainFractionsContract();
-      if (!contract)
-        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
-
-      const result = await contract.getFunction("getFraction")(creator, id);
+      const result = (await publicClient.readContract({
+        address: ADDRESSES.OFFCHAIN_FRACTIONS as Address,
+        abi: OFFCHAIN_FRACTIONS_ABI,
+        functionName: "getFraction",
+        args: [creator as Address, id as `0x${string}`],
+      })) as any;
 
       return {
         token: result.token,
@@ -541,7 +597,7 @@ export function useOffchainFractions(
         closer: result.closer,
       };
     } catch (error) {
-      throw new Error(parseEthersError(error));
+      throw new Error(parseViemError(error));
     }
   }
 
@@ -556,31 +612,28 @@ export function useOffchainFractions(
     creator: string,
     id: string
   ): Promise<bigint> {
-    assertSigner(signer);
+    assertPublicClient(publicClient);
 
     try {
-      const contract = getOffchainFractionsContract();
-      if (!contract)
-        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
-
       // Debug logging
       console.log("getStepsPurchased parameters:", {
         user,
         creator,
         id,
-        contractAddress: contract.address,
+        contractAddress: ADDRESSES.OFFCHAIN_FRACTIONS,
       });
 
-      const result = await contract.getFunction("stepsPurchased")(
-        user,
-        creator,
-        id
-      );
+      const result = (await publicClient.readContract({
+        address: ADDRESSES.OFFCHAIN_FRACTIONS as Address,
+        abi: OFFCHAIN_FRACTIONS_ABI,
+        functionName: "stepsPurchased",
+        args: [user as Address, creator as Address, id as `0x${string}`],
+      })) as bigint;
 
       console.log("getStepsPurchased result:", result.toString());
       return result;
     } catch (error) {
-      throw new Error(parseEthersError(error));
+      throw new Error(parseViemError(error));
     }
   }
 
@@ -589,17 +642,18 @@ export function useOffchainFractions(
    * @returns The wildcard operator address that can perform refunds for any user
    */
   async function getRefundWildcardOperator(): Promise<string> {
-    assertSigner(signer);
+    assertPublicClient(publicClient);
 
     try {
-      const contract = getOffchainFractionsContract();
-      if (!contract)
-        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
-
-      const result = await contract.getFunction("REFUND_WILDCARD_OPERATOR")();
+      const result = (await publicClient.readContract({
+        address: ADDRESSES.OFFCHAIN_FRACTIONS as Address,
+        abi: OFFCHAIN_FRACTIONS_ABI,
+        functionName: "REFUND_WILDCARD_OPERATOR",
+        args: [],
+      })) as string;
       return result;
     } catch (error) {
-      throw new Error(parseEthersError(error));
+      throw new Error(parseViemError(error));
     }
   }
 
@@ -614,24 +668,21 @@ export function useOffchainFractions(
     creator: string,
     id: string
   ): Promise<RefundDetails> {
-    assertSigner(signer);
+    assertPublicClient(publicClient);
 
     try {
-      const contract = getOffchainFractionsContract();
-      if (!contract)
-        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
-
-      const result = await contract.getFunction("getRefundDetails")(
-        user,
-        creator,
-        id
-      );
+      const result = (await publicClient.readContract({
+        address: ADDRESSES.OFFCHAIN_FRACTIONS as Address,
+        abi: OFFCHAIN_FRACTIONS_ABI,
+        functionName: "getRefundDetails",
+        args: [user as Address, creator as Address, id as `0x${string}`],
+      })) as any;
       return {
         refundTo: result.refundTo,
         useCounterfactualAddress: result.useCounterfactualAddress,
       };
     } catch (error) {
-      throw new Error(parseEthersError(error));
+      throw new Error(parseViemError(error));
     }
   }
 
@@ -648,13 +699,10 @@ export function useOffchainFractions(
     refundTo: string,
     useCounterfactualAddress: boolean
   ): Promise<string> {
-    assertSigner(signer);
+    assertWalletClient(walletClient);
+    assertPublicClient(publicClient);
 
     try {
-      const contract = getOffchainFractionsContract();
-      if (!contract)
-        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
-
       setIsProcessing(true);
 
       // Validate parameters
@@ -662,31 +710,51 @@ export function useOffchainFractions(
         throw new Error(OffchainFractionsError.INVALID_PARAMETERS);
       }
 
-      const owner = await signer.getAddress();
+      const owner = walletClient.account?.address;
+      if (!owner) {
+        throw new Error("No account found in wallet client");
+      }
 
-      // Run a static call first to surface any revert reason
+      // Run a simulation 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));
+        await publicClient.simulateContract({
+          address: ADDRESSES.OFFCHAIN_FRACTIONS as Address,
+          abi: OFFCHAIN_FRACTIONS_ABI,
+          functionName: "setRefundDetails",
+          args: [
+            creator as Address,
+            id as `0x${string}`,
+            refundTo as Address,
+            useCounterfactualAddress,
+          ],
+          account: walletClient.account!,
+        });
+      } catch (simulationError) {
+        throw new Error(parseViemError(simulationError));
       }
 
       // Execute the transaction
-      const tx = await contract.getFunction("setRefundDetails")(
-        creator,
-        id,
-        refundTo,
-        useCounterfactualAddress
-      );
-      await tx.wait();
+      const hash = await walletClient.writeContract({
+        address: ADDRESSES.OFFCHAIN_FRACTIONS as Address,
+        abi: OFFCHAIN_FRACTIONS_ABI,
+        functionName: "setRefundDetails",
+        args: [
+          creator as Address,
+          id as `0x${string}`,
+          refundTo as Address,
+          useCounterfactualAddress,
+        ],
+        chain: walletClient.chain,
+        account: walletClient.account!,
+      });
+
+      await publicClient.waitForTransactionReceipt({
+        hash,
+      });
 
-      return tx.hash;
+      return hash;
     } catch (error) {
-      throw new Error(parseEthersError(error));
+      throw new Error(parseViemError(error));
     } finally {
       setIsProcessing(false);
     }
@@ -701,13 +769,10 @@ export function useOffchainFractions(
     refundOperator: string,
     isApproved: boolean
   ): Promise<string> {
-    assertSigner(signer);
+    assertWalletClient(walletClient);
+    assertPublicClient(publicClient);
 
     try {
-      const contract = getOffchainFractionsContract();
-      if (!contract)
-        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
-
       setIsProcessing(true);
 
       // Validate parameters
@@ -715,29 +780,41 @@ export function useOffchainFractions(
         throw new Error(OffchainFractionsError.INVALID_PARAMETERS);
       }
 
-      const owner = await signer.getAddress();
+      const owner = walletClient.account?.address;
+      if (!owner) {
+        throw new Error("No account found in wallet client");
+      }
 
-      // Run a static call first to surface any revert reason
+      // Run a simulation first to surface any revert reason
       try {
-        await contract
-          .getFunction("setRefundOperatorStatus")
-          .staticCall(refundOperator, isApproved, {
-            from: owner,
-          });
-      } catch (staticError) {
-        throw new Error(parseEthersError(staticError));
+        await publicClient.simulateContract({
+          address: ADDRESSES.OFFCHAIN_FRACTIONS as Address,
+          abi: OFFCHAIN_FRACTIONS_ABI,
+          functionName: "setRefundOperatorStatus",
+          args: [refundOperator as Address, isApproved],
+          account: walletClient.account!,
+        });
+      } catch (simulationError) {
+        throw new Error(parseViemError(simulationError));
       }
 
       // Execute the transaction
-      const tx = await contract.getFunction("setRefundOperatorStatus")(
-        refundOperator,
-        isApproved
-      );
-      await tx.wait();
+      const hash = await walletClient.writeContract({
+        address: ADDRESSES.OFFCHAIN_FRACTIONS as Address,
+        abi: OFFCHAIN_FRACTIONS_ABI,
+        functionName: "setRefundOperatorStatus",
+        args: [refundOperator as Address, isApproved],
+        chain: walletClient.chain,
+        account: walletClient.account!,
+      });
+
+      await publicClient.waitForTransactionReceipt({
+        hash,
+      });
 
-      return tx.hash;
+      return hash;
     } catch (error) {
-      throw new Error(parseEthersError(error));
+      throw new Error(parseViemError(error));
     } finally {
       setIsProcessing(false);
     }
@@ -752,20 +829,18 @@ export function useOffchainFractions(
     user: string,
     refundOperator: string
   ): Promise<boolean> {
-    assertSigner(signer);
+    assertPublicClient(publicClient);
 
     try {
-      const contract = getOffchainFractionsContract();
-      if (!contract)
-        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
-
-      const result = await contract.getFunction("isRefundOperatorApproved")(
-        user,
-        refundOperator
-      );
+      const result = (await publicClient.readContract({
+        address: ADDRESSES.OFFCHAIN_FRACTIONS as Address,
+        abi: OFFCHAIN_FRACTIONS_ABI,
+        functionName: "isRefundOperatorApproved",
+        args: [user as Address, refundOperator as Address],
+      })) as boolean;
       return result;
     } catch (error) {
-      throw new Error(parseEthersError(error));
+      throw new Error(parseViemError(error));
     }
   }
 
@@ -778,20 +853,18 @@ export function useOffchainFractions(
     user: string,
     refundOperator: string
   ): Promise<boolean> {
-    assertSigner(signer);
+    assertPublicClient(publicClient);
 
     try {
-      const contract = getOffchainFractionsContract();
-      if (!contract)
-        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
-
-      const result = await contract.getFunction("refundApprovals")(
-        user,
-        refundOperator
-      );
+      const result = (await publicClient.readContract({
+        address: ADDRESSES.OFFCHAIN_FRACTIONS as Address,
+        abi: OFFCHAIN_FRACTIONS_ABI,
+        functionName: "refundApprovals",
+        args: [user as Address, refundOperator as Address],
+      })) as any;
       return result.isApproved;
     } catch (error) {
-      throw new Error(parseEthersError(error));
+      throw new Error(parseViemError(error));
     }
   }
 
@@ -808,7 +881,7 @@ export function useOffchainFractions(
       const fraction = await getFraction(creator, id);
       return Date.now() / 1000 > fraction.expiration;
     } catch (error) {
-      throw new Error(parseEthersError(error));
+      throw new Error(parseViemError(error));
     }
   }
 
@@ -825,7 +898,7 @@ export function useOffchainFractions(
       const fraction = await getFraction(creator, id);
       return fraction.soldSteps >= fraction.minSharesToRaise;
     } catch (error) {
-      throw new Error(parseEthersError(error));
+      throw new Error(parseViemError(error));
     }
   }
 
@@ -842,7 +915,7 @@ export function useOffchainFractions(
       const fraction = await getFraction(creator, id);
       return fraction.soldSteps >= fraction.totalSteps;
     } catch (error) {
-      throw new Error(parseEthersError(error));
+      throw new Error(parseViemError(error));
     }
   }
 
@@ -859,7 +932,7 @@ export function useOffchainFractions(
       const fraction = await getFraction(creator, id);
       return fraction.soldSteps * fraction.step;
     } catch (error) {
-      throw new Error(parseEthersError(error));
+      throw new Error(parseViemError(error));
     }
   }
 
@@ -876,7 +949,7 @@ export function useOffchainFractions(
       const fraction = await getFraction(creator, id);
       return fraction.totalSteps - fraction.soldSteps;
     } catch (error) {
-      throw new Error(parseEthersError(error));
+      throw new Error(parseViemError(error));
     }
   }
 
@@ -889,13 +962,10 @@ export function useOffchainFractions(
     params: CreateFractionParams,
     ethPriceInUSD: number | null
   ): Promise<string> {
-    assertSigner(signer);
+    assertWalletClient(walletClient);
+    assertPublicClient(publicClient);
 
     try {
-      const contract = getOffchainFractionsContract();
-      if (!contract)
-        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
-
       const {
         id,
         token,
@@ -908,26 +978,28 @@ export function useOffchainFractions(
         closer,
       } = params;
 
-      const feeData = await signer.provider?.getFeeData();
-      const gasPrice =
-        feeData?.gasPrice ?? feeData?.maxFeePerGas ?? (0n as bigint);
-      if (gasPrice === 0n) {
+      const gasPrice = await publicClient.getGasPrice();
+      if (!gasPrice) {
         throw new Error("Could not fetch gas price to estimate cost.");
       }
 
-      const estimatedGas: bigint = await contract
-        .getFunction("createFraction")
-        .estimateGas(
-          id,
-          token,
+      const estimatedGas = await publicClient.estimateContractGas({
+        address: ADDRESSES.OFFCHAIN_FRACTIONS as Address,
+        abi: OFFCHAIN_FRACTIONS_ABI,
+        functionName: "createFraction",
+        args: [
+          id as `0x${string}`,
+          token as Address,
           step,
           totalSteps,
           expiration,
-          to,
+          to as Address,
           useCounterfactualAddress,
           minSharesToRaise,
-          closer
-        );
+          closer as Address,
+        ],
+        account: walletClient.account!,
+      });
 
       const estimatedCost: bigint = estimatedGas * gasPrice;
 
@@ -943,7 +1015,7 @@ export function useOffchainFractions(
         );
       }
     } catch (error: any) {
-      throw new Error(parseEthersError(error));
+      throw new Error(parseViemError(error));
     }
   }
 
@@ -956,13 +1028,10 @@ export function useOffchainFractions(
     params: BuyFractionsParams,
     ethPriceInUSD: number | null
   ): Promise<string> {
-    assertSigner(signer);
+    assertWalletClient(walletClient);
+    assertPublicClient(publicClient);
 
     try {
-      const contract = getOffchainFractionsContract();
-      if (!contract)
-        throw new Error(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
-
       const {
         creator,
         id,
@@ -973,24 +1042,26 @@ export function useOffchainFractions(
         useCounterfactualAddressForRefund,
       } = params;
 
-      const feeData = await signer.provider?.getFeeData();
-      const gasPrice =
-        feeData?.gasPrice ?? feeData?.maxFeePerGas ?? (0n as bigint);
-      if (gasPrice === 0n) {
+      const gasPrice = await publicClient.getGasPrice();
+      if (!gasPrice) {
         throw new Error("Could not fetch gas price to estimate cost.");
       }
 
-      const estimatedGas: bigint = await contract
-        .getFunction("buyFractions")
-        .estimateGas(
-          creator,
-          id,
+      const estimatedGas = await publicClient.estimateContractGas({
+        address: ADDRESSES.OFFCHAIN_FRACTIONS as Address,
+        abi: OFFCHAIN_FRACTIONS_ABI,
+        functionName: "buyFractions",
+        args: [
+          creator as Address,
+          id as `0x${string}`,
           stepsToBuy,
           minStepsToBuy,
-          refundTo,
-          creditTo,
-          useCounterfactualAddressForRefund
-        );
+          refundTo as Address,
+          creditTo as Address,
+          useCounterfactualAddressForRefund,
+        ],
+        account: walletClient.account!,
+      });
 
       const estimatedCost: bigint = estimatedGas * gasPrice;
 
@@ -1006,7 +1077,7 @@ export function useOffchainFractions(
         );
       }
     } catch (error: any) {
-      throw new Error(parseEthersError(error));
+      throw new Error(parseViemError(error));
     }
   }
 
@@ -1051,7 +1122,7 @@ export function useOffchainFractions(
     },
     addresses: ADDRESSES,
 
-    // Signer availability
-    isSignerAvailable: !!signer,
+    // Wallet client availability
+    isSignerAvailable: !!walletClient,
   };
 }