@glowlabs-org/utils 0.2.113 → 0.2.115

package/dist/cjs/{farms-router-djet_3Cn.js → farms-router-CuZE5YJ_.js}

@@ -225,7 +225,7 @@ const sepoliaAddresses = {
     USDG_UNISWAP: "0x2a085A3aEA8982396533327c854753Ce521B666d",
     GLW_UNISWAP: "0x8e27016D0B866a56CE74A1a280c749dD679bb0Fa",
     FORWARDER: "0xDaC24F18171224eeaf6a9B38f5C5081aDbDff969",
-    OFFCHAIN_FRACTIONS: "0x9976d13930bdEB80C03706B7a6333B00fdee3BB3",
+    OFFCHAIN_FRACTIONS: "0x7D97528eeF8B8D17AA1Ba3307Ed39b07b3A1b69B",
     COUNTERFACTUAL_HOLDER_FACTORY: "0x2c3AB887746F6f4a8a4b9Db6aC800eb71945509A",
     FOUNDATION_WALLET: "0x5e230FED487c86B90f6508104149F087d9B1B0A7",
     UNISWAP_V2_ROUTER: "0xeE567Fe1712Faf6149d80dA1E6934E354124CfE3",
@@ -290,7 +290,7 @@ exports.ForwarderError = void 0;
     ForwarderError["MISSING_REQUIRED_PARAMS"] = "Missing required parameters";
 })(exports.ForwarderError || (exports.ForwarderError = {}));
 // Utility to extract the most useful revert reason from an ethers error object
-function parseEthersError$1(error) {
+function parseEthersError(error) {
     if (!error)
         return "Unknown error";
     const possibleError = error;
@@ -317,7 +317,7 @@ function parseEthersError$1(error) {
     return exports.ForwarderError.UNKNOWN_ERROR;
 }
 // Type-guard style helper to ensure a signer exists throughout the rest of the function.
-function assertSigner$1(maybeSigner) {
+function assertSigner(maybeSigner) {
     if (!maybeSigner) {
         throw new Error(exports.ForwarderError.SIGNER_NOT_AVAILABLE);
     }
@@ -332,7 +332,7 @@ function useForwarder(signer, CHAIN_ID) {
     };
     // Returns a contract instance for Forwarder
     function getForwarderContract() {
-        assertSigner$1(signer);
+        assertSigner(signer);
         return new ethers.Contract(ADDRESSES.FORWARDER, FORWARDER_ABI, signer);
     }
     /**
@@ -394,7 +394,7 @@ function useForwarder(signer, CHAIN_ID) {
      * Get the appropriate token contract based on currency
      */
     function getTokenContract(currency = "USDC") {
-        assertSigner$1(signer);
+        assertSigner(signer);
         let tokenAddress;
         switch (currency) {
             case "USDC":
@@ -417,7 +417,7 @@ function useForwarder(signer, CHAIN_ID) {
      * @param currency The currency to check allowance for
      */
     async function checkTokenAllowance(owner, currency = "USDC") {
-        assertSigner$1(signer);
+        assertSigner(signer);
         try {
             const tokenContract = getTokenContract(currency);
             if (!tokenContract)
@@ -426,7 +426,7 @@ function useForwarder(signer, CHAIN_ID) {
             return allowance;
         }
         catch (error) {
-            throw new Error(parseEthersError$1(error));
+            throw new Error(parseEthersError(error));
         }
     }
     /**
@@ -435,7 +435,7 @@ function useForwarder(signer, CHAIN_ID) {
      * @param currency The currency to check balance for
      */
     async function checkTokenBalance(owner, currency = "USDC") {
-        assertSigner$1(signer);
+        assertSigner(signer);
         try {
             const tokenContract = getTokenContract(currency);
             if (!tokenContract)
@@ -444,7 +444,7 @@ function useForwarder(signer, CHAIN_ID) {
             return balance;
         }
         catch (error) {
-            throw new Error(parseEthersError$1(error));
+            throw new Error(parseEthersError(error));
         }
     }
     /**
@@ -453,7 +453,7 @@ function useForwarder(signer, CHAIN_ID) {
      * @param currency The currency to approve
      */
     async function approveToken(amount, currency = "USDC") {
-        assertSigner$1(signer);
+        assertSigner(signer);
         try {
             const tokenContract = getTokenContract(currency);
             if (!tokenContract)
@@ -465,7 +465,7 @@ function useForwarder(signer, CHAIN_ID) {
             return true;
         }
         catch (error) {
-            throw new Error(parseEthersError$1(error));
+            throw new Error(parseEthersError(error));
         }
         finally {
             setIsProcessing(false);
@@ -476,7 +476,7 @@ function useForwarder(signer, CHAIN_ID) {
      * @param params Forward parameters including type, amount, and required fields
      */
     async function forwardTokens(params) {
-        assertSigner$1(signer);
+        assertSigner(signer);
         try {
             const forwarderContract = getForwarderContract();
             if (!forwarderContract)
@@ -508,7 +508,7 @@ function useForwarder(signer, CHAIN_ID) {
                     await approveTx.wait();
                 }
                 catch (approveError) {
-                    throw new Error(parseEthersError$1(approveError) || "Token approval failed");
+                    throw new Error(parseEthersError(approveError) || "Token approval failed");
                 }
             }
             // Get the token address based on currency
@@ -546,7 +546,7 @@ function useForwarder(signer, CHAIN_ID) {
                 }
             }
             catch (staticError) {
-                throw new Error(parseEthersError$1(staticError));
+                throw new Error(parseEthersError(staticError));
             }
             // Execute the forward transaction
             let tx;
@@ -562,7 +562,7 @@ function useForwarder(signer, CHAIN_ID) {
             return tx.hash;
         }
         catch (txError) {
-            throw new Error(parseEthersError$1(txError));
+            throw new Error(parseEthersError(txError));
         }
         finally {
             setIsProcessing(false);
@@ -572,7 +572,7 @@ function useForwarder(signer, CHAIN_ID) {
      * Forward tokens for protocol fee payment and GCTL minting with staking
      */
     async function payProtocolFeeAndMintGCTLAndStake(amount, userAddress, applicationId, regionId, currency = "USDC") {
-        assertSigner$1(signer);
+        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.");
@@ -590,7 +590,7 @@ function useForwarder(signer, CHAIN_ID) {
      * Forward tokens for protocol fee payment and GCTL minting with staking
      */
     async function sponsorProtocolFeeAndMintGCTLAndStake(amount, userAddress, applicationId, currency = "USDC") {
-        assertSigner$1(signer);
+        assertSigner(signer);
         if (currency === "GLW") {
             throw new Error("GCTL minting is not supported with GLW payment. Use USDC or USDG.");
         }
@@ -606,7 +606,7 @@ function useForwarder(signer, CHAIN_ID) {
      * Forward tokens for protocol fee payment only
      */
     async function payProtocolFee(amount, userAddress, applicationId, currency = "USDC") {
-        assertSigner$1(signer);
+        assertSigner(signer);
         return forwardTokens({
             amount,
             userAddress,
@@ -619,7 +619,7 @@ function useForwarder(signer, CHAIN_ID) {
      * Forward tokens for protocol fee payment only
      */
     async function sponsorProtocolFee(amount, userAddress, applicationId, currency = "USDC") {
-        assertSigner$1(signer);
+        assertSigner(signer);
         return forwardTokens({
             amount,
             userAddress,
@@ -632,7 +632,7 @@ function useForwarder(signer, CHAIN_ID) {
      * Forward USDC to mint GCTL and stake to a region
      */
     async function mintGCTLAndStake(amount, userAddress, regionId, currency = "USDC") {
-        assertSigner$1(signer);
+        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.");
@@ -649,7 +649,7 @@ function useForwarder(signer, CHAIN_ID) {
      * Forward USDC to mint GCTL (existing functionality, keeping for compatibility)
      */
     async function mintGCTL(amount, userAddress, currency = "USDC") {
-        assertSigner$1(signer);
+        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.");
@@ -665,7 +665,7 @@ function useForwarder(signer, CHAIN_ID) {
      * Forward tokens to pay audit fees (USDC only, calls forward())
      */
     async function payAuditFees(amount, userAddress, applicationId) {
-        assertSigner$1(signer);
+        assertSigner(signer);
         return forwardTokens({
             amount,
             userAddress,
@@ -678,7 +678,7 @@ function useForwarder(signer, CHAIN_ID) {
      * Forward tokens to buy a solar farm
      */
     async function buySolarFarm(amount, userAddress, farmId, currency = "USDC") {
-        assertSigner$1(signer);
+        assertSigner(signer);
         return forwardTokens({
             amount,
             userAddress,
@@ -691,7 +691,7 @@ function useForwarder(signer, CHAIN_ID) {
      * Forward tokens to commit to a Kickstarter (USDC or USDG only)
      */
     async function commitKickstarter(amount, userAddress, kickstarterId, currency = "USDC") {
-        assertSigner$1(signer);
+        assertSigner(signer);
         if (currency === "GLW") {
             throw new Error("CommitKickstarter supports only USDC or USDG");
         }
@@ -709,7 +709,7 @@ function useForwarder(signer, CHAIN_ID) {
      * @param ethPriceInUSD Current ETH price in USD (for cost estimation)
      */
     async function estimateGasForForward(params, ethPriceInUSD) {
-        assertSigner$1(signer);
+        assertSigner(signer);
         try {
             const forwarderContract = getForwarderContract();
             if (!forwarderContract)
@@ -763,7 +763,7 @@ function useForwarder(signer, CHAIN_ID) {
             }
         }
         catch (error) {
-            throw new Error(parseEthersError$1(error));
+            throw new Error(parseEthersError(error));
         }
     }
     /**
@@ -772,7 +772,7 @@ function useForwarder(signer, CHAIN_ID) {
      * @param recipient Address to mint USDC to
      */
     async function mintTestUSDC(amount, recipient) {
-        assertSigner$1(signer);
+        assertSigner(signer);
         if (CHAIN_ID !== 11155111) {
             throw new Error("Minting test USDC is only supported on Sepolia");
         }
@@ -788,7 +788,7 @@ function useForwarder(signer, CHAIN_ID) {
         }
         catch (error) {
             // If mint function doesn't exist or fails, provide helpful error
-            const errorMessage = parseEthersError$1(error);
+            const errorMessage = parseEthersError(error);
             if (errorMessage.includes("mint")) {
                 throw new Error("This USDC contract doesn't support minting");
             }
@@ -1300,40 +1300,37 @@ exports.OffchainFractionsError = void 0;
     OffchainFractionsError["INSUFFICIENT_BALANCE"] = "Insufficient balance";
     OffchainFractionsError["INSUFFICIENT_ALLOWANCE"] = "Insufficient allowance";
 })(exports.OffchainFractionsError || (exports.OffchainFractionsError = {}));
-// Utility to extract the most useful revert reason from an ethers error object
-function parseEthersError(error) {
+// Utility to extract the most useful revert reason from a viem error object
+function parseViemError(error) {
     if (!error)
         return "Unknown error";
-    const possibleError = 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;
+    // Check if it's a viem BaseError
+    if (error instanceof Error) {
+        // For contract revert errors
+        if (error.cause?.reason) {
+            return error.cause.reason;
+        }
+        // For viem's shortMessage
+        if (error.shortMessage) {
+            return error.shortMessage;
+        }
+        // Fallback to regular message
+        if (error.message) {
+            return error.message;
         }
-        catch { }
     }
-    // Found on MetaMask/Alchemy shape errors
-    if (possibleError?.data?.message)
-        return possibleError.data.message;
-    if (possibleError?.error?.message)
-        return possibleError.error.message;
-    // Standard ethers v5 message
-    if (possibleError?.reason)
-        return possibleError.reason;
-    if (possibleError?.message)
-        return possibleError.message;
     return exports.OffchainFractionsError.UNKNOWN_ERROR;
 }
-// Type-guard style helper to ensure a signer exists throughout the rest of the function.
-function assertSigner(maybeSigner) {
-    if (!maybeSigner) {
+// Type-guard style helper to ensure a wallet client exists throughout the rest of the function.
+function assertWalletClient(maybeWalletClient) {
+    if (!maybeWalletClient) {
         throw new Error(exports.OffchainFractionsError.SIGNER_NOT_AVAILABLE);
     }
+    if (!maybeWalletClient.account) {
+        throw new Error("Wallet client must have an account");
+    }
 }
-function useOffchainFractions(signer, CHAIN_ID) {
+function useOffchainFractions(walletClient, publicClient, CHAIN_ID) {
     // Use dynamic addresses based on chain configuration
     const ADDRESSES = getAddresses(CHAIN_ID);
     // Framework-agnostic processing flag
@@ -1341,17 +1338,11 @@ function useOffchainFractions(signer, CHAIN_ID) {
     const setIsProcessing = (value) => {
         isProcessing = value;
     };
-    // Returns a contract instance for OffchainFractions
-    function getOffchainFractionsContract() {
-        assertSigner(signer);
-        return new ethers.Contract(ADDRESSES.OFFCHAIN_FRACTIONS, OFFCHAIN_FRACTIONS_ABI, signer);
-    }
-    /**
-     * Get the appropriate token contract
-     */
-    function getTokenContract(tokenAddress) {
-        assertSigner(signer);
-        return new ethers.Contract(tokenAddress, ERC20_ABI, signer);
+    // Helper to assert public client is available
+    function assertPublicClient(maybePublicClient) {
+        if (!maybePublicClient) {
+            throw new Error("Public client not available");
+        }
     }
     /**
      * Check current token allowance for the offchain fractions contract
@@ -1359,16 +1350,18 @@ function useOffchainFractions(signer, CHAIN_ID) {
      * @param tokenAddress The token contract address
      */
     async function checkTokenAllowance(owner, tokenAddress) {
-        assertSigner(signer);
+        assertPublicClient(publicClient);
         try {
-            const tokenContract = getTokenContract(tokenAddress);
-            if (!tokenContract)
-                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
-            const allowance = await tokenContract.allowance(owner, ADDRESSES.OFFCHAIN_FRACTIONS);
+            const allowance = await publicClient.readContract({
+                address: tokenAddress,
+                abi: ERC20_ABI,
+                functionName: "allowance",
+                args: [owner, ADDRESSES.OFFCHAIN_FRACTIONS],
+            });
             return allowance;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
     }
     /**
@@ -1377,16 +1370,18 @@ function useOffchainFractions(signer, CHAIN_ID) {
      * @param tokenAddress The token contract address
      */
     async function checkTokenBalance(owner, tokenAddress) {
-        assertSigner(signer);
+        assertPublicClient(publicClient);
         try {
-            const tokenContract = getTokenContract(tokenAddress);
-            if (!tokenContract)
-                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
-            const balance = await tokenContract.balanceOf(owner);
+            const balance = await publicClient.readContract({
+                address: tokenAddress,
+                abi: ERC20_ABI,
+                functionName: "balanceOf",
+                args: [owner],
+            });
             return balance;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
     }
     /**
@@ -1395,18 +1390,25 @@ function useOffchainFractions(signer, CHAIN_ID) {
      * @param amount Amount to approve (BigNumber)
      */
     async function approveToken(tokenAddress, amount) {
-        assertSigner(signer);
+        assertWalletClient(walletClient);
+        assertPublicClient(publicClient);
         try {
-            const tokenContract = getTokenContract(tokenAddress);
-            if (!tokenContract)
-                throw new Error(exports.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,
+                abi: ERC20_ABI,
+                functionName: "approve",
+                args: [ADDRESSES.OFFCHAIN_FRACTIONS, 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);
@@ -1417,11 +1419,9 @@ function useOffchainFractions(signer, CHAIN_ID) {
      * @param params Parameters for creating the fraction
      */
     async function createFraction(params) {
-        assertSigner(signer);
+        assertWalletClient(walletClient);
+        assertPublicClient(publicClient);
         try {
-            const contract = getOffchainFractionsContract();
-            if (!contract)
-                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
             setIsProcessing(true);
             const { id, token, step, totalSteps, expiration, to, useCounterfactualAddress, minSharesToRaise, closer, } = params;
             // Validate parameters
@@ -1434,22 +1434,55 @@ function useOffchainFractions(signer, CHAIN_ID) {
             if (minSharesToRaise > totalSteps) {
                 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, step, totalSteps, expiration, to, useCounterfactualAddress, minSharesToRaise, closer);
+                await publicClient.simulateContract({
+                    address: ADDRESSES.OFFCHAIN_FRACTIONS,
+                    abi: OFFCHAIN_FRACTIONS_ABI,
+                    functionName: "createFraction",
+                    args: [
+                        id,
+                        token,
+                        step,
+                        totalSteps,
+                        expiration,
+                        to,
+                        useCounterfactualAddress,
+                        minSharesToRaise,
+                        closer,
+                    ],
+                    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("createFraction")(id, token, step, totalSteps, expiration, to, useCounterfactualAddress, minSharesToRaise, closer);
-            await tx.wait();
-            return tx.hash;
+            const hash = await walletClient.writeContract({
+                address: ADDRESSES.OFFCHAIN_FRACTIONS,
+                abi: OFFCHAIN_FRACTIONS_ABI,
+                functionName: "createFraction",
+                args: [
+                    id,
+                    token,
+                    step,
+                    totalSteps,
+                    expiration,
+                    to,
+                    useCounterfactualAddress,
+                    minSharesToRaise,
+                    closer,
+                ],
+                chain: walletClient.chain,
+                account: walletClient.account,
+            });
+            await publicClient.waitForTransactionReceipt({
+                hash,
+            });
+            return hash;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
         finally {
             setIsProcessing(false);
@@ -1460,11 +1493,9 @@ function useOffchainFractions(signer, CHAIN_ID) {
      * @param params Parameters for buying fractions
      */
     async function buyFractions(params) {
-        assertSigner(signer);
+        assertWalletClient(walletClient);
+        assertPublicClient(publicClient);
         try {
-            const contract = getOffchainFractionsContract();
-            if (!contract)
-                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
             setIsProcessing(true);
             const { creator, id, stepsToBuy, minStepsToBuy, refundTo, creditTo, useCounterfactualAddressForRefund, } = params;
             // Validate parameters
@@ -1480,7 +1511,10 @@ function useOffchainFractions(signer, CHAIN_ID) {
             // Get fraction data to calculate required amount
             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);
             if (balance < requiredAmount) {
@@ -1489,28 +1523,63 @@ function useOffchainFractions(signer, CHAIN_ID) {
             // 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,
+                    abi: ERC20_ABI,
+                    functionName: "approve",
+                    args: [ADDRESSES.OFFCHAIN_FRACTIONS, 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, stepsToBuy, minStepsToBuy, refundTo, creditTo, useCounterfactualAddressForRefund, {
-                    from: owner,
+                await publicClient.simulateContract({
+                    address: ADDRESSES.OFFCHAIN_FRACTIONS,
+                    abi: OFFCHAIN_FRACTIONS_ABI,
+                    functionName: "buyFractions",
+                    args: [
+                        creator,
+                        id,
+                        stepsToBuy,
+                        minStepsToBuy,
+                        refundTo,
+                        creditTo,
+                        useCounterfactualAddressForRefund,
+                    ],
+                    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("buyFractions")(creator, id, stepsToBuy, minStepsToBuy, refundTo, creditTo, useCounterfactualAddressForRefund);
-            await tx.wait();
-            return tx.hash;
+            const hash = await walletClient.writeContract({
+                address: ADDRESSES.OFFCHAIN_FRACTIONS,
+                abi: OFFCHAIN_FRACTIONS_ABI,
+                functionName: "buyFractions",
+                args: [
+                    creator,
+                    id,
+                    stepsToBuy,
+                    minStepsToBuy,
+                    refundTo,
+                    creditTo,
+                    useCounterfactualAddressForRefund,
+                ],
+                chain: walletClient.chain,
+                account: walletClient.account,
+            });
+            await publicClient.waitForTransactionReceipt({
+                hash,
+            });
+            return hash;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
         finally {
             setIsProcessing(false);
@@ -1523,11 +1592,9 @@ function useOffchainFractions(signer, CHAIN_ID) {
      * @param id The unique identifier of the fraction sale
      */
     async function claimRefund(user, creator, id) {
-        assertSigner(signer);
+        assertWalletClient(walletClient);
+        assertPublicClient(publicClient);
         try {
-            const contract = getOffchainFractionsContract();
-            if (!contract)
-                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
             setIsProcessing(true);
             // Normalize addresses to lowercase for consistency
             const normalizedUser = user?.toLowerCase();
@@ -1547,37 +1614,52 @@ function useOffchainFractions(signer, CHAIN_ID) {
             if (!normalizedUser || !normalizedCreator || !id) {
                 throw new Error(exports.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);
             if (userSteps === 0n) {
                 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,
                     from: owner,
                     contractMethod: "claimRefund",
                 });
-                // Ethers v6 syntax
-                await contract.claimRefund.staticCall(user, creator, id, {
-                    from: owner,
+                await publicClient.simulateContract({
+                    address: ADDRESSES.OFFCHAIN_FRACTIONS,
+                    abi: OFFCHAIN_FRACTIONS_ABI,
+                    functionName: "claimRefund",
+                    args: [user, creator, id],
+                    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();
-            return tx.hash;
+            // Execute the transaction
+            const hash = await walletClient.writeContract({
+                address: ADDRESSES.OFFCHAIN_FRACTIONS,
+                abi: OFFCHAIN_FRACTIONS_ABI,
+                functionName: "claimRefund",
+                args: [user, creator, id],
+                chain: walletClient.chain,
+                account: walletClient.account,
+            });
+            await publicClient.waitForTransactionReceipt({
+                hash,
+            });
+            return hash;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
         finally {
             setIsProcessing(false);
@@ -1589,33 +1671,47 @@ function useOffchainFractions(signer, CHAIN_ID) {
      * @param id The unique identifier of the fraction sale to close
      */
     async function closeFraction(creator, id) {
-        assertSigner(signer);
+        assertWalletClient(walletClient);
+        assertPublicClient(publicClient);
         try {
-            const contract = getOffchainFractionsContract();
-            if (!contract)
-                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
             setIsProcessing(true);
             // Validate parameters
             if (!creator || !id) {
                 throw new Error(exports.OffchainFractionsError.INVALID_PARAMETERS);
             }
-            const owner = await signer.getAddress();
-            // Run a static call first to surface any revert reason
+            const owner = walletClient.account?.address;
+            if (!owner) {
+                throw new Error("No account found in wallet client");
+            }
+            // 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,
+                    abi: OFFCHAIN_FRACTIONS_ABI,
+                    functionName: "closeFraction",
+                    args: [creator, id],
+                    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();
-            return tx.hash;
+            const hash = await walletClient.writeContract({
+                address: ADDRESSES.OFFCHAIN_FRACTIONS,
+                abi: OFFCHAIN_FRACTIONS_ABI,
+                functionName: "closeFraction",
+                args: [creator, id],
+                chain: walletClient.chain,
+                account: walletClient.account,
+            });
+            await publicClient.waitForTransactionReceipt({
+                hash,
+            });
+            return hash;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
         finally {
             setIsProcessing(false);
@@ -1627,12 +1723,14 @@ function useOffchainFractions(signer, CHAIN_ID) {
      * @param id The unique identifier of the fraction sale
      */
     async function getFraction(creator, id) {
-        assertSigner(signer);
-        try {
-            const contract = getOffchainFractionsContract();
-            if (!contract)
-                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
-            const result = await contract.getFunction("getFraction")(creator, id);
+        assertPublicClient(publicClient);
+        try {
+            const result = (await publicClient.readContract({
+                address: ADDRESSES.OFFCHAIN_FRACTIONS,
+                abi: OFFCHAIN_FRACTIONS_ABI,
+                functionName: "getFraction",
+                args: [creator, id],
+            }));
             return {
                 token: result.token,
                 expiration: Number(result.expiration),
@@ -1648,7 +1746,7 @@ function useOffchainFractions(signer, CHAIN_ID) {
             };
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
     }
     /**
@@ -1658,24 +1756,26 @@ function useOffchainFractions(signer, CHAIN_ID) {
      * @param id The unique identifier of the fraction sale
      */
     async function getStepsPurchased(user, creator, id) {
-        assertSigner(signer);
+        assertPublicClient(publicClient);
         try {
-            const contract = getOffchainFractionsContract();
-            if (!contract)
-                throw new Error(exports.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,
+                abi: OFFCHAIN_FRACTIONS_ABI,
+                functionName: "stepsPurchased",
+                args: [user, creator, id],
+            }));
             console.log("getStepsPurchased result:", result.toString());
             return result;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
     }
     /**
@@ -1683,16 +1783,18 @@ function useOffchainFractions(signer, CHAIN_ID) {
      * @returns The wildcard operator address that can perform refunds for any user
      */
     async function getRefundWildcardOperator() {
-        assertSigner(signer);
-        try {
-            const contract = getOffchainFractionsContract();
-            if (!contract)
-                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
-            const result = await contract.getFunction("REFUND_WILDCARD_OPERATOR")();
+        assertPublicClient(publicClient);
+        try {
+            const result = (await publicClient.readContract({
+                address: ADDRESSES.OFFCHAIN_FRACTIONS,
+                abi: OFFCHAIN_FRACTIONS_ABI,
+                functionName: "REFUND_WILDCARD_OPERATOR",
+                args: [],
+            }));
             return result;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
     }
     /**
@@ -1702,19 +1804,21 @@ function useOffchainFractions(signer, CHAIN_ID) {
      * @param id The unique identifier of the fraction sale
      */
     async function getRefundDetails(user, creator, id) {
-        assertSigner(signer);
-        try {
-            const contract = getOffchainFractionsContract();
-            if (!contract)
-                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
-            const result = await contract.getFunction("getRefundDetails")(user, creator, id);
+        assertPublicClient(publicClient);
+        try {
+            const result = (await publicClient.readContract({
+                address: ADDRESSES.OFFCHAIN_FRACTIONS,
+                abi: OFFCHAIN_FRACTIONS_ABI,
+                functionName: "getRefundDetails",
+                args: [user, creator, id],
+            }));
             return {
                 refundTo: result.refundTo,
                 useCounterfactualAddress: result.useCounterfactualAddress,
             };
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
     }
     /**
@@ -1725,35 +1829,57 @@ function useOffchainFractions(signer, CHAIN_ID) {
      * @param useCounterfactualAddress Whether to use counterfactual address for refunds
      */
     async function setRefundDetails(creator, id, refundTo, useCounterfactualAddress) {
-        assertSigner(signer);
+        assertWalletClient(walletClient);
+        assertPublicClient(publicClient);
         try {
-            const contract = getOffchainFractionsContract();
-            if (!contract)
-                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
             setIsProcessing(true);
             // Validate parameters
             if (!creator || !id || !refundTo) {
                 throw new Error(exports.OffchainFractionsError.INVALID_PARAMETERS);
             }
-            const owner = await signer.getAddress();
-            // Run a static call first to surface any revert reason
+            const owner = walletClient.account?.address;
+            if (!owner) {
+                throw new Error("No account found in wallet client");
+            }
+            // Run a simulation first to surface any revert reason
             try {
-                await contract
-                    .getFunction("setRefundDetails")
-                    .staticCall(creator, id, refundTo, useCounterfactualAddress, {
-                    from: owner,
+                await publicClient.simulateContract({
+                    address: ADDRESSES.OFFCHAIN_FRACTIONS,
+                    abi: OFFCHAIN_FRACTIONS_ABI,
+                    functionName: "setRefundDetails",
+                    args: [
+                        creator,
+                        id,
+                        refundTo,
+                        useCounterfactualAddress,
+                    ],
+                    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("setRefundDetails")(creator, id, refundTo, useCounterfactualAddress);
-            await tx.wait();
-            return tx.hash;
+            const hash = await walletClient.writeContract({
+                address: ADDRESSES.OFFCHAIN_FRACTIONS,
+                abi: OFFCHAIN_FRACTIONS_ABI,
+                functionName: "setRefundDetails",
+                args: [
+                    creator,
+                    id,
+                    refundTo,
+                    useCounterfactualAddress,
+                ],
+                chain: walletClient.chain,
+                account: walletClient.account,
+            });
+            await publicClient.waitForTransactionReceipt({
+                hash,
+            });
+            return hash;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
         finally {
             setIsProcessing(false);
@@ -1765,35 +1891,47 @@ function useOffchainFractions(signer, CHAIN_ID) {
      * @param isApproved Whether to approve or revoke the operator
      */
     async function setRefundOperatorStatus(refundOperator, isApproved) {
-        assertSigner(signer);
+        assertWalletClient(walletClient);
+        assertPublicClient(publicClient);
         try {
-            const contract = getOffchainFractionsContract();
-            if (!contract)
-                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
             setIsProcessing(true);
             // Validate parameters
             if (!refundOperator) {
                 throw new Error(exports.OffchainFractionsError.INVALID_PARAMETERS);
             }
-            const owner = await signer.getAddress();
-            // Run a static call first to surface any revert reason
+            const owner = walletClient.account?.address;
+            if (!owner) {
+                throw new Error("No account found in wallet client");
+            }
+            // Run a simulation first to surface any revert reason
             try {
-                await contract
-                    .getFunction("setRefundOperatorStatus")
-                    .staticCall(refundOperator, isApproved, {
-                    from: owner,
+                await publicClient.simulateContract({
+                    address: ADDRESSES.OFFCHAIN_FRACTIONS,
+                    abi: OFFCHAIN_FRACTIONS_ABI,
+                    functionName: "setRefundOperatorStatus",
+                    args: [refundOperator, isApproved],
+                    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("setRefundOperatorStatus")(refundOperator, isApproved);
-            await tx.wait();
-            return tx.hash;
+            const hash = await walletClient.writeContract({
+                address: ADDRESSES.OFFCHAIN_FRACTIONS,
+                abi: OFFCHAIN_FRACTIONS_ABI,
+                functionName: "setRefundOperatorStatus",
+                args: [refundOperator, isApproved],
+                chain: walletClient.chain,
+                account: walletClient.account,
+            });
+            await publicClient.waitForTransactionReceipt({
+                hash,
+            });
+            return hash;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
         finally {
             setIsProcessing(false);
@@ -1805,16 +1943,18 @@ function useOffchainFractions(signer, CHAIN_ID) {
      * @param refundOperator The refund operator address
      */
     async function isRefundOperatorApproved(user, refundOperator) {
-        assertSigner(signer);
-        try {
-            const contract = getOffchainFractionsContract();
-            if (!contract)
-                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
-            const result = await contract.getFunction("isRefundOperatorApproved")(user, refundOperator);
+        assertPublicClient(publicClient);
+        try {
+            const result = (await publicClient.readContract({
+                address: ADDRESSES.OFFCHAIN_FRACTIONS,
+                abi: OFFCHAIN_FRACTIONS_ABI,
+                functionName: "isRefundOperatorApproved",
+                args: [user, refundOperator],
+            }));
             return result;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
     }
     /**
@@ -1823,16 +1963,18 @@ function useOffchainFractions(signer, CHAIN_ID) {
      * @param refundOperator The refund operator address
      */
     async function getRefundApprovalStatus(user, refundOperator) {
-        assertSigner(signer);
-        try {
-            const contract = getOffchainFractionsContract();
-            if (!contract)
-                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
-            const result = await contract.getFunction("refundApprovals")(user, refundOperator);
+        assertPublicClient(publicClient);
+        try {
+            const result = (await publicClient.readContract({
+                address: ADDRESSES.OFFCHAIN_FRACTIONS,
+                abi: OFFCHAIN_FRACTIONS_ABI,
+                functionName: "refundApprovals",
+                args: [user, refundOperator],
+            }));
             return result.isApproved;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
     }
     /**
@@ -1846,7 +1988,7 @@ function useOffchainFractions(signer, CHAIN_ID) {
             return Date.now() / 1000 > fraction.expiration;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
     }
     /**
@@ -1860,7 +2002,7 @@ function useOffchainFractions(signer, CHAIN_ID) {
             return fraction.soldSteps >= fraction.minSharesToRaise;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
     }
     /**
@@ -1874,7 +2016,7 @@ function useOffchainFractions(signer, CHAIN_ID) {
             return fraction.soldSteps >= fraction.totalSteps;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
     }
     /**
@@ -1888,7 +2030,7 @@ function useOffchainFractions(signer, CHAIN_ID) {
             return fraction.soldSteps * fraction.step;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
     }
     /**
@@ -1902,7 +2044,7 @@ function useOffchainFractions(signer, CHAIN_ID) {
             return fraction.totalSteps - fraction.soldSteps;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
     }
     /**
@@ -1911,20 +2053,31 @@ function useOffchainFractions(signer, CHAIN_ID) {
      * @param ethPriceInUSD Current ETH price in USD (for cost estimation)
      */
     async function estimateGasForCreateFraction(params, ethPriceInUSD) {
-        assertSigner(signer);
+        assertWalletClient(walletClient);
+        assertPublicClient(publicClient);
         try {
-            const contract = getOffchainFractionsContract();
-            if (!contract)
-                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
             const { id, token, step, totalSteps, expiration, to, useCounterfactualAddress, minSharesToRaise, closer, } = params;
-            const feeData = await signer.provider?.getFeeData();
-            const gasPrice = feeData?.gasPrice ?? feeData?.maxFeePerGas ?? 0n;
-            if (gasPrice === 0n) {
+            const gasPrice = await publicClient.getGasPrice();
+            if (!gasPrice) {
                 throw new Error("Could not fetch gas price to estimate cost.");
             }
-            const estimatedGas = await contract
-                .getFunction("createFraction")
-                .estimateGas(id, token, step, totalSteps, expiration, to, useCounterfactualAddress, minSharesToRaise, closer);
+            const estimatedGas = await publicClient.estimateContractGas({
+                address: ADDRESSES.OFFCHAIN_FRACTIONS,
+                abi: OFFCHAIN_FRACTIONS_ABI,
+                functionName: "createFraction",
+                args: [
+                    id,
+                    token,
+                    step,
+                    totalSteps,
+                    expiration,
+                    to,
+                    useCounterfactualAddress,
+                    minSharesToRaise,
+                    closer,
+                ],
+                account: walletClient.account,
+            });
             const estimatedCost = estimatedGas * gasPrice;
             if (ethPriceInUSD) {
                 const estimatedCostInEth = viem.formatEther(estimatedCost);
@@ -1936,7 +2089,7 @@ function useOffchainFractions(signer, CHAIN_ID) {
             }
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
     }
     /**
@@ -1945,20 +2098,29 @@ function useOffchainFractions(signer, CHAIN_ID) {
      * @param ethPriceInUSD Current ETH price in USD (for cost estimation)
      */
     async function estimateGasForBuyFractions(params, ethPriceInUSD) {
-        assertSigner(signer);
+        assertWalletClient(walletClient);
+        assertPublicClient(publicClient);
         try {
-            const contract = getOffchainFractionsContract();
-            if (!contract)
-                throw new Error(exports.OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
             const { creator, id, stepsToBuy, minStepsToBuy, refundTo, creditTo, useCounterfactualAddressForRefund, } = params;
-            const feeData = await signer.provider?.getFeeData();
-            const gasPrice = feeData?.gasPrice ?? feeData?.maxFeePerGas ?? 0n;
-            if (gasPrice === 0n) {
+            const gasPrice = await publicClient.getGasPrice();
+            if (!gasPrice) {
                 throw new Error("Could not fetch gas price to estimate cost.");
             }
-            const estimatedGas = await contract
-                .getFunction("buyFractions")
-                .estimateGas(creator, id, stepsToBuy, minStepsToBuy, refundTo, creditTo, useCounterfactualAddressForRefund);
+            const estimatedGas = await publicClient.estimateContractGas({
+                address: ADDRESSES.OFFCHAIN_FRACTIONS,
+                abi: OFFCHAIN_FRACTIONS_ABI,
+                functionName: "buyFractions",
+                args: [
+                    creator,
+                    id,
+                    stepsToBuy,
+                    minStepsToBuy,
+                    refundTo,
+                    creditTo,
+                    useCounterfactualAddressForRefund,
+                ],
+                account: walletClient.account,
+            });
             const estimatedCost = estimatedGas * gasPrice;
             if (ethPriceInUSD) {
                 const estimatedCostInEth = viem.formatEther(estimatedCost);
@@ -1970,7 +2132,7 @@ function useOffchainFractions(signer, CHAIN_ID) {
             }
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
     }
     return {
@@ -2007,8 +2169,8 @@ function useOffchainFractions(signer, CHAIN_ID) {
             return isProcessing;
         },
         addresses: ADDRESSES,
-        // Signer availability
-        isSignerAvailable: !!signer,
+        // Wallet client availability
+        isSignerAvailable: !!walletClient,
     };
 }
 
@@ -3433,4 +3595,4 @@ exports.regionMetadata = regionMetadata;
 exports.usStates = usStates;
 exports.useForwarder = useForwarder;
 exports.useOffchainFractions = useOffchainFractions;
-//# sourceMappingURL=farms-router-djet_3Cn.js.map
+//# sourceMappingURL=farms-router-CuZE5YJ_.js.map