@glowlabs-org/utils 0.2.113 → 0.2.115

package/dist/esm/{farms-router-CDZkFsAs.js → farms-router-BUi6rxeX.js}

@@ -223,7 +223,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",
@@ -288,7 +288,7 @@ var ForwarderError;
     ForwarderError["MISSING_REQUIRED_PARAMS"] = "Missing required parameters";
 })(ForwarderError || (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;
@@ -315,7 +315,7 @@ function parseEthersError$1(error) {
     return 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(ForwarderError.SIGNER_NOT_AVAILABLE);
     }
@@ -330,7 +330,7 @@ function useForwarder(signer, CHAIN_ID) {
     };
     // Returns a contract instance for Forwarder
     function getForwarderContract() {
-        assertSigner$1(signer);
+        assertSigner(signer);
         return new Contract(ADDRESSES.FORWARDER, FORWARDER_ABI, signer);
     }
     /**
@@ -392,7 +392,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":
@@ -415,7 +415,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)
@@ -424,7 +424,7 @@ function useForwarder(signer, CHAIN_ID) {
             return allowance;
         }
         catch (error) {
-            throw new Error(parseEthersError$1(error));
+            throw new Error(parseEthersError(error));
         }
     }
     /**
@@ -433,7 +433,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)
@@ -442,7 +442,7 @@ function useForwarder(signer, CHAIN_ID) {
             return balance;
         }
         catch (error) {
-            throw new Error(parseEthersError$1(error));
+            throw new Error(parseEthersError(error));
         }
     }
     /**
@@ -451,7 +451,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)
@@ -463,7 +463,7 @@ function useForwarder(signer, CHAIN_ID) {
             return true;
         }
         catch (error) {
-            throw new Error(parseEthersError$1(error));
+            throw new Error(parseEthersError(error));
         }
         finally {
             setIsProcessing(false);
@@ -474,7 +474,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)
@@ -506,7 +506,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
@@ -544,7 +544,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;
@@ -560,7 +560,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);
@@ -570,7 +570,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.");
@@ -588,7 +588,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.");
         }
@@ -604,7 +604,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,
@@ -617,7 +617,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,
@@ -630,7 +630,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.");
@@ -647,7 +647,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.");
@@ -663,7 +663,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,
@@ -676,7 +676,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,
@@ -689,7 +689,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");
         }
@@ -707,7 +707,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)
@@ -761,7 +761,7 @@ function useForwarder(signer, CHAIN_ID) {
             }
         }
         catch (error) {
-            throw new Error(parseEthersError$1(error));
+            throw new Error(parseEthersError(error));
         }
     }
     /**
@@ -770,7 +770,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");
         }
@@ -786,7 +786,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");
             }
@@ -1298,40 +1298,37 @@ var OffchainFractionsError;
     OffchainFractionsError["INSUFFICIENT_BALANCE"] = "Insufficient balance";
     OffchainFractionsError["INSUFFICIENT_ALLOWANCE"] = "Insufficient allowance";
 })(OffchainFractionsError || (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 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(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
@@ -1339,17 +1336,11 @@ function useOffchainFractions(signer, CHAIN_ID) {
     const setIsProcessing = (value) => {
         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) {
-        assertSigner(signer);
-        return new 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
@@ -1357,16 +1348,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(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));
         }
     }
     /**
@@ -1375,16 +1368,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(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));
         }
     }
     /**
@@ -1393,18 +1388,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(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);
@@ -1415,11 +1417,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(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
             setIsProcessing(true);
             const { id, token, step, totalSteps, expiration, to, useCounterfactualAddress, minSharesToRaise, closer, } = params;
             // Validate parameters
@@ -1432,22 +1432,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);
@@ -1458,11 +1491,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(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
             setIsProcessing(true);
             const { creator, id, stepsToBuy, minStepsToBuy, refundTo, creditTo, useCounterfactualAddressForRefund, } = params;
             // Validate parameters
@@ -1478,7 +1509,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) {
@@ -1487,28 +1521,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);
@@ -1521,11 +1590,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(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
             setIsProcessing(true);
             // Normalize addresses to lowercase for consistency
             const normalizedUser = user?.toLowerCase();
@@ -1545,37 +1612,52 @@ function useOffchainFractions(signer, CHAIN_ID) {
             if (!normalizedUser || !normalizedCreator || !id) {
                 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);
             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);
@@ -1587,33 +1669,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(OffchainFractionsError.CONTRACT_NOT_AVAILABLE);
             setIsProcessing(true);
             // Validate parameters
             if (!creator || !id) {
                 throw new Error(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);
@@ -1625,12 +1721,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(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),
@@ -1646,7 +1744,7 @@ function useOffchainFractions(signer, CHAIN_ID) {
             };
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
     }
     /**
@@ -1656,24 +1754,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(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));
         }
     }
     /**
@@ -1681,16 +1781,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(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));
         }
     }
     /**
@@ -1700,19 +1802,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(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));
         }
     }
     /**
@@ -1723,35 +1827,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(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
+            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);
@@ -1763,35 +1889,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(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
+            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);
@@ -1803,16 +1941,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(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));
         }
     }
     /**
@@ -1821,16 +1961,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(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));
         }
     }
     /**
@@ -1844,7 +1986,7 @@ function useOffchainFractions(signer, CHAIN_ID) {
             return Date.now() / 1000 > fraction.expiration;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
     }
     /**
@@ -1858,7 +2000,7 @@ function useOffchainFractions(signer, CHAIN_ID) {
             return fraction.soldSteps >= fraction.minSharesToRaise;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
     }
     /**
@@ -1872,7 +2014,7 @@ function useOffchainFractions(signer, CHAIN_ID) {
             return fraction.soldSteps >= fraction.totalSteps;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
     }
     /**
@@ -1886,7 +2028,7 @@ function useOffchainFractions(signer, CHAIN_ID) {
             return fraction.soldSteps * fraction.step;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
     }
     /**
@@ -1900,7 +2042,7 @@ function useOffchainFractions(signer, CHAIN_ID) {
             return fraction.totalSteps - fraction.soldSteps;
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
     }
     /**
@@ -1909,20 +2051,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(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 = formatEther(estimatedCost);
@@ -1934,7 +2087,7 @@ function useOffchainFractions(signer, CHAIN_ID) {
             }
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
     }
     /**
@@ -1943,20 +2096,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(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 = formatEther(estimatedCost);
@@ -1968,7 +2130,7 @@ function useOffchainFractions(signer, CHAIN_ID) {
             }
         }
         catch (error) {
-            throw new Error(parseEthersError(error));
+            throw new Error(parseViemError(error));
         }
     }
     return {
@@ -2005,8 +2167,8 @@ function useOffchainFractions(signer, CHAIN_ID) {
             return isProcessing;
         },
         addresses: ADDRESSES,
-        // Signer availability
-        isSignerAvailable: !!signer,
+        // Wallet client availability
+        isSignerAvailable: !!walletClient,
     };
 }
 
@@ -3409,4 +3571,4 @@ function FarmsRouter(baseUrl) {
 }
 
 export { ControlRouter as C, DECIMALS_BY_TOKEN as D, FarmsRouter as F, GLOW_WEIGHT_DECIMAL_PRECISION as G, HUB_URL as H, KickstarterRouter as K, MAX_WEIGHT as M, OffchainFractionsError as O, PAYMENT_CURRENCIES as P, RegionRouter as R, TRANSFER_TYPES as T, USDG_WEIGHT_DECIMAL_PRECISION as U, WalletsRouter as W, useOffchainFractions as a, ForwarderError as b, REGIONS as c, OFF_CHAIN_PAYMENT_CURRENCIES as d, allRegions as e, usStates as f, countries as g, FORWARDER_ABI as h, OFFCHAIN_FRACTIONS_ABI as i, getAddresses as j, GCA_URLS as k, regionMetadata as r, useForwarder as u };
-//# sourceMappingURL=farms-router-CDZkFsAs.js.map
+//# sourceMappingURL=farms-router-BUi6rxeX.js.map